packages feed

sbv 6.1 → 7.0

raw patch · 429 files changed

+48936/−43867 lines, 429 filesdep +Globdep +bytestringdep +doctestdep −HUnitdep −base-compatdep −old-timedep ~base

Dependencies added: Glob, bytestring, doctest, generic-deriving, hlint, tasty, tasty-golden, tasty-hunit, template-haskell, time

Dependencies removed: HUnit, base-compat, old-time

Dependency ranges changed: base

Files

CHANGES.md view
@@ -1,8 +1,126 @@ * Hackage: <http://hackage.haskell.org/package/sbv> * GitHub:  <http://leventerkok.github.com/sbv/> -* Latest Hackage released version: 6.1, 2017-05-26+* Latest Hackage released version: 7.0, 2017-07-19 +### Version 7.0, Released 2017-07-19++  * NB. SBV now requires GHC >= 8.0.1 to compile. If you are stuck with an older+    version of GHC, please get in contact.++  * This is a major rewrite of the internals of SBV, and is a backwards compatibility+    breaking release. While we kept the top-level and most commonly used APIs the+    same (both types and semantics), much of the internals and advanced features+    have been rewritten to move SBV to a new model of execution: SBV no longer+    runs your program symbolically and calls the SMT solver afterwards. Instead,+    the interaction with the solver happens interleaved with the actual program execution.+    The motivation is to allow the end-users to send/receive arbitrary SMTLib+    commands to the solver, instead of the cooked-up recipes. SBV still provides+    all the recipes for its existing functionality, but users can now interact+    with the solver directly. See the module "Data.SBV.Control" for the main+    API, together with the new functions 'runSMT' and 'runSMTWith'.++  * The 'Tactic' based solver control (introduced in v6.0) is completely removed, and+    is replaced by the above described mechanism which gives the user a lot of+    flexibility instead. Use queries for anything that required a tactic before.++  * The call 'allSat' has been reworked so it performs only one call to the underlying+    solver and repeatedly issues check-sat to get new assignments. This differs from the+    previous implementation where we spun off a new call to the executable for each+    successive model. While this is more efficient and much more preferable, it also+    means that the results are no longer lazily computed: If there is an infinite number+    of solutions (or a very large number), you can no longer merely do a 'take' on the result.+    While this is inconvenient, it fits better with our new methodology of query based+    interaction. Note that the old behavior can be modeled, if required, by the user; by explicitly+    interleaving the calls to 'sat.' Furthermore, we now provide a new configuration+    parameter named 'allSatMaxModelCount' which can be used to limit the number models we+    seek. The default is to get all models, however long that might take.++  * The Bridge modules (`Data.SBV.Bridge.Yices`, `Data.SBV.Bridge.Z3`) etc. are+    all removed. The bridge functionality was hardly used, where different solvers+    were much easier to access using the `with` functions. (Such as `proveWith`,+    `satWith` etc.) This should result in no loss of functionality, except for+    occasional explicit mention of solvers in your code, if you were using+    bridge modules to start with.++  * Optimization routines have been changed to take a priority as an argument, (i.e.,+    Lexicographic, Independent, etc.). The old method of supplying the priority+    via tactics is no longer supported.++  * Pareto-front extraction has been reworked, reflecting the changes in Z3 for+    this functionality. Since pareto-fronts can be infinite in number, the user+    is now allowed to specify a "limit" to stop the solver from querying ad+    infinitum. If the limit is not specified, then sbv will query till it+    exhausts all the pareto-fronts, or till it runs out of memory in case there+    is an infinite number of them.++  * Extraction of unsat-cores has changed. To use this feature, we now use+    custom queries. See "Data.SBV.Examples.Misc.UnsatCore" for an example.+    Old style of unsat-core extraction is no longer supported.++  * The 'timing' option of SMTConfig has been reworked. Since we now start the+    solver immediately, it is no longer sensible to distinguish between "SBV" time,+    "translation" time etc. Instead, we print one simple "Elapsed" time if requested.+    If you need a detailed timing analysis, use the new 'transcript' option to+    SMTConfig: It will produce a file with precise timing intervals for each+    command issued to help you figure out how long each step took.++  * The following functions have been reworked, so they now also return+    the time-elapsed for each solver:++        satWithAll   :: Provable a => [SMTConfig] -> a -> IO [(Solver, NominalDiffTime, SatResult)]+        satWithAny   :: Provable a => [SMTConfig] -> a -> IO  (Solver, NominalDiffTime, SatResult)+        proveWithAll :: Provable a => [SMTConfig] -> a -> IO [(Solver, NominalDiffTime, ThmResult)]+        proveWithAny :: Provable a => [SMTConfig] -> a -> IO  (Solver, NominalDiffTime, ThmResult)++  * Changed the way `satWithAny` and `proveWithAny` works. Previously, these+    two functions ran multiple solvers, and took the result of the first+    one to finish, killing all the others. In addition, they *waitied* for+    the still-running solvers to finish cleaning-up, as sending a 'ThreadKilled'+    is usually not instantaneous. Furthermore, a solver might simply take+    its time! We now send the interrupt but do not wait for the process to+    actually terminate. In rare occasions this could create zombie processes+    if you use a solver that is not cooperating, but we have seen not insignificant+    speed-ups for regular usage due to ThreadKilled wait times being rather long.++  * Configuration option `useLogic` is removed. If required, this should+    be done by a call to the new 'setLogic' function:++        setLogic QF_NRA++  * Configuration option `timeOut` is removed. This was rarely used, and the solver+    support was rather sketchy. We now have a better mechanism in the query mode+    for timeouts, where it really matters. Please get in touch if you relied on+    this old mechanism. Correspondingly, the functions `isTheorem`, `isSatisfiable`,+    `isTheoremWith` and `isSatisfiableWith` had their time-out arguments removed+    and return types simplified.++  * The function 'isSatisfiableInCurrentPath' is removed. Proper queries should be used+    for what this function tentatively attempted to provide. Please get in touch+    if you relied on this function and want to restructure your code to use proper queries.++  * Configuration option 'smtFile' is removed. Instead use 'transcript' now, which+    provides a much more detailed output that is directly loadable to a solver+    and has an accurate account of precisely what SBV sent.++  * Enumerations are now much easier to use symbolically, with the addition+    of the template-haskell splice mkSymbolicEnumeration. See "Data/SBV/Examples/Misc/Enumerate.hs"+    for an example.++  * Thanks to Kanishka Azimi, our external test suite is now run by+    Tasty! Kanishka modernized the test suite, and reworked the+    infrastructure that was showing its age. Thanks!++  * The function pConstrain and the Data.SBV.Tools.ExpectedValue are+    removed. Probabilistic constraints were rarely used, and if+    necessary can be implemented outside of SBV. If you were using+    this feature, please get in contact.++  * SArray and SFunArray has been reworked, and they no longer take+    and initial value. Similarly resetArray has been removed, as it+    did not really do what it advertised. If an initial value is needed,+    it is best to code this explicitly in your model.+ ### Version 6.1, 2017-05-26    * Add support for unsat-core extraction. To use this feature, use@@ -54,6 +172,9 @@     Currently, only Z3 supports pseudo-booleans directly. For all other solvers,     SBV will translate these to equivalent terms that do not require special     functions.++  * The function getModel has been renamed to getAssignment. (The former name is+    now available as a query command.)    * Export `SolverCapabilities` from `Data.SBV.Internals`, in case users want access.
Data/SBV.hs view
@@ -78,7 +78,7 @@ -- If a predicate is not valid, 'prove' will return a counterexample: An -- assignment to inputs such that the predicate fails. The 'sat' function will -- return a satisfying assignment, if there is one. The 'allSat' function returns--- all satisfying assignments, lazily.+-- all satisfying assignments. -- -- The sbv library uses third-party SMT solvers via the standard SMT-Lib interface: -- <http://smtlib.cs.uiowa.edu/>@@ -105,8 +105,12 @@ -- get in touch if there is a solver you'd like to see included. --------------------------------------------------------------------------------- -{-# LANGUAGE    FlexibleInstances #-}-{-# OPTIONS_GHC -fno-warn-orphans #-}+{-# LANGUAGE    FlexibleInstances   #-}+{-# LANGUAGE    QuasiQuotes         #-}+{-# LANGUAGE    TemplateHaskell     #-}+{-# LANGUAGE    ScopedTypeVariables #-}+{-# LANGUAGE    StandaloneDeriving  #-}+{-# OPTIONS_GHC -fno-warn-orphans  #-}  module Data.SBV (   -- * Programming with symbolic values@@ -123,13 +127,9 @@   -- *** Signed unbounded integers   -- $unboundedLimitations   , SInteger-  -- *** IEEE-floating point numbers+  -- *** Floating point numbers   -- $floatingPoints-  , SFloat, SDouble, IEEEFloating(..), IEEEFloatConvertable(..), RoundingMode(..), SRoundingMode, nan, infinity, sNaN, sInfinity-  -- **** Rounding modes-  , sRoundNearestTiesToEven, sRoundNearestTiesToAway, sRoundTowardPositive, sRoundTowardNegative, sRoundTowardZero, sRNE, sRNA, sRTP, sRTN, sRTZ-  -- **** Bit-pattern conversions-  , sFloatAsSWord32, sWord32AsSFloat, sDoubleAsSWord64, sWord64AsSDouble, blastSFloat, blastSDouble+  , SFloat, SDouble   -- *** Signed algebraic reals   -- $algReals   , SReal, AlgReal, sRealToSInteger@@ -143,7 +143,7 @@   , sBools, sWord8s, sWord16s, sWord32s, sWord64s, sInt8s, sInt16s, sInt32s, sInt64s, sIntegers, sReals, sFloats, sDoubles    -- *** Abstract SBV type-  , SBV+  , SBV, HasKind(..), Kind(..)   -- *** Arrays of symbolic values   , SymArray(..), SArray, SFunArray, mkSFunArray @@ -172,60 +172,45 @@   , Boolean(..)   -- *** Generalizations of boolean operations   , bAnd, bOr, bAny, bAll-  -- ** Pretty-printing and reading numbers in Hex & Binary-  , PrettyNum(..), readBin-  -- * Checking satisfiability in path conditions-  , isSatisfiableInCurrentPath    -- * Uninterpreted sorts, constants, and functions   -- $uninterpreted   , Uninterpreted(..), addAxiom    -- * Symbolic Equality and Comparisons-  , EqSymbolic(..), OrdSymbolic(..)-  -- * Cardinality constraints+  , EqSymbolic(..), OrdSymbolic(..), Equality(..)++  -- * Constraints+  -- $constrainIntro+  , constrain, namedConstraint+  -- ** Cardinality constraints   -- $cardIntro   , pbAtMost, pbAtLeast, pbExactly, pbLe, pbGe, pbEq, pbMutexed, pbStronglyMutexed    -- * Enumerations   -- $enumerations+  , mkSymbolicEnumeration    -- * Properties, proofs, satisfiability, and safety   -- $proveIntro   -- $noteOnNestedQuantifiers-  -- ** Predicates and Goals-  , Predicate, Goal, Provable(..), Equality(..)-  -- ** Proving properties-  , prove, proveWith, isTheorem, isTheoremWith-  -- ** Checking satisfiability-  , sat, satWith, isSatisfiable, isSatisfiableWith+  -- $multiIntro+  , Predicate, Goal, Provable(..)   -- ** Checking safety   -- $safeIntro-  , sAssert, safe, safeWith, isSafe, SExecutable(..)-  -- ** Finding all satisfying assignments-  , allSat, allSatWith+  , sAssert, isSafe, SExecutable(..)   -- ** Satisfying a sequence of boolean conditions   , solve-  -- ** Adding constraints-  -- $constrainIntro-  , constrain, namedConstraint, pConstrain -  -- ** Checking constraint vacuity-  , isVacuous, isVacuousWith   -- ** Quick-checking   , sbvQuickCheck -  -- * Proving properties using multiple solvers-  -- $multiIntro-  , proveWithAll, proveWithAny, satWithAll, satWithAny--  -- * Tactics-  -- $tacticIntro-  , Tactic(..), tactic+  -- * Running a symbolic computation+  , runSMT, runSMTWith    -- * Optimization   -- $optiIntro-  , OptimizeStyle(..), Penalty(..), Objective(..), minimize, maximize, assertSoft, optimize, optimizeWith+  , OptimizeStyle(..), Penalty(..), Objective(..), minimize, maximize, assertSoft   , ExtCW(..), GeneralizedCW(..)    -- * Model extraction@@ -235,15 +220,22 @@   -- $resultTypes   , ThmResult(..), SatResult(..), AllSatResult(..), SafeResult(..), OptimizeResult(..), SMTResult(..) +  -- * IEEE-floating point numbers+  , IEEEFloating(..), IEEEFloatConvertable(..), RoundingMode(..), SRoundingMode, nan, infinity, sNaN, sInfinity+  -- ** Rounding modes+  , sRoundNearestTiesToEven, sRoundNearestTiesToAway, sRoundTowardPositive, sRoundTowardNegative, sRoundTowardZero, sRNE, sRNA, sRTP, sRTN, sRTZ+  -- ** Bit-pattern conversions+  , sFloatAsSWord32, sWord32AsSFloat, sDoubleAsSWord64, sWord64AsSDouble, blastSFloat, blastSDouble+   -- ** Programmable model extraction   -- $programmableExtraction   , SatModel(..), Modelable(..), displayModels, extractModels   , getModelDictionaries, getModelValues, getModelUninterpretedValues    -- * SMT Interface: Configurations and solvers-  , SMTConfig(..), SMTLibVersion(..), SMTLibLogic(..), Logic(..), Solver(..), SMTSolver(..)-  , boolector, cvc4, yices, z3, mathSAT, abc, defaultSolverConfig, sbvCurrentSolver, defaultSMTCfg, sbvCheckSolverInstallation, sbvAvailableSolvers-  , Timing(..), TimedStep(..), TimingInfo, showTDiff, CW(..), HasKind(..), Kind(..), cwToBool+  , SMTConfig(..), Timing(..), SMTLibVersion(..), Solver(..), SMTSolver(..)+  , boolector, cvc4, yices, z3, mathSAT, abc, defaultSolverConfig, defaultSMTCfg, sbvCheckSolverInstallation, sbvAvailableSolvers+  , setLogic, setOption, setInfo, setTimeOut    -- * Symbolic computations   , Symbolic, output, SymWord(..)@@ -257,10 +249,10 @@   , module Data.Ratio   ) where -import Control.Monad            (filterM)-import Control.Concurrent.Async (async, waitAny, waitAnyCancel)-import System.IO.Unsafe         (unsafeInterleaveIO)             -- only used safely!+import Control.Monad (filterM) +import qualified Control.Exception as C+ import Data.SBV.Core.AlgReals import Data.SBV.Core.Data import Data.SBV.Core.Model@@ -270,20 +262,16 @@ import Data.SBV.Provers.Prover  import Data.SBV.Utils.Boolean-import Data.SBV.Utils.TDiff-import Data.SBV.Utils.PrettyNum+import Data.SBV.Utils.TDiff   (Timing(..))  import Data.Bits import Data.Int import Data.Ratio import Data.Word --- | The currently active solver, obtained by importing "Data.SBV".--- To have other solvers /current/, import one of the bridge--- modules "Data.SBV.Bridge.ABC", "Data.SBV.Bridge.Boolector", "Data.SBV.Bridge.CVC4",--- "Data.SBV.Bridge.Yices", or "Data.SBV.Bridge.Z3" directly.-sbvCurrentSolver :: SMTConfig-sbvCurrentSolver = z3+import qualified Language.Haskell.TH as TH+import Data.Generics+import Data.SBV.Control.Utils(SMTValue)  -- | Form the symbolic conjunction of a given list of boolean conditions. Useful in expressing -- problems with constraints, like the following:@@ -298,10 +286,11 @@ -- | Check whether the given solver is installed and is ready to go. This call does a -- simple call to the solver to ensure all is well. sbvCheckSolverInstallation :: SMTConfig -> IO Bool-sbvCheckSolverInstallation cfg = do ThmResult r <- proveWith cfg $ \x -> (x+x) .== ((x*2) :: SWord8)-                                    case r of-                                      Unsatisfiable{} -> return True-                                      _               -> return False+sbvCheckSolverInstallation cfg = check `C.catch` (\(_ :: C.SomeException) -> return False)+  where check = do ThmResult r <- proveWith cfg $ \x -> (x+x) .== ((x*2) :: SWord8)+                   case r of+                     Unsatisfiable{} -> return True+                     _               -> return False  -- | The default configs corresponding to supported SMT solvers defaultSolverConfig :: Solver -> SMTConfig@@ -316,44 +305,6 @@ sbvAvailableSolvers :: IO [SMTConfig] sbvAvailableSolvers = filterM sbvCheckSolverInstallation (map defaultSolverConfig [minBound .. maxBound]) -sbvWithAny :: [SMTConfig] -> (SMTConfig -> a -> IO b) -> a -> IO (Solver, b)-sbvWithAny []      _    _ = error "SBV.withAny: No solvers given!"-sbvWithAny solvers what a = snd `fmap` (mapM try solvers >>= waitAnyCancel)-   where try s = async $ what s a >>= \r -> return (name (solver s), r)--sbvWithAll :: [SMTConfig] -> (SMTConfig -> a -> IO b) -> a -> IO [(Solver, b)]-sbvWithAll solvers what a = mapM try solvers >>= (unsafeInterleaveIO . go)-   where try s = async $ what s a >>= \r -> return (name (solver s), r)-         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)---- | Prove a property with multiple solvers, running them in separate threads. The--- results will be returned in the order produced.-proveWithAll :: Provable a => [SMTConfig] -> a -> IO [(Solver, ThmResult)]-proveWithAll  = (`sbvWithAll` proveWith)---- | 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.-proveWithAny :: Provable a => [SMTConfig] -> a -> IO (Solver, ThmResult)-proveWithAny  = (`sbvWithAny` proveWith)---- | Find a satisfying assignment to a property with multiple solvers, running them in separate threads. The--- results will be returned in the order produced.-satWithAll :: Provable a => [SMTConfig] -> a -> IO [(Solver, SatResult)]-satWithAll = (`sbvWithAll` satWith)---- | 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.-satWithAny :: Provable a => [SMTConfig] -> a -> IO (Solver, SatResult)-satWithAny    = (`sbvWithAny` satWith)- -- If we get a program producing nothing (i.e., Symbolic ()), pretend it simply returns True. -- This is useful since min/max calls and constraints will provide the context instance Provable Goal where@@ -410,6 +361,21 @@ instance {-# OVERLAPPABLE #-} (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SymWord g, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> z) where   k === l = prove $ \a b c d e f g -> k (a, b, c, d, e, f, g) .== l (a, b, c, d, e, f, g) +-- | Make an enumeration a symbolic type.+mkSymbolicEnumeration :: TH.Name -> TH.Q [TH.Dec]+mkSymbolicEnumeration typeName = do+    let typeCon = TH.conT typeName+    [d| deriving instance Eq       $(typeCon)+        deriving instance Show     $(typeCon)+        deriving instance Ord      $(typeCon)+        deriving instance Read     $(typeCon)+        deriving instance Data     $(typeCon)+        deriving instance SymWord  $(typeCon)+        deriving instance HasKind  $(typeCon)+        deriving instance SMTValue $(typeCon)+        deriving instance SatModel $(typeCon)+      |]+ -- Haddock section documentation {- $progIntro The SBV library is really two things:@@ -431,6 +397,15 @@ executable within Haskell, without the need for any custom interpreters. (They are truly Haskell programs, not AST's built out of pieces of syntax.) This provides for an integrated feel of the system, one of the original design goals for SBV.++= Incremental mode: Queries++SBV provides a wide variety of ways to utilize SMT-solvers, without requiring the user to+deal with the solvers themselves. While this mode is convenient, advanced users might need+access to the underlying solver, using the SMTLib language. For such use cases, SBV allows+users to have an interactive session: The user can issue commands to the solver, inspect+the values/results, and formulate new constraints. This advanced feature is available through+the "Data.SBV.Control" module, where most SMTLib features are made available via a typed-API. -}  {- $proveIntro@@ -484,8 +459,8 @@  >>> safe (sub :: SInt8 -> SInt8 -> SInt8) [sub: x >= y must hold!: Violated. Model:-  s0 = -128 :: Int8-  s1 = -127 :: Int8]+  s0 = 30 :: Int8+  s1 = 32 :: Int8]  What happens if we make sure to arrange for this invariant? Consider this version: @@ -506,13 +481,6 @@ -}  -{- $tacticIntro-In certain cases, the prove/sat calls can benefit from user guidance, in terms of tactics. From a semantic view,-a tactic has no effect on the meaning of a predicate. It is merely guidance for SBV to guide the proof. It is-also used for executing cases in parallel ('ParallelCase'), or picking the logic to use ('UseLogic'), or-specifying a timeout ('StopAfter'). For most users, default values of these should suffice.--}- {- $optiIntro   SBV can optimize metric functions, i.e., those that generate both bounded 'SIntN', 'SWordN', and unbounded 'SInteger'   types, along with those produce 'SReal's. That is, it can find models satisfying all the constraints while minimizing@@ -539,56 +507,51 @@    Here's an optimization example in action: -  >>> optimize $ \x y -> minimize "goal" (x+2*(y::SInteger))+  >>> optimize Lexicographic $ \x y -> minimize "goal" (x+2*(y::SInteger))   Optimal in an extension field:     goal = -oo :: Integer -  Of course, this becomes more useful when the result is not in an extension field:--  @-      optimize $ do x <- sInteger "x"-                    y <- sInteger "y"--                    constrain $ x .> 0-                    constrain $ x .< 6-                    constrain $ y .> 2-                    constrain $ y .< 12--                    minimize "goal" (x+2*(y::SInteger))-  @+  We will describe the role of the constructor 'Lexicographic' shortly. -  This will produce:+  Of course, this becomes more useful when the result is not in an extension field: -  @-  Optimal model:-    x    = 1 :: Integer-    y    = 3 :: Integer-    goal = 7 :: Integer-   @+>>> :{+    optimize Lexicographic $ do+                  x <- sInteger "x"+                  y <- sInteger "y"+                  constrain $ x .> 0+                  constrain $ x .< 6+                  constrain $ y .> 2+                  constrain $ y .< 12+                  minimize "goal" $ x + 2 * y+    :}+Optimal model:+  x    = 1 :: Integer+  y    = 3 :: Integer+  goal = 7 :: Integer    As usual, the programmatic API can be used to extract the values of objectives and model-values ('getModelObjectives',-  'getModel', etc.) to access these values and program with them further.+  'getModelAssignment', etc.) to access these values and program with them further.  == Multiple optimization goals    Multiple goals can be specified, using the same syntax. In this case, the user gets to pick what style of-  optimization to perform:--    * The default is lexicographic. That is, solver will optimize the goals in the given order, optimizing-      the latter ones under the model that optimizes the previous ones. This is the default behavior, but-      can also be explicitly specified by:--       @ 'tactic' $ 'OptimizePriority' 'Lexicographic' @+  optimization to perform, by passing the relevant 'OptimizeStyle' as the first argument to 'optimize'. -    * Goals can also be independently optimized. In this case the user will be presented a model for each-      goal given. To enable this, use the tactic:+    * ['Lexicographic']. The solver will optimize the goals in the given order, optimizing+      the latter ones under the model that optimizes the previous ones. -       @ 'tactic' $ 'OptimizePriority' 'Independent' @+    * ['Independent']. The solver will optimize the goals independently of each other. In this case the user will+      be presented a model for each goal given. -    * Finally, the user can query for pareto-fronts. A pareto front is an model such that no goal can be made-      "better" without making some other goal "worse." To enable this style, use:+    * ['Pareto']. Finally, the user can query for pareto-fronts. A pareto front is an model such that no goal can be made+      "better" without making some other goal "worse." -       @ 'tactic' $ 'OptimizePriority' 'Pareto' @+      The optional number argument to 'Pareto' specifies the maximum number of pareto-fronts the user is asking+      to get. If 'Nothing', SBV will query for all pareto-fronts. Note that pareto-fronts can be infinite+      in number, so if 'Nothing' is used, there is a potential for infinitely waiting for the SBV-solver interaction+      to finish. (If you suspect this might be the case, run in 'verbose' mode to see the interaction and+      put a limiting factor appropriately.)  == Soft Assertions @@ -764,46 +727,59 @@ can take arbitrarily long in the presence of constraints, if the random input values generated rarely satisfy the constraints. (As an extreme case, consider @'constrain' 'false'@.) -A probabilistic constraint (see 'pConstrain') attaches a probability threshold for the-constraint to be considered. For instance:+=== Named constraints and unsat cores -  @ 'pConstrain' 0.8 c @+Constraints can be given names: -will make sure that the condition @c@ is satisfied 80% of the time (and correspondingly, falsified 20%-of the time), in expectation. This variant is useful for 'genTest' and 'quickCheck' functions, where we-want to filter the test cases according to some probability distribution, to make sure that the test-vectors-are drawn from interesting subsets of the input space. For instance, if we were to generate 100 test cases-with the above constraint, we'd expect about 80 of them to satisfy the condition @c@, while about 20 of them-will fail it.+  @ 'namedConstraint' "a is at least 5" $ a .>= 5@ -The following properties hold:+Such constraints are useful when used in conjunction with 'getUnsatCore' function+where the backend solver can be queried to obtain an unsat core in case the constraints are unsatisfiable.+This feature is enabled by the following tactic: -  @-    'constrain'      = 'pConstrain' 1-    'pConstrain' t c = 'pConstrain' (1-t) (not c)-  @+   @ tactic $ SetOptions [ProduceUnsatCores True] @ -Note that while 'constrain' can be used freely, 'pConstrain' is only allowed in the contexts of-'genTest' or 'quickCheck'. Calls to 'pConstrain' in a prove/sat call will be rejected as SBV does not-deal with probabilistic constraints when it comes to satisfiability and proofs.-Also, both 'constrain' and 'pConstrain' calls during code-generation will also be rejected, for similar reasons.+See "Data.SBV.Examples.Misc.UnsatCore" for an example use case. -=== Named constraints and unsat cores+=== Constraint vacuity -Constraints can be given names:+When adding constraints, one has to be careful about+making sure they are not inconsistent. The function 'isVacuous' can be use for this purpose.+Here is an example. Consider the following predicate: -  @ 'namedConstraint' "a is at least 5" $ a .>= 5@+    >>> let pred = do { x <- free "x"; constrain $ x .< x; return $ x .>= (5 :: SWord8) } -Such constraints are useful when used in conjunction with 'getUnsatCore', and 'extractUnsatCore' features,-where the backend solver can be queried to obtain an unsat core in case the constraints are unsatisfiable:+This predicate asserts that all 8-bit values are larger than 5, subject to the constraint that the+values considered satisfy @x .< x@, i.e., they are less than themselves. Since there are no values that+satisfy this constraint, the proof will pass vacuously: -   @ satWith z3{getUnsatCore=True} $ do ... @+    >>> prove pred+    Q.E.D. -See "Data.SBV.Examples.Misc.UnsatCore" for an example use case.+We can use 'isVacuous' to make sure to see that the pass was vacuous: -=== Constraint vacuity+    >>> isVacuous pred+    True -SBV does not check that a given constraints is not vacuous. That is, that it can never be satisfied. This is usually+While the above example is trivial, things can get complicated if there are multiple constraints with+non-straightforward relations; so if constraints are used one should make sure to check the predicate+is not vacuously true. Here's an example that is not vacuous:++     >>> let pred' = do { x <- free "x"; constrain $ x .> 6; return $ x .>= (5 :: SWord8) }++This time the proof passes as expected:++     >>> prove pred'+     Q.E.D.++And the proof is not vacuous:++     >>> isVacuous pred'+     False++=== Checking for vacuity++As we discussed SBV does not check that a given constraints is not vacuous. That is, that it can never be satisfied. This is usually the right behavior, since checking vacuity can be costly. The functions 'isVacuous' and 'isVacuousWith' should be used to explicitly check for constraint vacuity if desired. Alternatively, the tactic: @@ -824,8 +800,10 @@ (Note that you'll also need to use the language pragmas @DeriveDataTypeable@, @DeriveAnyClass@, and import @Data.Generics@ for the above to work.)   This is all it takes to introduce 'B' as an uninterpreted sort in SBV, which makes the type @SBV B@ automagically become available as the type-of symbolic values that ranges over 'B' values. Note that the @()@ argument is important to distinguish it from enumerations.+of symbolic values that ranges over 'B' values. Note that the @()@ argument is important to distinguish it from enumerations, which will be+translated to proper SMT data-types. + Uninterpreted functions over both uninterpreted and regular sorts can be declared using the facilities introduced by the 'Uninterpreted' class. -}@@ -834,15 +812,24 @@ If the uninterpreted sort definition takes the form of an enumeration (i.e., a simple data type with all nullary constructors), then SBV will actually translate that as just such a data-type to SMT-Lib, and will use the constructors as the inhabitants of the said sort. A simple example is: -  @-    data X = A | B | C deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind, SatModel)-  @+@+    data X = A | B | C+    mkSymbolicEnumeration ''X+@ +Note the magic incantation @mkSymbolicEnumeration ''X@. For this to work, you need to have the following+options turned on:++>   LANGUAGE TemplateHaskell+>   LANGUAGE StandaloneDeriving+>   LANGUAGE DeriveDataTypeable+>   LANGUAGE DeriveAnyClass+ Now, the user can define -  @+@     type SX = SBV X-  @+@  and treat @SX@ as a regular symbolic type ranging over the values @A@, @B@, and @C@. Such values can be compared for equality, and with the usual other comparison operators, such as @.==@, @./=@, @.>@, @.>=@, @<@, and @<=@.@@ -850,13 +837,13 @@ Note that in this latter case the type is no longer uninterpreted, but is properly represented as a simple enumeration of the said elements. A simple query would look like: -   @+@      allSat $ \x -> x .== (x :: SX)-   @+@  which would list all three elements of this domain as satisfying solutions. -   @+@      Solution #1:        s0 = A :: X      Solution #2:@@ -864,10 +851,12 @@      Solution #3:        s0 = C :: X      Found 3 different solutions.-   @+@ -Note that the result is properly typed as @X@ elements; these are not mere strings. So, in a 'getModel' scenario, the user can recover actual+Note that the result is properly typed as @X@ elements; these are not mere strings. So, in a 'getModelAssignment' scenario, the user can recover actual elements of the domain and program further with those values as usual.++See "Data.SBV.Examples.Misc.Enumerate" for an extended example on how to use symbolic enumerations. -}  {- $noteOnNestedQuantifiers
− Data/SBV/Bridge/ABC.hs 
@@ -1,92 +0,0 @@------------------------------------------------------------------------------------- |--- Module      :  Data.SBV.Bridge.ABC--- Copyright   :  (c) Adam Foltzer--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Interface to the ABC verification and synthesis tool. Import this--- module if you want to use ABC as your backend solver. Also see:------       - "Data.SBV.Bridge.Boolector"--- ---       - "Data.SBV.Bridge.CVC4"--- ---       - "Data.SBV.Bridge.MathSAT"--- ---       - "Data.SBV.Bridge.Yices"--- ---       - "Data.SBV.Bridge.Z3"---------------------------------------------------------------------------------------module Data.SBV.Bridge.ABC (-  -- * ABC specific interface-  sbvCurrentSolver-  -- ** Proving, checking satisfiability, optimization-  , prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable-  -- * Non-Boolector specific SBV interface-  -- $moduleExportIntro-  , module Data.SBV-  ) where--import Data.SBV hiding (prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable, sbvCurrentSolver)---- | Current solver instance, pointing to abc.-sbvCurrentSolver :: SMTConfig-sbvCurrentSolver = abc---- | Prove theorems, using ABC-prove :: Provable a-      => a              -- ^ Property to check-      -> IO ThmResult   -- ^ Response from the SMT solver, containing the counter-example if found-prove = proveWith sbvCurrentSolver---- | Find satisfying solutions, using ABC-sat :: Provable a-    => a                -- ^ Property to check-    -> IO SatResult     -- ^ Response of the SMT Solver, containing the model if found-sat = satWith sbvCurrentSolver---- | Check all 'sAssert' calls are safe, using ABC-safe :: SExecutable a-    => a                -- ^ Program containing sAssert calls-    -> IO [SafeResult]-safe = safeWith sbvCurrentSolver---- | Find all satisfying solutions, using ABC-allSat :: Provable a-       => a                -- ^ Property to check-       -> IO AllSatResult  -- ^ List of all satisfying models-allSat = allSatWith sbvCurrentSolver---- | Optimize objectives, using ABC-optimize :: Provable a-         => a                -- ^ Program with objectives-         -> IO OptimizeResult-optimize = optimizeWith sbvCurrentSolver---- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using ABC-isVacuous :: Provable a-          => a             -- ^ Property to check-          -> IO Bool       -- ^ True if the constraints are unsatisifiable-isVacuous = isVacuousWith sbvCurrentSolver---- | Check if the statement is a theorem, with an optional time-out in seconds, using ABC-isTheorem :: Provable a-          => Maybe Int          -- ^ Optional time-out, specify in seconds-          -> a                  -- ^ Property to check-          -> IO (Maybe Bool)    -- ^ Returns Nothing if time-out expires-isTheorem = isTheoremWith sbvCurrentSolver---- | Check if the statement is satisfiable, with an optional time-out in seconds, using ABC-isSatisfiable :: Provable a-              => Maybe Int       -- ^ Optional time-out, specify in seconds-              -> a               -- ^ Property to check-              -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers-isSatisfiable = isSatisfiableWith sbvCurrentSolver--{- $moduleExportIntro-The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module.--}
− Data/SBV/Bridge/Boolector.hs 
@@ -1,92 +0,0 @@------------------------------------------------------------------------------------- |--- Module      :  Data.SBV.Bridge.Boolector--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Interface to the Boolector SMT solver. Import this module if you want to use the--- Boolector SMT prover as your backend solver. Also see:------       - "Data.SBV.Bridge.ABC"--- ---       - "Data.SBV.Bridge.CVC4"--- ---       - "Data.SBV.Bridge.MathSAT"--- ---       - "Data.SBV.Bridge.Yices"--- ---       - "Data.SBV.Bridge.Z3"---------------------------------------------------------------------------------------module Data.SBV.Bridge.Boolector (-  -- * Boolector specific interface-  sbvCurrentSolver-  -- ** Proving, checking satisfiability, optimization-  , prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable-  -- * Non-Boolector specific SBV interface-  -- $moduleExportIntro-  , module Data.SBV-  ) where--import Data.SBV hiding (prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable, sbvCurrentSolver)---- | Current solver instance, pointing to Boolector.-sbvCurrentSolver :: SMTConfig-sbvCurrentSolver = boolector---- | Prove theorems, using the Boolector SMT solver-prove :: Provable a-      => a              -- ^ Property to check-      -> IO ThmResult   -- ^ Response from the SMT solver, containing the counter-example if found-prove = proveWith sbvCurrentSolver---- | Find satisfying solutions, using the Boolector SMT solver-sat :: Provable a-    => a                -- ^ Property to check-    -> IO SatResult     -- ^ Response of the SMT Solver, containing the model if found-sat = satWith sbvCurrentSolver---- | Check all 'sAssert' calls are safe, using the Boolector SMT solver-safe :: SExecutable a-    => a                -- ^ Program containing sAssert calls-    -> IO [SafeResult]-safe = safeWith sbvCurrentSolver---- | Find all satisfying solutions, using the Boolector SMT solver-allSat :: Provable a-       => a                -- ^ Property to check-       -> IO AllSatResult  -- ^ List of all satisfying models-allSat = allSatWith sbvCurrentSolver---- | Optimize objectives, using Boolector-optimize :: Provable a-         => a                -- ^ Program with objectives-         -> IO OptimizeResult-optimize = optimizeWith sbvCurrentSolver---- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using the Boolector SMT solver-isVacuous :: Provable a-          => a             -- ^ Property to check-          -> IO Bool       -- ^ True if the constraints are unsatisifiable-isVacuous = isVacuousWith sbvCurrentSolver---- | Check if the statement is a theorem, with an optional time-out in seconds, using the Boolector SMT solver-isTheorem :: Provable a-          => Maybe Int          -- ^ Optional time-out, specify in seconds-          -> a                  -- ^ Property to check-          -> IO (Maybe Bool)    -- ^ Returns Nothing if time-out expires-isTheorem = isTheoremWith sbvCurrentSolver---- | Check if the statement is satisfiable, with an optional time-out in seconds, using the Boolector SMT solver-isSatisfiable :: Provable a-              => Maybe Int       -- ^ Optional time-out, specify in seconds-              -> a               -- ^ Property to check-              -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers-isSatisfiable = isSatisfiableWith sbvCurrentSolver--{- $moduleExportIntro-The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module.--}
− Data/SBV/Bridge/CVC4.hs 
@@ -1,92 +0,0 @@------------------------------------------------------------------------------------- |--- Module      :  Data.SBV.Bridge.CVC4--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Interface to the CVC4 SMT solver. Import this module if you want to use the--- CVC4 SMT prover as your backend solver. Also see:------       - "Data.SBV.Bridge.ABC"--- ---       - "Data.SBV.Bridge.Boolector"--- ---       - "Data.SBV.Bridge.MathSAT"--- ---       - "Data.SBV.Bridge.Yices"--- ---       - "Data.SBV.Bridge.Z3"---------------------------------------------------------------------------------------module Data.SBV.Bridge.CVC4 (-  -- * CVC4 specific interface-  sbvCurrentSolver-  -- ** Proving, checking satisfiability, optimization-  , prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable-  -- * Non-CVC4 specific SBV interface-  -- $moduleExportIntro-  , module Data.SBV-  ) where--import Data.SBV hiding (prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable, sbvCurrentSolver)---- | Current solver instance, pointing to cvc4.-sbvCurrentSolver :: SMTConfig-sbvCurrentSolver = cvc4---- | Prove theorems, using the CVC4 SMT solver-prove :: Provable a-      => a              -- ^ Property to check-      -> IO ThmResult   -- ^ Response from the SMT solver, containing the counter-example if found-prove = proveWith sbvCurrentSolver---- | Find satisfying solutions, using the CVC4 SMT solver-sat :: Provable a-    => a                -- ^ Property to check-    -> IO SatResult     -- ^ Response of the SMT Solver, containing the model if found-sat = satWith sbvCurrentSolver---- | Check all 'sAssert' calls are safe, using the CVC4 SMT solver-safe :: SExecutable a-    => a                -- ^ Program containing sAssert calls-    -> IO [SafeResult]-safe = safeWith sbvCurrentSolver---- | Find all satisfying solutions, using the CVC4 SMT solver-allSat :: Provable a-       => a                -- ^ Property to check-       -> IO AllSatResult  -- ^ List of all satisfying models-allSat = allSatWith sbvCurrentSolver---- | Optimize objectives, using CVC4-optimize :: Provable a-         => a                -- ^ Program with objectives-         -> IO OptimizeResult-optimize = optimizeWith sbvCurrentSolver---- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using the CVC4 SMT solver-isVacuous :: Provable a-          => a             -- ^ Property to check-          -> IO Bool       -- ^ True if the constraints are unsatisifiable-isVacuous = isVacuousWith sbvCurrentSolver---- | Check if the statement is a theorem, with an optional time-out in seconds, using the CVC4 SMT solver-isTheorem :: Provable a-          => Maybe Int          -- ^ Optional time-out, specify in seconds-          -> a                  -- ^ Property to check-          -> IO (Maybe Bool)    -- ^ Returns Nothing if time-out expires-isTheorem = isTheoremWith sbvCurrentSolver---- | Check if the statement is satisfiable, with an optional time-out in seconds, using the CVC4 SMT solver-isSatisfiable :: Provable a-              => Maybe Int       -- ^ Optional time-out, specify in seconds-              -> a               -- ^ Property to check-              -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers-isSatisfiable = isSatisfiableWith sbvCurrentSolver--{- $moduleExportIntro-The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module.--}
− Data/SBV/Bridge/MathSAT.hs 
@@ -1,92 +0,0 @@------------------------------------------------------------------------------------- |--- Module      :  Data.SBV.Bridge.MathSAT--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Interface to the MathSAT SMT solver. Import this module if you want to use the--- MathSAT SMT prover as your backend solver. Also see:------       - "Data.SBV.Bridge.ABC"--- ---       - "Data.SBV.Bridge.Boolector"--- ---       - "Data.SBV.Bridge.CVC4"--- ---       - "Data.SBV.Bridge.Yices"--- ---       - "Data.SBV.Bridge.Z3"---------------------------------------------------------------------------------------module Data.SBV.Bridge.MathSAT (-  -- * MathSAT specific interface-  sbvCurrentSolver-  -- ** Proving, checking satisfiability, optimization-  , prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable-  -- * Non-MathSAT specific SBV interface-  -- $moduleExportIntro-  , module Data.SBV-  ) where--import Data.SBV hiding (prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable, sbvCurrentSolver)---- | Current solver instance, pointing to MathSAT.-sbvCurrentSolver :: SMTConfig-sbvCurrentSolver = mathSAT---- | Prove theorems, using the MathSAT SMT solver-prove :: Provable a-      => a              -- ^ Property to check-      -> IO ThmResult   -- ^ Response from the SMT solver, containing the counter-example if found-prove = proveWith sbvCurrentSolver---- | Find satisfying solutions, using the MathSAT SMT solver-sat :: Provable a-    => a                -- ^ Property to check-    -> IO SatResult     -- ^ Response of the SMT Solver, containing the model if found-sat = satWith sbvCurrentSolver---- | Check all 'sAssert' calls are safe, using the MathSAT SMT solver-safe :: SExecutable a-    => a                -- ^ Program containing sAssert calls-    -> IO [SafeResult]-safe = safeWith sbvCurrentSolver---- | Find all satisfying solutions, using the MathSAT SMT solver-allSat :: Provable a-       => a                -- ^ Property to check-       -> IO AllSatResult  -- ^ List of all satisfying models-allSat = allSatWith sbvCurrentSolver---- | Optimize objectives, using MathSAT-optimize :: Provable a-         => a                -- ^ Program with objectives-         -> IO OptimizeResult-optimize = optimizeWith sbvCurrentSolver---- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using the MathSAT SMT solver-isVacuous :: Provable a-          => a             -- ^ Property to check-          -> IO Bool       -- ^ True if the constraints are unsatisifiable-isVacuous = isVacuousWith sbvCurrentSolver---- | Check if the statement is a theorem, with an optional time-out in seconds, using the MathSAT SMT solver-isTheorem :: Provable a-          => Maybe Int          -- ^ Optional time-out, specify in seconds-          -> a                  -- ^ Property to check-          -> IO (Maybe Bool)    -- ^ Returns Nothing if time-out expires-isTheorem = isTheoremWith sbvCurrentSolver---- | Check if the statement is satisfiable, with an optional time-out in seconds, using the MathSAT SMT solver-isSatisfiable :: Provable a-              => Maybe Int       -- ^ Optional time-out, specify in seconds-              -> a               -- ^ Property to check-              -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers-isSatisfiable = isSatisfiableWith sbvCurrentSolver--{- $moduleExportIntro-The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module.--}
− Data/SBV/Bridge/Yices.hs 
@@ -1,92 +0,0 @@------------------------------------------------------------------------------------- |--- Module      :  Data.SBV.Bridge.Yices--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Interface to the Yices SMT solver. Import this module if you want to use the--- Yices SMT prover as your backend solver. Also see:------       - "Data.SBV.Bridge.ABC"--- ---       - "Data.SBV.Bridge.Boolector"--- ---       - "Data.SBV.Bridge.CVC4"--- ---       - "Data.SBV.Bridge.MathSAT"--- ---       - "Data.SBV.Bridge.Z3"---------------------------------------------------------------------------------------module Data.SBV.Bridge.Yices (-  -- * Yices specific interface-  sbvCurrentSolver-  -- ** Proving, checking satisfiability, optimization-  , prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable-  -- * Non-Yices specific SBV interface-  -- $moduleExportIntro-  , module Data.SBV-  ) where--import Data.SBV hiding (prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable, sbvCurrentSolver)---- | Current solver instance, pointing to yices.-sbvCurrentSolver :: SMTConfig-sbvCurrentSolver = yices---- | Prove theorems, using the Yices SMT solver-prove :: Provable a-      => a              -- ^ Property to check-      -> IO ThmResult   -- ^ Response from the SMT solver, containing the counter-example if found-prove = proveWith sbvCurrentSolver---- | Find satisfying solutions, using the Yices SMT solver-sat :: Provable a-    => a                -- ^ Property to check-    -> IO SatResult     -- ^ Response of the SMT Solver, containing the model if found-sat = satWith sbvCurrentSolver---- | Check all 'sAssert' calls are safe, using the Yices SMT solver-safe :: SExecutable a-    => a                -- ^ Program containing sAssert calls-    -> IO [SafeResult]-safe = safeWith sbvCurrentSolver---- | Find all satisfying solutions, using the Yices SMT solver-allSat :: Provable a-       => a                -- ^ Property to check-       -> IO AllSatResult  -- ^ List of all satisfying models-allSat = allSatWith sbvCurrentSolver---- | Optimize objectives, using Yices-optimize :: Provable a-         => a                -- ^ Program with objectives-         -> IO OptimizeResult-optimize = optimizeWith sbvCurrentSolver---- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using the Yices SMT solver-isVacuous :: Provable a-          => a             -- ^ Property to check-          -> IO Bool       -- ^ True if the constraints are unsatisifiable-isVacuous = isVacuousWith sbvCurrentSolver---- | Check if the statement is a theorem, with an optional time-out in seconds, using the Yices SMT solver-isTheorem :: Provable a-          => Maybe Int          -- ^ Optional time-out, specify in seconds-          -> a                  -- ^ Property to check-          -> IO (Maybe Bool)    -- ^ Returns Nothing if time-out expires-isTheorem = isTheoremWith sbvCurrentSolver---- | Check if the statement is satisfiable, with an optional time-out in seconds, using the Yices SMT solver-isSatisfiable :: Provable a-              => Maybe Int       -- ^ Optional time-out, specify in seconds-              -> a               -- ^ Property to check-              -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers-isSatisfiable = isSatisfiableWith sbvCurrentSolver--{- $moduleExportIntro-The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module.--}
− Data/SBV/Bridge/Z3.hs 
@@ -1,92 +0,0 @@------------------------------------------------------------------------------------- |--- Module      :  Data.SBV.Bridge.Z3--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Interface to the Z3 SMT solver. Import this module if you want to use the--- Z3 SMT prover as your backend solver. Also see:------       - "Data.SBV.Bridge.ABC"--- ---       - "Data.SBV.Bridge.Boolector"--- ---       - "Data.SBV.Bridge.CVC4"--- ---       - "Data.SBV.Bridge.MathSAT"--- ---       - "Data.SBV.Bridge.Yices"---------------------------------------------------------------------------------------module Data.SBV.Bridge.Z3 (-  -- * Z3 specific interface-  sbvCurrentSolver-  -- ** Proving, checking satisfiability, optimization-  , prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable-  -- * Non-Z3 specific SBV interface-  -- $moduleExportIntro-  , module Data.SBV-  ) where--import Data.SBV hiding (prove, sat, allSat, safe, optimize, isVacuous, isTheorem, isSatisfiable, sbvCurrentSolver)---- | Current solver instance, pointing to z3.-sbvCurrentSolver :: SMTConfig-sbvCurrentSolver = z3---- | Prove theorems, using the Z3 SMT solver-prove :: Provable a-      => a              -- ^ Property to check-      -> IO ThmResult   -- ^ Response from the SMT solver, containing the counter-example if found-prove = proveWith sbvCurrentSolver---- | Find satisfying solutions, using the Z3 SMT solver-sat :: Provable a-    => a                -- ^ Property to check-    -> IO SatResult     -- ^ Response of the SMT Solver, containing the model if found-sat = satWith sbvCurrentSolver---- | Check all 'sAssert' calls are safe, using the Z3 SMT solver-safe :: SExecutable a-    => a                -- ^ Program containing sAssert calls-    -> IO [SafeResult]-safe = safeWith sbvCurrentSolver---- | Find all satisfying solutions, using the Z3 SMT solver-allSat :: Provable a-       => a                -- ^ Property to check-       -> IO AllSatResult  -- ^ List of all satisfying models-allSat = allSatWith sbvCurrentSolver---- | Optimize objectives, using Yices-optimize :: Provable a-         => a                -- ^ Program with objectives-         -> IO OptimizeResult-optimize = optimizeWith sbvCurrentSolver---- | Check vacuity of the explicit constraints introduced by calls to the 'constrain' function, using the Z3 SMT solver-isVacuous :: Provable a-          => a             -- ^ Property to check-          -> IO Bool       -- ^ True if the constraints are unsatisifiable-isVacuous = isVacuousWith sbvCurrentSolver---- | Check if the statement is a theorem, with an optional time-out in seconds, using the Z3 SMT solver-isTheorem :: Provable a-          => Maybe Int          -- ^ Optional time-out, specify in seconds-          -> a                  -- ^ Property to check-          -> IO (Maybe Bool)    -- ^ Returns Nothing if time-out expires-isTheorem = isTheoremWith sbvCurrentSolver---- | Check if the statement is satisfiable, with an optional time-out in seconds, using the Z3 SMT solver-isSatisfiable :: Provable a-              => Maybe Int       -- ^ Optional time-out, specify in seconds-              -> a               -- ^ Property to check-              -> IO (Maybe Bool) -- ^ Returns Nothing if time-out expiers-isSatisfiable = isSatisfiableWith sbvCurrentSolver--{- $moduleExportIntro-The remainder of the SBV library that is common to all back-end SMT solvers, directly coming from the "Data.SBV" module.--}
Data/SBV/Compilers/C.hs view
@@ -29,10 +29,7 @@  import Data.SBV.Utils.PrettyNum   (shex, showCFloat, showCDouble) -import GHC.Stack.Compat-#if !MIN_VERSION_base(4,9,0)-import GHC.SrcLoc.Compat-#endif+import GHC.Stack  --------------------------------------------------------------------------- -- * API@@ -408,7 +405,7 @@  -- | Generate the C program genCProg :: CgConfig -> String -> Doc -> Result -> [(String, CgVal)] -> [(String, CgVal)] -> Maybe SW -> Doc -> [Doc]-genCProg cfg fn proto (Result kindInfo _tvals cgs ins preConsts tbls arrs _uis _axioms (SBVPgm asgns) cstrs _tacs _goals origAsserts _) inVars outVars mbRet extDecls+genCProg cfg fn proto (Result kindInfo _tvals cgs ins preConsts tbls arrs _uis _axioms (SBVPgm asgns) cstrs origAsserts _) inVars outVars mbRet extDecls   | isNothing (cgInteger cfg) && KUnbounded `Set.member` kindInfo   = error $ "SBV->C: Unbounded integers are not supported by the C compiler."           ++ "\nUse 'cgIntegerSize' to specify a fixed size for SInteger representation."
Data/SBV/Compilers/CodeGen.hs view
@@ -40,8 +40,9 @@         ) where  import Control.Monad             (filterM, replicateM, unless)-import Control.Monad.Trans       (MonadIO, lift)-import Control.Monad.State.Lazy  (MonadState, StateT(..), modify)+import Control.Monad.Reader      (ask)+import Control.Monad.Trans       (MonadIO, lift, liftIO)+import Control.Monad.State.Lazy  (MonadState, StateT(..), modify') import Data.Char                 (toLower, isSpace) import Data.List                 (nub, isPrefixOf, intercalate, (\\)) import System.Directory          (createDirectoryIfMissing, doesDirectoryExist, doesFileExist)@@ -54,9 +55,6 @@ import Data.SBV.Core.Data import Data.SBV.Core.Symbolic (svToSymSW, svMkSymVar, outputSVal) -import Prelude ()-import Prelude.Compat- -- | Abstract over code generation for different languages class CgTarget a where   targetName :: a -> String@@ -127,7 +125,7 @@  -- | Sets RTC (run-time-checks) for index-out-of-bounds, shift-with-large value etc. on/off. Default: 'False'. cgPerformRTCs :: Bool -> SBVCodeGen ()-cgPerformRTCs b = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgRTC = b } })+cgPerformRTCs b = modify' (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgRTC = b } })  -- | Sets number of bits to be used for representing the 'SInteger' type in the generated C code. -- The argument must be one of @8@, @16@, @32@, or @64@. Note that this is essentially unsafe as@@ -138,7 +136,7 @@   | i `notElem` [8, 16, 32, 64]   = error $ "SBV.cgIntegerSize: Argument must be one of 8, 16, 32, or 64. Received: " ++ show i   | True-  = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgInteger = Just i }})+  = modify' (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgInteger = Just i }})  -- | Possible mappings for the 'SReal' type when translated to C. Used in conjunction -- with the function 'cgSRealType'. Note that the particular characteristics of the@@ -149,7 +147,7 @@                  | CgLongDouble -- ^ @long double@                  deriving Eq --- | 'Show' instance for 'cgSRealType' displays values as they would be used in a C program+-- 'Show' instance for 'cgSRealType' displays values as they would be used in a C program instance Show CgSRealType where   show CgFloat      = "float"   show CgDouble     = "double"@@ -161,60 +159,60 @@ -- infinite precision SReal values becomes reduced to the corresponding floating point type in -- C, and hence it is subject to rounding errors. cgSRealType :: CgSRealType -> SBVCodeGen ()-cgSRealType rt = modify (\s -> s {cgFinalConfig = (cgFinalConfig s) { cgReal = Just rt }})+cgSRealType rt = modify' (\s -> s {cgFinalConfig = (cgFinalConfig s) { cgReal = Just rt }})  -- | Should we generate a driver program? Default: 'True'. When a library is generated, it will have -- a driver if any of the contituent functions has a driver. (See 'compileToCLib'.) cgGenerateDriver :: Bool -> SBVCodeGen ()-cgGenerateDriver b = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgGenDriver = b } })+cgGenerateDriver b = modify' (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgGenDriver = b } })  -- | Should we generate a Makefile? Default: 'True'. cgGenerateMakefile :: Bool -> SBVCodeGen ()-cgGenerateMakefile b = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgGenMakefile = b } })+cgGenerateMakefile b = modify' (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgGenMakefile = b } })  -- | Sets driver program run time values, useful for generating programs with fixed drivers for testing. Default: None, i.e., use random values. cgSetDriverValues :: [Integer] -> SBVCodeGen ()-cgSetDriverValues vs = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgDriverVals = vs } })+cgSetDriverValues vs = modify' (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgDriverVals = vs } })  -- | Ignore assertions (those generated by 'sAssert' calls) in the generated C code cgIgnoreSAssert :: Bool -> SBVCodeGen ()-cgIgnoreSAssert b = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgIgnoreAsserts = b } })+cgIgnoreSAssert b = modify' (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgIgnoreAsserts = b } })  -- | Adds the given lines to the header file generated, useful for generating programs with uninterpreted functions. cgAddPrototype :: [String] -> SBVCodeGen ()-cgAddPrototype ss = modify (\s -> let old = cgPrototypes s-                                      new = if null old then ss else old ++ [""] ++ ss-                                  in s { cgPrototypes = new })+cgAddPrototype ss = modify' (\s -> let old = cgPrototypes s+                                       new = if null old then ss else old ++ [""] ++ ss+                                   in s { cgPrototypes = new })  -- | Adds the given lines to the program file generated, useful for generating programs with uninterpreted functions. cgAddDecl :: [String] -> SBVCodeGen ()-cgAddDecl ss = modify (\s -> s { cgDecls = cgDecls s ++ ss })+cgAddDecl ss = modify' (\s -> s { cgDecls = cgDecls s ++ ss })  -- | Adds the given words to the compiler options in the generated Makefile, useful for linking extra stuff in. cgAddLDFlags :: [String] -> SBVCodeGen ()-cgAddLDFlags ss = modify (\s -> s { cgLDFlags = cgLDFlags s ++ ss })+cgAddLDFlags ss = modify' (\s -> s { cgLDFlags = cgLDFlags s ++ ss })  -- | Creates an atomic input in the generated code. svCgInput :: Kind -> String -> SBVCodeGen SVal-svCgInput k nm = do r <- liftSymbolic (svMkSymVar (Just ALL) k Nothing)+svCgInput k nm = do r  <- liftSymbolic (ask >>= liftIO . svMkSymVar (Just ALL) k Nothing)                     sw <- liftSymbolic (svToSymSW r)-                    modify (\s -> s { cgInputs = (nm, CgAtomic sw) : cgInputs s })+                    modify' (\s -> s { cgInputs = (nm, CgAtomic sw) : cgInputs s })                     return r  -- | Creates an array input in the generated code. svCgInputArr :: Kind -> Int -> String -> SBVCodeGen [SVal] svCgInputArr k sz nm   | sz < 1 = error $ "SBV.cgInputArr: Array inputs must have at least one element, given " ++ show sz ++ " for " ++ show nm-  | True   = do rs <- liftSymbolic $ replicateM sz (svMkSymVar (Just ALL) k Nothing)+  | True   = do rs  <- liftSymbolic $ ask >>= liftIO . replicateM sz . svMkSymVar (Just ALL) k Nothing                 sws <- liftSymbolic $ mapM svToSymSW rs-                modify (\s -> s { cgInputs = (nm, CgArray sws) : cgInputs s })+                modify' (\s -> s { cgInputs = (nm, CgArray sws) : cgInputs s })                 return rs  -- | Creates an atomic output in the generated code. svCgOutput :: String -> SVal -> SBVCodeGen () svCgOutput nm v = do _ <- liftSymbolic (outputSVal v)                      sw <- liftSymbolic (svToSymSW v)-                     modify (\s -> s { cgOutputs = (nm, CgAtomic sw) : cgOutputs s })+                     modify' (\s -> s { cgOutputs = (nm, CgAtomic sw) : cgOutputs s })  -- | Creates an array output in the generated code. svCgOutputArr :: String -> [SVal] -> SBVCodeGen ()@@ -222,14 +220,14 @@   | sz < 1 = error $ "SBV.cgOutputArr: Array outputs must have at least one element, received " ++ show sz ++ " for " ++ show nm   | True   = do _ <- liftSymbolic (mapM outputSVal vs)                 sws <- liftSymbolic (mapM svToSymSW vs)-                modify (\s -> s { cgOutputs = (nm, CgArray sws) : cgOutputs s })+                modify' (\s -> s { cgOutputs = (nm, CgArray sws) : cgOutputs s })   where sz = length vs  -- | Creates a returned (unnamed) value in the generated code. svCgReturn :: SVal -> SBVCodeGen () svCgReturn v = do _ <- liftSymbolic (outputSVal v)                   sw <- liftSymbolic (svToSymSW v)-                  modify (\s -> s { cgReturns = CgAtomic sw : cgReturns s })+                  modify' (\s -> s { cgReturns = CgAtomic sw : cgReturns s })  -- | Creates a returned (unnamed) array value in the generated code. svCgReturnArr :: [SVal] -> SBVCodeGen ()@@ -237,14 +235,14 @@   | sz < 1 = error $ "SBV.cgReturnArr: Array returns must have at least one element, received " ++ show sz   | True   = do _ <- liftSymbolic (mapM outputSVal vs)                 sws <- liftSymbolic (mapM svToSymSW vs)-                modify (\s -> s { cgReturns = CgArray sws : cgReturns s })+                modify' (\s -> s { cgReturns = CgArray sws : cgReturns s })   where sz = length vs  -- | Creates an atomic input in the generated code. cgInput :: SymWord a => String -> SBVCodeGen (SBV a) cgInput nm = do r <- liftSymbolic forall_                 sw <- cgSBVToSW r-                modify (\s -> s { cgInputs = (nm, CgAtomic sw) : cgInputs s })+                modify' (\s -> s { cgInputs = (nm, CgAtomic sw) : cgInputs s })                 return r  -- | Creates an array input in the generated code.@@ -253,14 +251,14 @@   | sz < 1 = error $ "SBV.cgInputArr: Array inputs must have at least one element, given " ++ show sz ++ " for " ++ show nm   | True   = do rs <- liftSymbolic $ mapM (const forall_) [1..sz]                 sws <- mapM cgSBVToSW rs-                modify (\s -> s { cgInputs = (nm, CgArray sws) : cgInputs s })+                modify' (\s -> s { cgInputs = (nm, CgArray sws) : cgInputs s })                 return rs  -- | Creates an atomic output in the generated code. cgOutput :: String -> SBV a -> SBVCodeGen () cgOutput nm v = do _ <- liftSymbolic (output v)                    sw <- cgSBVToSW v-                   modify (\s -> s { cgOutputs = (nm, CgAtomic sw) : cgOutputs s })+                   modify' (\s -> s { cgOutputs = (nm, CgAtomic sw) : cgOutputs s })  -- | Creates an array output in the generated code. cgOutputArr :: SymWord a => String -> [SBV a] -> SBVCodeGen ()@@ -268,14 +266,14 @@   | sz < 1 = error $ "SBV.cgOutputArr: Array outputs must have at least one element, received " ++ show sz ++ " for " ++ show nm   | True   = do _ <- liftSymbolic (mapM output vs)                 sws <- mapM cgSBVToSW vs-                modify (\s -> s { cgOutputs = (nm, CgArray sws) : cgOutputs s })+                modify' (\s -> s { cgOutputs = (nm, CgArray sws) : cgOutputs s })   where sz = length vs  -- | Creates a returned (unnamed) value in the generated code. cgReturn :: SBV a -> SBVCodeGen () cgReturn v = do _ <- liftSymbolic (output v)                 sw <- cgSBVToSW v-                modify (\s -> s { cgReturns = CgAtomic sw : cgReturns s })+                modify' (\s -> s { cgReturns = CgAtomic sw : cgReturns s })  -- | Creates a returned (unnamed) array value in the generated code. cgReturnArr :: SymWord a => [SBV a] -> SBVCodeGen ()@@ -283,7 +281,7 @@   | sz < 1 = error $ "SBV.cgReturnArr: Array returns must have at least one element, received " ++ show sz   | True   = do _ <- liftSymbolic (mapM output vs)                 sws <- mapM cgSBVToSW vs-                modify (\s -> s { cgReturns = CgArray sws : cgReturns s })+                modify' (\s -> s { cgReturns = CgArray sws : cgReturns s })   where sz = length vs  -- | Representation of a collection of generated programs.@@ -305,7 +303,7 @@ isCgMakefile CgMakefile{} = True isCgMakefile _            = False --- | A simple way to print bundles, mostly for debugging purposes.+-- A simple way to print bundles, mostly for debugging purposes. instance Show CgPgmBundle where    show (CgPgmBundle _ fs) = intercalate "\n" $ map showFile fs     where showFile :: (FilePath, (CgPgmKind, [Doc])) -> String@@ -317,7 +315,7 @@ -- of makefiles, source code, headers, etc. codeGen :: CgTarget l => l -> CgConfig -> String -> SBVCodeGen () -> IO CgPgmBundle codeGen l cgConfig nm (SBVCodeGen comp) = do-   (((), st'), res) <- runSymbolic' CodeGen $ runStateT comp initCgState { cgFinalConfig = cgConfig }+   (((), st'), res) <- runSymbolic CodeGen $ runStateT comp initCgState { cgFinalConfig = cgConfig }    let st = st' { cgInputs       = reverse (cgInputs st')                 , cgOutputs      = reverse (cgOutputs st')                 }
+ Data/SBV/Control.hs view
@@ -0,0 +1,247 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Control+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Control sublanguage for interacting with SMT solvers.+-----------------------------------------------------------------------------++{-# LANGUAGE NamedFieldPuns #-}++module Data.SBV.Control (+     -- $queryIntro++     -- * User queries+       Query, query++     -- * Create a fresh variable+     , freshVar_, freshVar++     -- * Checking satisfiability+     , CheckSatResult(..), checkSat, checkSatUsing, checkSatAssuming, checkSatAssumingWithUnsatisfiableSet++     -- * Querying the solver+     -- ** Extracting values+     , SMTValue(..), getValue, getUninterpretedValue, getModel, getAssignment, getSMTResult, getUnknownReason++     -- ** Extracting the unsat core+     , getUnsatCore++     -- ** Extracting a proof+     , getProof++     -- ** Extracting assertions+     , getAssertions++     -- * Getting solver information+     , SMTInfoFlag(..), SMTErrorBehavior(..), SMTReasonUnknown(..), SMTInfoResponse(..)+     , getInfo, getOption++     -- * Entering and exiting assertion stack+     , getAssertionStackDepth, push, pop, inNewAssertionStack++     -- * Tactics+     , caseSplit++     -- * Resetting the solver state+     , resetAssertions++     -- * Communicating results back+     -- ** Constructing assignments+     , (|->)++     -- ** Miscellaneous+     , echo++     -- ** Terminating the query+     , mkSMTResult+     , exit++     -- * Controlling the solver behavior+     , ignoreExitCode, timeout++     -- * Performing actions+     , io++     -- * Solver options+     , SMTOption(..)++     -- * Logics supported+     , Logic(..)++     ) where++import Data.SBV.Core.Data     (SMTProblem(..), SMTSolver(..), SMTConfig(..))+import Data.SBV.Core.Symbolic ( Query, IStage(..), SBVRunMode(..), Symbolic, Query(..), rSMTOptions+                              , extractSymbolicSimulationState, solverSetOptions, runMode+                              )++import Data.SBV.Control.Query+import Data.SBV.Control.Utils (runProofOn, SMTValue(..))++import Data.IORef (readIORef, writeIORef)++import qualified Control.Monad.Reader as R (ask)+import Control.Monad.Trans  (liftIO)+import Control.Monad.State  (evalStateT)++-- | Run a custom query+query :: Query a -> Symbolic a+query (Query userQuery) = do+     st <- R.ask+     rm <- liftIO $ readIORef (runMode st)+     case rm of+        -- Transitioning from setup+        SMTMode ISetup isSAT cfg -> liftIO $ do let backend = engine (solver cfg)++                                                res     <- extractSymbolicSimulationState st+                                                setOpts <- reverse <$> readIORef (rSMTOptions st)++                                                let SMTProblem{smtLibPgm} = runProofOn cfg isSAT [] res+                                                    cfg' = cfg { solverSetOptions = solverSetOptions cfg ++ setOpts }+                                                    pgm  = smtLibPgm cfg'++                                                writeIORef (runMode st) $ SMTMode IRun isSAT cfg++                                                backend cfg' st (show pgm) $ evalStateT userQuery++        -- Already in a query, in theory we can just continue, but that causes use-case issues+        -- so we reject it. TODO: Review if we should actually support this. The issue arises with+        -- expressions like this:+        --+        -- In the following t0's output doesn't get recorded, as the output call is too late when we get+        -- here. (The output field isn't "incremental.") So, t0/t1 behave differently!+        --+        --   t0 = satWith z3{verbose=True, transcript=Just "t.smt2"} $ query (return (false::SBool))+        --   t1 = satWith z3{verbose=True, transcript=Just "t.smt2"} $ ((return (false::SBool)) :: Predicate)+        --+        -- Also, not at all clear what it means to go in an out of query mode:+        --+        -- r = runSMTWith z3{verbose=True} $ do+        --         a' <- sInteger "a"+        --+        --        (a, av) <- query $ do _ <- checkSat+        --                              av <- getValue a'+        --                              return (a', av)+        --+        --        liftIO $ putStrLn $ "Got: " ++ show av+        --        -- constrain $ a .> literal av + 1      -- Cant' do this since we're "out" of query. Sigh.+        --+        --        bv <- query $ do constrain $ a .> literal av + 1+        --                         _ <- checkSat+        --                         getValue a+        --+        --        return $ a' .== a' + 1+        --+        -- This would be one possible implementation, alas it has the problems above:+        --+        --    SMTMode IRun _ _ -> liftIO $ evalStateT userQuery st+        --+        -- So, we just reject it.++        SMTMode IRun _ _ -> error $ unlines [ ""+                                            , "*** Data.SBV: Unsupported nested query is detected."+                                            , "***"+                                            , "*** Please group your queries into one block. Note that this"+                                            , "*** can also arise if you have a call to 'query' not within 'runSMT'"+                                            , "*** For instance, within 'sat'/'prove' calls with custom user queries."+                                            , "*** The solution is to do the sat/prove part in the query directly."+                                            , "***"+                                            , "*** While multiple/nested queries should not be necessary in general,"+                                            , "*** please do get in touch if your use case does require such a feature,"+                                            , "*** to see how we can accommodate such scenarios."+                                            ]++        -- Otherwise choke!+        m -> error $ unlines [ ""+                             , "*** Data.SBV: Invalid query call."+                             , "***"+                             , "***   Current mode: " ++ show m+                             , "***"+                             , "*** Query calls are only valid within runSMT/runSMTWith calls"+                             ]++{- $queryIntro+In certain cases, the user might want to take over the communication with the solver, programmatically+querying the engine and issuing commands accordingly. Even with human guidance, perhaps, where the user+can take a look at the engine state and issue commands to guide the proof. This is an advanced feature,+as the user is given full access to the underlying SMT solver, so the usual protections provided by+SBV are no longer there to prevent mistakes.++Having said that, queries can be extremely powerful as they allow direct control of the solver. Here's a+simple example:++@+    module Test where++    import Data.SBV+    import Data.SBV.Control  -- queries require this module to be imported!++    test :: Symbolic (Maybe (Integer, Integer))+    test = do x <- sInteger "x"   -- a free variable named "x"+              y <- sInteger "y"   -- a free variable named "y"++              -- require the sum to be 10+              constrain $ x + y .== 10++              -- Go into the Query mode+              query $ do+                    -- Query the solver: Are the constraints satisfiable?+                    cs <- checkSat+                    case cs of+                      Unk   -> error "Solver said unknown!"+                      Unsat -> return Nothing -- no solution!+                      Sat   -> -- Query the values:+                               do xv <- getValue x+                                  yv <- getValue y++                                  io $ putStrLn $ "Solver returned: " ++ show (xv, yv)++                                  -- We can now add new constraints,+                                  -- Or perform arbitrary computations and tell+                                  -- the solver anything we want!+                                  constrain $ x .> literal xv + literal yv++                                  -- call checkSat again+                                  csNew <- checkSat+                                  case csNew of+                                    Unk   -> error "Solver said unknown!"+                                    Unsat -> return Nothing+                                    Sat   -> do xv2 <- getValue x+                                                yv2 <- getValue y++                                                return $ Just (xv2, yv2)+@++Note the type of 'test', it returns an optional pair of integers in the 'Symbolic' monad. We turn+it into an IO value with the 'runSMT' function: (There's also 'runSMTWith' that uses a user specified+solver instead of the default.)++@+    pair :: IO (Maybe (Integer, Integer))+    pair = runSMT test+@++When run, this can return:++@+*Test> pair+Solver returned: (10,0)+Just (11,-1)+@++demonstrating that the user has full contact with the solver and can guide it as the program executes. SBV+provides access to many SMTLib features in the query mode, as exported from this very module.++For other examples see:++  - "Data.SBV.Examples.Queries.AllSat": Simulating SBV's 'allSat' using queries.+  - "Data.SBV.Examples.Queries.CaseSplit": Performing a case-split during a query.+  - "Data.SBV.Examples.Queries.Enums": Using enumerations in queries.+  - "Data.SBV.Examples.Queries.FourFours": Solution to a fun arithmetic puzzle, coded using queries.+  - "Data.SBV.Examples.Queries.GuessNumber": The famous number guessing game.+  - "Data.SBV.Examples.Queries.UnsatCore": Extracting unsat-cores using queries.+-}
+ Data/SBV/Control/Query.hs view
@@ -0,0 +1,706 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Control.Query+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Querying a solver interactively.+-----------------------------------------------------------------------------++{-# LANGUAGE LambdaCase     #-}+{-# LANGUAGE NamedFieldPuns #-}+{-# LANGUAGE TupleSections  #-}+{-# LANGUAGE Rank2Types     #-}++{-# OPTIONS_GHC -fno-warn-orphans #-}++module Data.SBV.Control.Query (+       send, ask, retrieveResponse+     , CheckSatResult(..), checkSat, checkSatUsing, checkSatAssuming, checkSatAssumingWithUnsatisfiableSet+     , getUnsatCore, getProof, getAssignment, getOption, freshVar, freshVar_, push, pop, getAssertionStackDepth+     , inNewAssertionStack, echo, caseSplit, resetAssertions, exit, getAssertions, getValue, getUninterpretedValue, getModel, getSMTResult+     , getLexicographicOptResults, getIndependentOptResults, getParetoOptResults, getAllSatResult, getUnknownReason+     , SMTOption(..), SMTInfoFlag(..), SMTErrorBehavior(..), SMTReasonUnknown(..), SMTInfoResponse(..), getInfo+     , Logic(..), Assignment(..)+     , ignoreExitCode, timeout+     , (|->)+     , mkSMTResult+     , io+     ) where++import Control.Monad            (unless, when, zipWithM)+import Control.Monad.State.Lazy (get)++import Data.IORef    (readIORef)++import Data.List     (unzip3, intercalate, nubBy, sortBy, elemIndex)+import Data.Maybe    (listToMaybe, catMaybes)+import Data.Function (on)++import Data.SBV.Core.Data++import Data.SBV.Core.Symbolic   (QueryState(..), Query(..), SMTModel(..), SMTResult(..), State(..), incrementInternalCounter)++import Data.SBV.Utils.SExpr+import Data.SBV.Utils.Boolean++import Data.SBV.Control.Types+import Data.SBV.Control.Utils++-- | An Assignment of a model binding+data Assignment = Assign SVal CW++-- Remove one pair of surrounding 'c's, if present+noSurrounding :: Char -> String -> String+noSurrounding c (c':cs@(_:_)) | c == c' && c == last cs  = init cs+noSurrounding _ s                                        = s++-- Remove a pair of surrounding quotes+unQuote :: String -> String+unQuote = noSurrounding '"'++-- Remove a pair of surrounding bars+unBar :: String -> String+unBar = noSurrounding '|'++-- Is this a string? If so, return it, otherwise fail in the Maybe monad.+fromECon :: SExpr -> Maybe String+fromECon (ECon s) = Just s+fromECon _        = Nothing++-- Collect strings appearing, used in 'getOption' only+stringsOf :: SExpr -> [String]+stringsOf (ECon s)      = [s]+stringsOf (ENum (i, _)) = [show i]+stringsOf (EReal   r)   = [show r]+stringsOf (EFloat  f)   = [show f]+stringsOf (EDouble d)   = [show d]+stringsOf (EApp ss)     = concatMap stringsOf ss++-- Sort of a light-hearted show for SExprs, for better consumption at the user level.+serialize :: Bool -> SExpr -> String+serialize removeQuotes = go+  where go (ECon s)      = if removeQuotes then unQuote s else s+        go (ENum (i, _)) = show i+        go (EReal   r)   = show r+        go (EFloat  f)   = show f+        go (EDouble d)   = show d+        go (EApp [x])    = go x+        go (EApp ss)     = "(" ++ unwords (map go ss) ++ ")"++-- | Ask solver for info.+getInfo :: SMTInfoFlag -> Query SMTInfoResponse+getInfo flag = do+    let cmd = "(get-info " ++ show flag ++ ")"+        bad = unexpected "getInfo" cmd "a valid get-info response" Nothing++        isAllStatistics AllStatistics = True+        isAllStatistics _             = False++        isAllStat = isAllStatistics flag++        render = serialize True++        grabAllStat k v = (render k, render v)++        -- we're trying to do our best to get key-value pairs here, but this+        -- is necessarily a half-hearted attempt.+        grabAllStats (EApp xs) = walk xs+           where walk []             = []+                 walk [t]            = [grabAllStat t (ECon "")]+                 walk (t : v : rest) =  grabAllStat t v          : walk rest+        grabAllStats o = [grabAllStat o (ECon "")]++    r <- ask cmd++    parse r bad $ \pe ->+       if isAllStat+          then return $ Resp_AllStatistics $ grabAllStats pe+          else case pe of+                 ECon "unsupported"                                        -> return Resp_Unsupported+                 EApp [ECon ":assertion-stack-levels", ENum (i, _)]        -> return $ Resp_AssertionStackLevels i+                 EApp (ECon ":authors" : ns)                               -> return $ Resp_Authors (map render ns)+                 EApp [ECon ":error-behavior", ECon "immediate-exit"]      -> return $ Resp_Error ErrorImmediateExit+                 EApp [ECon ":error-behavior", ECon "continued-execution"] -> return $ Resp_Error ErrorContinuedExecution+                 EApp (ECon ":name" : o)                                   -> return $ Resp_Name (render (EApp o))+                 EApp [ECon ":reason-unknown", ECon "memout"]              -> return $ Resp_ReasonUnknown UnknownMemOut+                 EApp [ECon ":reason-unknown", ECon "incomplete"]          -> return $ Resp_ReasonUnknown UnknownIncomplete+                 EApp (ECon ":reason-unknown" : o)                         -> return $ Resp_ReasonUnknown (UnknownOther (render (EApp o)))+                 EApp (ECon ":version" : o)                                -> return $ Resp_Version (render (EApp o))+                 EApp (ECon s : o)                                         -> return $ Resp_InfoKeyword s (map render o)+                 _                                                         -> bad r Nothing++-- | Retrieve the value of an 'SMTOption.' The curious function argument is on purpose here,+-- simply pass the constructor name. Example: the call @'getOption' 'ProduceUnsatCores'@ will return+-- either @Nothing@ or @Just (ProduceUnsatCores True)@ or @Just (ProduceUnsatCores False)@.+--+-- Result will be 'Nothing' if the solver does not support this option.+getOption :: (a -> SMTOption) -> Query (Maybe SMTOption)+getOption f = case f undefined of+                 DiagnosticOutputChannel{}   -> askFor "DiagnosticOutputChannel"   ":diagnostic-output-channel"   $ string     DiagnosticOutputChannel+                 ProduceAssertions{}         -> askFor "ProduceAssertions"         ":produce-assertions"          $ bool       ProduceAssertions+                 ProduceAssignments{}        -> askFor "ProduceAssignments"        ":produce-assignments"         $ bool       ProduceAssignments+                 ProduceProofs{}             -> askFor "ProduceProofs"             ":produce-proofs"              $ bool       ProduceProofs+                 ProduceUnsatAssumptions{}   -> askFor "ProduceUnsatAssumptions"   ":produce-unsat-assumptions"   $ bool       ProduceUnsatAssumptions+                 ProduceUnsatCores{}         -> askFor "ProduceUnsatCores"         ":produce-unsat-cores"         $ bool       ProduceUnsatCores+                 RandomSeed{}                -> askFor "RandomSeed"                ":random-seed"                 $ integer    RandomSeed+                 ReproducibleResourceLimit{} -> askFor "ReproducibleResourceLimit" ":reproducible-resource-limit" $ integer    ReproducibleResourceLimit+                 SMTVerbosity{}              -> askFor "SMTVerbosity"              ":verbosity"                   $ integer    SMTVerbosity+                 OptionKeyword nm _          -> askFor ("OptionKeyword" ++ nm)     nm                             $ stringList (OptionKeyword nm)+                 SetLogic{}                  -> error "Data.SBV.Query: SMTLib does not allow querying value of the logic!"+                 -- Not to be confused by getInfo, which is totally irrelevant!+                 SetInfo{}                   -> error "Data.SBV.Query: SMTLib does not allow querying value of meta-info!"++  where askFor sbvName smtLibName continue = do+                let cmd = "(get-option " ++ smtLibName ++ ")"+                    bad = unexpected ("getOption " ++ sbvName) cmd "a valid option value" Nothing++                r <- ask cmd++                parse r bad $ \case ECon "unsupported" -> return Nothing+                                    e                  -> continue e (bad r)++        string c (ECon s) _ = return $ Just $ c s+        string _ e        k = k $ Just ["Expected string, but got: " ++ show (serialize False e)]++        bool c (ENum (0, _)) _ = return $ Just $ c False+        bool c (ENum (1, _)) _ = return $ Just $ c True+        bool _ e             k = k $ Just ["Expected boolean, but got: " ++ show (serialize False e)]++        integer c (ENum (i, _)) _ = return $ Just $ c i+        integer _ e             k = k $ Just ["Expected integer, but got: " ++ show (serialize False e)]++        -- free format, really+        stringList c e _ = return $ Just $ c $ stringsOf e++-- | Get the reason unknown. Only internally used.+getUnknownReason :: Query String+getUnknownReason = do ru <- getInfo ReasonUnknown+                      case ru of+                        Resp_Unsupported     -> return "No reason provided."+                        Resp_ReasonUnknown r -> return $ case r of+                                                           UnknownMemOut       -> "Out of memory."+                                                           UnknownIncomplete   -> "Incomplete."+                                                           UnknownOther      s -> s+                        -- Shouldn't happen, but just in case:+                        _                    -> return $ "Unexpected reason value received: " ++ show ru++-- | Issue check-sat and get an SMT Result out.+getSMTResult :: Query SMTResult+getSMTResult = do cfg <- getConfig+                  cs  <- checkSat+                  case cs of+                    Unsat -> return $ Unsatisfiable cfg+                    Sat   -> Satisfiable cfg <$> getModel+                    Unk   -> Unknown     cfg <$> getUnknownReason++-- | Classify a model based on whether it has unbound objectives or not.+classifyModel :: SMTConfig -> SMTModel -> SMTResult+classifyModel cfg m = case filter (not . isRegularCW . snd) (modelObjectives m) of+                        [] -> Satisfiable cfg m+                        _  -> SatExtField cfg m++-- | Issue check-sat and get results of a lexicographic optimization.+getLexicographicOptResults :: Query SMTResult+getLexicographicOptResults = do cfg <- getConfig+                                cs  <- checkSat+                                case cs of+                                  Unsat -> return $ Unsatisfiable cfg+                                  Sat   -> classifyModel cfg <$> getModelWithObjectives+                                  Unk   -> Unknown       cfg <$> getUnknownReason+   where getModelWithObjectives = do objectiveValues <- getObjectiveValues+                                     m               <- getModel+                                     return m {modelObjectives = objectiveValues}++-- | Issue check-sat and get results of an independent (boxed) optimization.+getIndependentOptResults :: [String] -> Query [(String, SMTResult)]+getIndependentOptResults objNames = do cfg <- getConfig+                                       cs  <- checkSat++                                       case cs of+                                         Unsat -> return [(nm, Unsatisfiable cfg) | nm <- objNames]+                                         Sat   -> continue (classifyModel cfg)+                                         Unk   -> do ur <- Unknown cfg <$> getUnknownReason+                                                     return [(nm, ur) | nm <- objNames]++  where continue classify = do objectiveValues <- getObjectiveValues+                               nms <- zipWithM getIndependentResult [0..] objNames+                               return [(n, classify (m {modelObjectives = objectiveValues})) | (n, m) <- nms]++        getIndependentResult :: Int -> String -> Query (String, SMTModel)+        getIndependentResult i s = do m <- getModelAtIndex (Just i)+                                      return (s, m)++-- | Construct a pareto-front optimization result+getParetoOptResults :: Maybe Int -> Query (Bool, [SMTResult])+getParetoOptResults (Just i)+        | i <= 0             = return (True, [])+getParetoOptResults mbN      = do cfg <- getConfig+                                  cs  <- checkSat++                                  case cs of+                                    Unsat -> return (False, [])+                                    Sat   -> continue (classifyModel cfg)+                                    Unk   -> do ur <- getUnknownReason+                                                return (False, [ProofError cfg [ur]])++  where continue classify = do m <- getModel+                               (limReached, fronts) <- getParetoFronts (subtract 1 <$> mbN) [m]+                               return (limReached, reverse (map classify fronts))++        getParetoFronts :: Maybe Int -> [SMTModel] -> Query (Bool, [SMTModel])+        getParetoFronts (Just i) sofar | i <= 0 = return (True, sofar)+        getParetoFronts mbi      sofar          = do cs <- checkSat+                                                     let more = getModel >>= \m -> getParetoFronts (subtract 1 <$> mbi) (m : sofar)+                                                     case cs of+                                                       Unsat -> return (False, sofar)+                                                       Sat   -> more+                                                       Unk   -> more++-- | Collect model values. It is implicitly assumed that we are in a check-sat+-- context. See 'getSMTResult' for a variant that issues a check-sat first and+-- returns an 'SMTResult'.+getModel :: Query SMTModel+getModel = getModelAtIndex Nothing++-- | Get a model stored at an index. This is likely very Z3 specific!+getModelAtIndex :: Maybe Int -> Query SMTModel+getModelAtIndex mbi = do+             State{runMode} <- get+             cfg  <- getConfig+             inps <- getQuantifiedInputs+             rm   <- io $ readIORef runMode+             let vars :: [NamedSymVar]+                 vars = case rm of+                          m@CodeGen         -> error $ "SBV.getModel: Model is not available in mode: " ++ show m+                          m@Concrete        -> error $ "SBV.getModel: Model is not available in mode: " ++ show m+                          SMTMode _ isSAT _ -> -- for "sat", display the prefix existentials. for "proof", display the prefix universals+                                               let allModelInputs = if isSAT then takeWhile ((/= ALL) . fst) inps+                                                                             else takeWhile ((== ALL) . fst) inps++                                                   sortByNodeId :: [NamedSymVar] -> [NamedSymVar]+                                                   sortByNodeId = sortBy (compare `on` (\(SW _ n, _) -> n))++                                               in sortByNodeId [nv | (_, nv@(_, n)) <- allModelInputs, not (isNonModelVar cfg n)]++             assocs <- mapM (\(sw, n) -> (n, ) <$> getValueCW mbi sw) vars++             return SMTModel { modelObjectives = []+                             , modelAssocs     = assocs+                             }++-- | Just after a check-sat is issued, collect objective values. Used+-- internally only, not exposed to the user.+getObjectiveValues :: Query [(String, GeneralizedCW)]+getObjectiveValues = do let cmd = "(get-objectives)"++                            bad = unexpected "getObjectiveValues" cmd "a list of objective values" Nothing++                        r <- ask cmd++                        inputs <- map snd <$> getQuantifiedInputs++                        parse r bad $ \case EApp (ECon "objectives" : es) -> do mbVals <- mapM (getObjValue (bad r) inputs) es+                                                                                return $ catMaybes mbVals+                                            _                             -> bad r Nothing++  where -- | Parse an objective value out.+        getObjValue :: (forall a. Maybe [String] -> Query a) -> [NamedSymVar] -> SExpr -> Query (Maybe (String, GeneralizedCW))+        getObjValue bailOut inputs expr =+                case expr of+                  EApp [_]          -> return Nothing  -- Happens when a soft-assertion has no associated group.+                  EApp [ECon nm, v] -> case listToMaybe [p | p@(sw, _) <- inputs, show sw == nm] of+                                         Nothing               -> return Nothing -- Happens when the soft assertion has a group-id that's not one of the input names+                                         Just (sw, actualName) -> grab sw v >>= \val -> return $ Just (actualName, val)+                  _                 -> dontUnderstand (show expr)++          where dontUnderstand s = bailOut $ Just [ "Unable to understand solver output."+                                                  , "While trying to process: " ++ s+                                                  ]++                grab :: SW -> SExpr -> Query GeneralizedCW+                grab s topExpr = extract topExpr+                  where k = kindOf s++                        -- things that can be printed as "integral" values+                        isFromInteger sw = or [f sw | f <- [isBoolean, isBounded, isInteger, isReal, isFloat, isDouble]]++                        getUIIndex (KUserSort  _ (Right xs)) i = i `elemIndex` xs+                        getUIIndex _                         _ = Nothing++                        guard True  v = return v+                        guard False _ = dontUnderstand (show topExpr)++                        extract (ENum    i) = guard (isFromInteger s) $ RegularCW  $ mkConstCW  k (fst i)+                        extract (EReal   i) = guard (isReal        s) $ RegularCW  $ CW KReal   (CWAlgReal i)+                        extract (EFloat  i) = guard (isFloat       s) $ RegularCW  $ CW KFloat  (CWFloat   i)+                        extract (EDouble i) = guard (isDouble      s) $ RegularCW  $ CW KDouble (CWDouble  i)++                        -- If we have an ECon, it could be uninterpted, or oo/epsilon+                        extract (ECon i)+                           | isUninterpreted s = return $ RegularCW  $ CW k (CWUserSort (getUIIndex k i, i))++                        -- Exhausted regular values, look for infinities and such:+                        extract val         = ExtendedCW <$> cvt (simplify val)++                        -- Convert to an extended expression. Hopefully complete!+                        cvt :: SExpr -> Query ExtCW+                        cvt (ECon "oo")                    = return $ Infinite  k+                        cvt (ECon "epsilon")               = return $ Epsilon   k+                        cvt (EApp [ECon "interval", x, y]) =          Interval  <$> cvt x <*> cvt y+                        cvt (ENum    (i, _))               = return $ BoundedCW $ mkConstCW k i+                        cvt (EReal   r)                    = return $ BoundedCW $ CW k $ CWAlgReal r+                        cvt (EFloat  f)                    = return $ BoundedCW $ CW k $ CWFloat   f+                        cvt (EDouble d)                    = return $ BoundedCW $ CW k $ CWDouble  d+                        cvt (EApp [ECon "+", x, y])        =          AddExtCW <$> cvt x <*> cvt y+                        cvt (EApp [ECon "*", x, y])        =          MulExtCW <$> cvt x <*> cvt y+                        -- Nothing else should show up, hopefully!+                        cvt e = dontUnderstand (show e)++                        -- drop the pesky to_real's that Z3 produces.. Cool but useless.+                        simplify :: SExpr -> SExpr+                        simplify (EApp [ECon "to_real", n]) = n+                        simplify (EApp xs)                  = EApp (map simplify xs)+                        simplify e                          = e++-- | Check for satisfiability, under the given conditions. Similar to 'checkSat' except it allows making+-- further assumptions as captured by the first argument of booleans. (Also see 'checkSatAssumingWithUnsatisfiableSet'+-- for a variant that returns the subset of the given assumptions that led to the 'Unsat' conclusion.)+checkSatAssuming :: [SBool] -> Query CheckSatResult+checkSatAssuming sBools = fst <$> checkSatAssumingHelper False sBools++-- | Check for satisfiability, under the given conditions. Returns the unsatisfiable+-- set of assumptions. Similar to 'checkSat' except it allows making further assumptions+-- as captured by the first argument of booleans. If the result is 'Unsat', the user will+-- also receive a subset of the given assumptions that led to the 'Unsat' conclusion. Note+-- that while this set will be a subset of the inputs, it is not necessarily guaranteed to be minimal.+--+-- You must have arranged for the production of unsat assumptions+-- first (/via/ @'setOption' $ 'ProduceUnsatAssumptions' 'True'@)+-- for this call to not error out!+--+-- Usage note: 'getUnsatCore' is usually easier to use than 'checkSatAssumingWithUnsatisfiableSet', as it+-- allows the use of named assertions, as obtained by 'namedAssert'. If 'getUnsatCore'+-- fills your needs, you should definitely prefer it over 'checkSatAssumingWithUnsatisfiableSet'.+checkSatAssumingWithUnsatisfiableSet :: [SBool] -> Query (CheckSatResult, Maybe [SBool])+checkSatAssumingWithUnsatisfiableSet = checkSatAssumingHelper True++-- | Helper for the two variants of checkSatAssuming we have. Internal only.+checkSatAssumingHelper :: Bool -> [SBool] -> Query (CheckSatResult, Maybe [SBool])+checkSatAssumingHelper getAssumptions sBools = do+        -- sigh.. SMT-Lib requires the values to be literals only. So, create proxies.+        let mkAssumption st = do swsOriginal <- mapM (\sb -> do sw <- sbvToSW st sb+                                                                return (sw, sb)) sBools++                                 -- drop duplicates and trues+                                 let swbs = [p | p@(sw, _) <- nubBy ((==) `on` fst) swsOriginal, sw /= trueSW]++                                 -- get a unique proxy name for each+                                 uniqueSWBs <- mapM (\(sw, sb) -> do unique <- incrementInternalCounter st+                                                                     return (sw, (unique, sb))) swbs++                                 let translate (sw, (unique, sb)) = (nm, decls, (proxy, sb))+                                        where nm    = show sw+                                              proxy = "__assumption_proxy_" ++ nm ++ "_" ++ show unique+                                              decls = [ "(declare-const " ++ proxy ++ " Bool)"+                                                      , "(assert (= " ++ proxy ++ " " ++ nm ++ "))"+                                                      ]++                                 return $ map translate uniqueSWBs++        assumptions <- inNewContext mkAssumption++        let (origNames, declss, proxyMap) = unzip3 assumptions++        let cmd = "(check-sat-assuming (" ++ unwords (map fst proxyMap) ++ "))"+            bad = unexpected "checkSatAssuming" cmd "one of sat/unsat/unknown"+                           $ Just [ "Make sure you use:"+                                  , ""+                                  , "       setOption $ ProduceUnsatAssumptions True"+                                  , ""+                                  , "to tell the solver to produce unsat assumptions."+                                  ]++        mapM_ (send True) $ concat declss+        r <- ask cmd++        let grabUnsat+             | getAssumptions = do as <- getUnsatAssumptions origNames proxyMap+                                   return (Unsat, Just as)+             | True           = return (Unsat, Nothing)++        parse r bad $ \case ECon "sat"     -> return (Sat, Nothing)+                            ECon "unsat"   -> grabUnsat+                            ECon "unknown" -> return (Unk, Nothing)+                            _              -> bad r Nothing++-- | The current assertion stack depth, i.e., #push - #pops after start. Always non-negative.+getAssertionStackDepth :: Query Int+getAssertionStackDepth = queryAssertionStackDepth <$> getQueryState++-- | Run the query in a new assertion stack. That is, we push the context, run the query+-- commands, and pop it back.+inNewAssertionStack :: Query a -> Query a+inNewAssertionStack q = do push 1+                           r <- q+                           pop 1+                           return r++-- | Push the context, entering a new one. Pushes multiple levels if /n/ > 1.+push :: Int -> Query ()+push i+ | i <= 0 = error $ "Data.SBV: push requires a strictly positive level argument, received: " ++ show i+ | True   = do depth <- getAssertionStackDepth+               send True $ "(push " ++ show i ++ ")"+               modifyQueryState $ \s -> s{queryAssertionStackDepth = depth + i}++-- | Pop the context, exiting a new one. Pops multiple levels if /n/ > 1. It's an error to pop levels that don't exist.+pop :: Int -> Query ()+pop i+ | i <= 0 = error $ "Data.SBV: pop requires a strictly positive level argument, received: " ++ show i+ | True   = do depth <- getAssertionStackDepth+               if i > depth+                  then error $ "Data.SBV: Illegally trying to pop " ++ shl i ++ ", at current level: " ++ show depth+                  else do QueryState{queryConfig} <- getQueryState+                          if not (supportsGlobalDecls (capabilities (solver queryConfig)))+                             then error $ unlines [ ""+                                                  , "*** Data.SBV: Backend solver does not support global-declarations."+                                                  , "***           Hence, calls to 'pop' are not supported."+                                                  , "***"+                                                  , "*** Request this as a feature for the underlying solver!"+                                                  ]+                             else do send True $ "(pop " ++ show i ++ ")"+                                     modifyQueryState $ \s -> s{queryAssertionStackDepth = depth - i}+   where shl 1 = "one level"+         shl n = show n ++ " levels"++-- | Search for a result via a sequence of case-splits, guided by the user. If one of+-- the conditions lead to a satisfiable result, returns @Just@ that result. If none of them+-- do, returns @Nothing@. Note that we automatically generate a coverage case and search+-- for it automatically as well. In that latter case, the string returned will be "Coverage".+-- The first argument controls printing progress messages +caseSplit :: Bool -> [(String, SBool)] -> Query (Maybe (String, SMTResult))+caseSplit printCases cases = do cfg <- getConfig+                                go cfg (cases ++ [("Coverage", bnot (bOr (map snd cases)))])+  where msg = when printCases . io . putStrLn++        go _ []            = return Nothing+        go cfg ((n,c):ncs) = do let notify s = msg $ "Case " ++ n ++ ": " ++ s++                                notify "Starting"+                                r <- checkSatAssuming [c]++                                case r of+                                  Unsat -> do notify "Unsatisfiable"+                                              go cfg ncs++                                  Sat   -> do notify "Satisfiable"+                                              res <- Satisfiable cfg <$> getModel+                                              return $ Just (n, res)++                                  Unk   -> do notify "Unknown"+                                              res <- Unknown cfg <$> getUnknownReason+                                              return $ Just (n, res)++-- | Reset the solver, by forgetting all the assertions. However, bindings are kept as is,+-- as opposed to 'reset'. Use this variant to clean-up the solver state while leaving the bindings+-- intact. Pops all assertion levels. Declarations and definitions resulting from the 'setLogic'+-- command are unaffected. Note that SBV implicitly uses global-declarations, so bindings will remain intact.+resetAssertions :: Query ()+resetAssertions = do send True "(reset-assertions)"+                     modifyQueryState $ \s -> s{queryAssertionStackDepth = 0}++-- | Echo a string. Note that the echoing is done by the solver, not by SBV.+echo :: String -> Query ()+echo s = do let cmd = "(echo \"" ++ concatMap sanitize s ++ "\")"++            -- we send the command, but otherwise ignore the response+            -- note that 'send True/False' would be incorrect here. 'send True' would+            -- require a success response. 'send False' would fail to consume the+            -- output. But 'ask' does the right thing! It gets "some" response,+            -- and forgets about it immediately.+            _ <- ask cmd++            return ()+  where sanitize '"'  = "\"\""  -- quotes need to be duplicated+        sanitize c    = [c]++-- | Exit the solver. This action will cause the solver to terminate. Needless to say,+-- trying to communicate with the solver after issuing "exit" will simply fail.+exit :: Query ()+exit = do send True "(exit)"+          modifyQueryState $ \s -> s{queryAssertionStackDepth = 0}++-- | Retrieve the unsat-core. Note you must have arranged for+-- unsat cores to be produced first (/via/ @'setOption' $ 'ProduceUnsatCores' 'True'@)+-- for this call to not error out!+getUnsatCore :: Query [String]+getUnsatCore = do+        let cmd = "(get-unsat-core)"+            bad = unexpected "getUnsatCore" cmd "an unsat-core response"+                           $ Just [ "Make sure you use:"+                                  , ""+                                  , "       setOption $ ProduceUnsatCores True"+                                  , ""+                                  , "so the solver will be ready to compute unsat cores,"+                                  , "and that there is a model by first issuing a 'checkSat' call."+                                  ]++        r <- ask cmd++        parse r bad $ \case+           EApp es | Just xs <- mapM fromECon es -> return $ map unBar xs+           _                                     -> bad r Nothing++-- | Retrieve the proof. Note you must have arranged for+-- proofs to be produced first (/via/ @'setOption' $ 'ProduceProofs' 'True'@)+-- for this call to not error out!+--+-- A proof is simply a 'String', as returned by the solver. In the future, SBV might+-- provide a better datatype, depending on the use cases. Please get in touch if you+-- use this function and can suggest a better API.+getProof :: Query String+getProof = do+        let cmd = "(get-proof)"+            bad = unexpected "getProof" cmd "a get-proof response"+                           $ Just [ "Make sure you use:"+                                  , ""+                                  , "       setOption $ ProduceProofs True"+                                  , ""+                                  , "to make sure the solver is ready for producing proofs."+                                  , "and that there is a proof by first issuing a 'checkSat' call."+                                  ]+++        r <- ask cmd++        -- we only care about the fact that we can parse the output, so the+        -- result of parsing is ignored.+        parse r bad $ \_ -> return r++-- | Retrieve assertions. Note you must have arranged for+-- assertions to be available first (/via/ @'setOption' $ 'ProduceAssertions' 'True'@)+-- for this call to not error out!+--+-- Note that the set of assertions returned is merely a list of strings, just like the+-- case for 'getProof'. In the future, SBV might provide a better datatype, depending+-- on the use cases. Please get in touch if you use this function and can suggest+-- a better API.+getAssertions :: Query [String]+getAssertions = do+        let cmd = "(get-assertions)"+            bad = unexpected "getAssertions" cmd "a get-assertions response"+                           $ Just [ "Make sure you use:"+                                  , ""+                                  , "       setOption $ ProduceAssertions True"+                                  , ""+                                  , "to make sure the solver is ready for producing assertions."+                                  ]++            render = serialize False++        r <- ask cmd++        parse r bad $ \pe -> case pe of+                                EApp xs -> return $ map render xs+                                _       -> return [render pe]++-- | Retrieve the assignment. This is a lightweight version of 'getValue', where the+-- solver returns the truth value for all named subterms of type 'Bool'.+getAssignment :: Query [(String, Bool)]+getAssignment = do+        let cmd = "(get-assignment)"+            bad = unexpected "getAssignment" cmd "a get-assignment response"+                           $ Just [ "Make sure you use:"+                                  , ""+                                  , "       setOption $ ProduceAssignments True"+                                  , ""+                                  , "to make sure the solver is ready for producing assignments,"+                                  , "and that there is a model by first issuing a 'checkSat' call."+                                  ]++            -- we're expecting boolean assignment to labels, essentially+            grab (EApp [ECon s, ENum (0, _)]) = Just (unQuote s, False)+            grab (EApp [ECon s, ENum (1, _)]) = Just (unQuote s, True)+            grab _                            = Nothing++        r <- ask cmd++        parse r bad $ \case EApp ps | Just vs <- mapM grab ps -> return vs+                            _                                 -> bad r Nothing++-- | Make an assignment. The type 'Assignment' is abstract, see 'success' for an example use case.+infix 1 |->+(|->) :: SymWord a => SBV a -> a -> Assignment+SBV a |-> v = case literal v of+                SBV (SVal _ (Left cw)) -> Assign a cw+                r                      -> error $ "Data.SBV: Impossible happened in |->: Cannot construct a CW with literal: " ++ show r++-- | Produce the query result from an assignment.+mkSMTResult :: [Assignment] -> Query SMTResult+mkSMTResult asgns = do+             QueryState{queryConfig} <- getQueryState+             inps <- getQuantifiedInputs++             let grabValues st = do let extract (Assign s n) = sbvToSW st (SBV s) >>= \sw -> return (sw, n)++                                    modelAssignment <- mapM extract asgns++                                    -- sanity checks+                                    --     - All existentials should be given a value+                                    --     - No duplicates+                                    --     - No bindings to vars that are not inputs+                                    let userSS = map fst modelAssignment++                                        missing, extra, dup :: [String]+                                        missing = [n | (EX, (s, n)) <- inps, s `notElem` userSS]+                                        extra   = [show s | s <- userSS, s `notElem` map (fst . snd) inps]+                                        dup     = let walk []     = []+                                                      walk (n:ns)+                                                        | n `elem` ns = show n : walk (filter (/= n) ns)+                                                        | True        = walk ns+                                                  in walk userSS++                                    unless (null (missing ++ extra ++ dup)) $ do++                                          let misTag = "***   Missing inputs"+                                              dupTag = "***   Duplicate bindings"+                                              extTag = "***   Extra bindings"++                                              maxLen = maximum $  0+                                                                : [length misTag | not (null missing)]+                                                               ++ [length extTag | not (null extra)]+                                                               ++ [length dupTag | not (null dup)]++                                              align s = s ++ replicate (maxLen - length s) ' ' ++ ": "++                                          error $ unlines $ [""+                                                            , "*** Data.SBV: Query model construction has a faulty assignment."+                                                            , "***"+                                                            ]+                                                         ++ [ align misTag ++ intercalate ", "  missing | not (null missing)]+                                                         ++ [ align extTag ++ intercalate ", "  extra   | not (null extra)  ]+                                                         ++ [ align dupTag ++ intercalate ", "  dup     | not (null dup)    ]+                                                         ++ [ "***"+                                                            , "*** Data.SBV: Check your query result construction!"+                                                            ]++                                    let findName s = case [nm | (_, (i, nm)) <- inps, s == i] of+                                                        [nm] -> nm+                                                        []   -> error "*** Data.SBV: Impossible happened: Cannot find " ++ show s ++ " in the input list"+                                                        nms  -> error $ unlines [ ""+                                                                                , "*** Data.SBV: Impossible happened: Multiple matches for: " ++ show s+                                                                                , "***   Candidates: " ++ unwords nms+                                                                                ]++                                    return [(findName s, n) | (s, n) <- modelAssignment]++             assocs <- inNewContext grabValues++             let m = SMTModel { modelObjectives = []+                              , modelAssocs     = assocs+                              }++             return $ Satisfiable queryConfig m
+ Data/SBV/Control/Types.hs view
@@ -0,0 +1,191 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Control.Types+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Types related to interactive queries+-----------------------------------------------------------------------------++{-# LANGUAGE DeriveGeneric  #-}+{-# LANGUAGE DeriveAnyClass #-}++module Data.SBV.Control.Types (+       CheckSatResult(..)+     , Logic(..)+     , SMTOption(..), isStartModeOption, setSMTOption+     , SMTInfoFlag(..)+     , SMTErrorBehavior(..)+     , SMTReasonUnknown(..)+     , SMTInfoResponse(..)+     ) where++import Generics.Deriving.Base (Generic)+import Generics.Deriving.Show (GShow, gshow)++import Control.DeepSeq (NFData(..))++-- | Result of a 'checkSat' or 'checkSatAssuming' call.+data CheckSatResult = Sat | Unsat | Unk+                    deriving (Eq, Show)++-- | Collectable information from the solver.+data SMTInfoFlag = AllStatistics+                 | AssertionStackLevels+                 | Authors+                 | ErrorBehavior+                 | Name+                 | ReasonUnknown+                 | Version+                 | InfoKeyword String++-- | Behavior of the solver for errors.+data SMTErrorBehavior = ErrorImmediateExit+                      | ErrorContinuedExecution+                      deriving Show++-- | Reason for reporting unknown.+data SMTReasonUnknown = UnknownMemOut+                      | UnknownIncomplete+                      | UnknownOther      String+                      deriving Show++-- | Collectable information from the solver.+data SMTInfoResponse = Resp_Unsupported+                     | Resp_AllStatistics        [(String, String)]+                     | Resp_AssertionStackLevels Integer+                     | Resp_Authors              [String]+                     | Resp_Error                SMTErrorBehavior+                     | Resp_Name                 String+                     | Resp_ReasonUnknown        SMTReasonUnknown+                     | Resp_Version              String+                     | Resp_InfoKeyword          String [String]+                     deriving Show++-- Show instance for SMTInfoFlag maintains smt-lib format per the SMTLib2 standard document.+instance Show SMTInfoFlag where+  show AllStatistics        = ":all-statistics"+  show AssertionStackLevels = ":assertion-stack-levels"+  show Authors              = ":authors"+  show ErrorBehavior        = ":error-behavior"+  show Name                 = ":name"+  show ReasonUnknown        = ":reason-unknown"+  show Version              = ":version"+  show (InfoKeyword s)      = s++-- | Option values that can be set in the solver, following the SMTLib specification <http://smtlib.cs.uiowa.edu/language.shtml>.+--+-- Note that not all solvers may support all of these!+--+-- Furthermore, SBV doesn't support the following options allowed by SMTLib.+--+--    * @:interactive-mode@                (Deprecated in SMTLib, use 'ProduceAssertions' instead.)+--    * @:print-success@                   (SBV critically needs this to be True in query mode.)+--    * @:produce-models@                  (SBV always sets this option so it can extract models.)+--    * @:regular-output-channel@          (SBV always requires regular output to come on stdout for query purposes.)+--    * @:global-declarations@             (SBV always uses global declarations since definitions are accumulative.)+--+-- Note that 'SetLogic' and 'SetInfo' are, strictly speaking, not SMTLib options. However, we treat it as such here+-- uniformly, as it fits better with how options work.+data SMTOption = DiagnosticOutputChannel   FilePath+               | ProduceAssertions         Bool+               | ProduceAssignments        Bool+               | ProduceProofs             Bool+               | ProduceUnsatAssumptions   Bool+               | ProduceUnsatCores         Bool+               | RandomSeed                Integer+               | ReproducibleResourceLimit Integer+               | SMTVerbosity              Integer+               | OptionKeyword             String  [String]+               | SetLogic                  Logic+               | SetInfo                   String  [String]+               deriving (Show, Generic, NFData)++-- | Can this command only be run at the very beginning? If 'True' then+-- we will reject setting these options in the query mode. Note that this+-- classification follows the SMTLib document.+isStartModeOption :: SMTOption -> Bool+isStartModeOption DiagnosticOutputChannel{}   = False+isStartModeOption ProduceAssertions{}         = True+isStartModeOption ProduceAssignments{}        = True+isStartModeOption ProduceProofs{}             = True+isStartModeOption ProduceUnsatAssumptions{}   = True+isStartModeOption ProduceUnsatCores{}         = True+isStartModeOption RandomSeed{}                = True+isStartModeOption ReproducibleResourceLimit{} = False+isStartModeOption SMTVerbosity{}              = False+isStartModeOption OptionKeyword{}             = True  -- Conservative.+isStartModeOption SetLogic{}                  = True+isStartModeOption SetInfo{}                   = False++-- SMTLib's True/False is spelled differently than Haskell's.+smtBool :: Bool -> String+smtBool True  = "true"+smtBool False = "false"++-- | Translate an option setting to SMTLib. Note the SetLogic/SetInfo discrepancy.+setSMTOption :: SMTOption -> String+setSMTOption = cvt+  where cvt (DiagnosticOutputChannel   f) = opt   [":diagnostic-output-channel",   show f]+        cvt (ProduceAssertions         b) = opt   [":produce-assertions",          smtBool b]+        cvt (ProduceAssignments        b) = opt   [":produce-assignments",         smtBool b]+        cvt (ProduceProofs             b) = opt   [":produce-proofs",              smtBool b]+        cvt (ProduceUnsatAssumptions   b) = opt   [":produce-unsat-assumptions",   smtBool b]+        cvt (ProduceUnsatCores         b) = opt   [":produce-unsat-cores",         smtBool b]+        cvt (RandomSeed                i) = opt   [":random-seed",                 show i]+        cvt (ReproducibleResourceLimit i) = opt   [":reproducible-resource-limit", show i]+        cvt (SMTVerbosity              i) = opt   [":verbosity",                   show i]+        cvt (OptionKeyword          k as) = opt   (k : as)+        cvt (SetLogic                  l) = logic l+        cvt (SetInfo                k as) = info  (k : as)++        opt   xs = "(set-option " ++ unwords xs ++ ")"+        info  xs = "(set-info "   ++ unwords xs ++ ")"+        logic l  = "(set-logic "  ++ show l     ++ ")"++-- | SMT-Lib logics. If left unspecified SBV will pick the logic based on what it determines is needed. However, the+-- user can override this choice using the tactic 'SetOptions' This is especially handy if one is experimenting with custom+-- logics that might be supported on new solvers. See <http://smtlib.cs.uiowa.edu/logics.shtml> for the official list.+data Logic+  = AUFLIA             -- ^ Formulas over the theory of linear integer arithmetic and arrays extended with free sort and function symbols but restricted to arrays with integer indices and values.+  | AUFLIRA            -- ^ Linear formulas with free sort and function symbols over one- and two-dimentional arrays of integer index and real value.+  | AUFNIRA            -- ^ Formulas with free function and predicate symbols over a theory of arrays of arrays of integer index and real value.+  | LRA                -- ^ Linear formulas in linear real arithmetic.+  | QF_ABV             -- ^ Quantifier-free formulas over the theory of bitvectors and bitvector arrays.+  | QF_AUFBV           -- ^ Quantifier-free formulas over the theory of bitvectors and bitvector arrays extended with free sort and function symbols.+  | QF_AUFLIA          -- ^ Quantifier-free linear formulas over the theory of integer arrays extended with free sort and function symbols.+  | QF_AX              -- ^ Quantifier-free formulas over the theory of arrays with extensionality.+  | QF_BV              -- ^ Quantifier-free formulas over the theory of fixed-size bitvectors.+  | QF_IDL             -- ^ Difference Logic over the integers. Boolean combinations of inequations of the form x - y < b where x and y are integer variables and b is an integer constant.+  | QF_LIA             -- ^ Unquantified linear integer arithmetic. In essence, Boolean combinations of inequations between linear polynomials over integer variables.+  | QF_LRA             -- ^ Unquantified linear real arithmetic. In essence, Boolean combinations of inequations between linear polynomials over real variables.+  | QF_NIA             -- ^ Quantifier-free integer arithmetic.+  | QF_NRA             -- ^ Quantifier-free real arithmetic.+  | QF_RDL             -- ^ Difference Logic over the reals. In essence, Boolean combinations of inequations of the form x - y < b where x and y are real variables and b is a rational constant.+  | QF_UF              -- ^ Unquantified formulas built over a signature of uninterpreted (i.e., free) sort and function symbols.+  | QF_UFBV            -- ^ Unquantified formulas over bitvectors with uninterpreted sort function and symbols.+  | QF_UFIDL           -- ^ Difference Logic over the integers (in essence) but with uninterpreted sort and function symbols.+  | QF_UFLIA           -- ^ Unquantified linear integer arithmetic with uninterpreted sort and function symbols.+  | QF_UFLRA           -- ^ Unquantified linear real arithmetic with uninterpreted sort and function symbols.+  | QF_UFNRA           -- ^ Unquantified non-linear real arithmetic with uninterpreted sort and function symbols.+  | QF_UFNIRA          -- ^ Unquantified non-linear real integer arithmetic with uninterpreted sort and function symbols.+  | UFLRA              -- ^ Linear real arithmetic with uninterpreted sort and function symbols.+  | UFNIA              -- ^ Non-linear integer arithmetic with uninterpreted sort and function symbols.+  | QF_FPBV            -- ^ Quantifier-free formulas over the theory of floating point numbers, arrays, and bit-vectors.+  | QF_FP              -- ^ Quantifier-free formulas over the theory of floating point numbers.+  | QF_FD              -- ^ Quantifier-free finite domains+  | Logic_ALL          -- ^ The catch-all value+  | CustomLogic String -- ^ In case you need a really custom string!+  deriving (Generic, NFData)++-- The show instance is "almost" the derived one, but not quite!+instance GShow Logic+instance Show Logic where+  show Logic_ALL       = "ALL"+  show (CustomLogic l) = l+  show l               = gshow l++{-# ANN type SMTInfoResponse ("HLint: ignore Use camelCase" :: String) #-}+{-# ANN type Logic           ("HLint: ignore Use camelCase" :: String) #-}
+ Data/SBV/Control/Utils.hs view
@@ -0,0 +1,609 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Control.Utils+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Query related utils.+-----------------------------------------------------------------------------++{-# LANGUAGE BangPatterns          #-}+{-# LANGUAGE DefaultSignatures     #-}+{-# LANGUAGE LambdaCase            #-}+{-# LANGUAGE NamedFieldPuns        #-}+{-# LANGUAGE ScopedTypeVariables   #-}+{-# OPTIONS_GHC -fno-warn-orphans  #-}++module Data.SBV.Control.Utils (+       io+     , ask, send, getValue, getUninterpretedValue, getValueCW, getUnsatAssumptions, SMTValue(..)+     , getQueryState, modifyQueryState, getConfig, getObjectives, getSBVAssertions, getQuantifiedInputs+     , checkSat, checkSatUsing, getAllSatResult+     , inNewContext, freshVar, freshVar_+     , parse+     , unexpected+     , timeout+     , queryDebug+     , retrieveResponse+     , runProofOn+     ) where++import Data.List  (sortBy, elemIndex, partition, groupBy, tails)++import Data.Ord      (comparing)+import Data.Function (on)++import Data.Int+import Data.Word++import qualified Data.Map as Map++import Control.Monad            (unless)+import Control.Monad.State.Lazy (get, liftIO)++import Data.IORef (readIORef, writeIORef)++import Data.Time (getZonedTime)++import Data.SBV.Core.Data     ( SW(..), CW(..), SBV, AlgReal, sbvToSW, kindOf, Kind(..)+                              , HasKind(..), mkConstCW, CWVal(..), SMTResult(..)+                              , NamedSymVar, SMTConfig(..), Query, SMTModel(..)+                              , QueryState(..), SVal(..), Quantifier(..), cache+                              , newExpr, SBVExpr(..), Op(..), FPOp(..), SBV(..)+                              , SolverContext(..), SBool, Objective(..), SolverCapabilities(..), capabilities+                              , Result(..), SMTProblem(..), trueSW, SymWord(..)+                              )+import Data.SBV.Core.Symbolic (IncState(..), withNewIncState, State(..), svToSW, registerLabel, svMkSymVar)++import Data.SBV.Core.AlgReals   (mergeAlgReals)+import Data.SBV.Core.Operations (svNot, svNotEqual, svOr)++import Data.SBV.SMT.SMTLib  (toIncSMTLib, toSMTLib)+import Data.SBV.SMT.Utils   (showTimeoutValue, annotateWithName, alignDiagnostic, alignPlain, debug, mergeSExpr)++import Data.SBV.Utils.SExpr+import Data.SBV.Control.Types++import qualified Data.Set as Set (toList)++import GHC.Stack++-- | 'Query' as a 'SolverContext'.+instance SolverContext Query where+   constrain          = addQueryConstraint Nothing+   namedConstraint nm = addQueryConstraint (Just nm)++   setOption o+     | isStartModeOption o = error $ unlines [ ""+                                             , "*** Data.SBV: '" ++ show o ++ "' can only be set at start-up time."+                                             , "*** Hint: Move the call to 'setOption' before the query."+                                             ]+     | True                = send True $ setSMTOption o++-- | Adding a constraint, possibly named. Only used internally.+-- Use 'constrain' and 'namedConstraint' from user programs.+addQueryConstraint :: Maybe String -> SBool -> Query ()+addQueryConstraint mbNm b = do sw <- inNewContext (\st -> do maybe (return ()) (registerLabel st) mbNm+                                                             sbvToSW st b)+                               send True $ "(assert " ++ mkNamed mbNm (show sw)  ++ ")"+   where mkNamed Nothing   s = s+         mkNamed (Just nm) s = annotateWithName nm s+++-- | Get the current configuration+getConfig :: Query SMTConfig+getConfig = queryConfig <$> getQueryState++-- | Get the objectives+getObjectives :: Query [Objective (SW, SW)]+getObjectives = do State{rOptGoals} <- get+                   io $ reverse <$> readIORef rOptGoals++-- | Get the assertions put in via 'sAssert'+getSBVAssertions :: Query [(String, Maybe CallStack, SW)]+getSBVAssertions = do State{rAsserts} <- get+                      io $ reverse <$> readIORef rAsserts++-- | Perform an arbitrary IO action.+io :: IO a -> Query a+io = liftIO++-- | Sync-up the external solver with new context we have generated+syncUpSolver :: IncState -> Query ()+syncUpSolver is = do+        cfg <- getConfig+        ls  <- io $ do let swapc ((_, a), b)   = (b, a)+                           cmp   (a, _) (b, _) = a `compare` b+                       inps  <- reverse <$> readIORef (rNewInps is)+                       ks    <- readIORef (rNewKinds is)+                       cnsts <- sortBy cmp . map swapc . Map.toList <$> readIORef (rNewConsts is)+                       as    <- readIORef (rNewAsgns is)+                       return $ toIncSMTLib cfg inps ks cnsts as cfg+        mapM_ (send True) (mergeSExpr ls)++-- | Retrieve the query context+getQueryState :: Query QueryState+getQueryState = do state <- get+                   mbQS  <- io $ readIORef (queryState state)+                   case mbQS of+                     Nothing -> error $ unlines [ ""+                                                , "*** Data.SBV: Impossible happened: Query context required in a non-query mode."+                                                , "Please report this as a bug!"+                                                ]+                     Just qs -> return qs++-- | Modify the query state+modifyQueryState :: (QueryState -> QueryState) -> Query ()+modifyQueryState f = do state <- get+                        mbQS  <- io $ readIORef (queryState state)+                        case mbQS of+                          Nothing -> error $ unlines [ ""+                                                     , "*** Data.SBV: Impossible happened: Query context required in a non-query mode."+                                                     , "Please report this as a bug!"+                                                     ]+                          Just qs -> let fqs = f qs+                                     in fqs `seq` io $ writeIORef (queryState state) $ Just fqs++-- | Execute in a new incremental context+inNewContext :: (State -> IO a) -> Query a+inNewContext act = do st <- get+                      (is, r) <- io $ withNewIncState st act+                      syncUpSolver is+                      return r++-- | Similar to 'freshVar', except creates unnamed variable.+freshVar_ :: forall a. SymWord a => Query (SBV a)+freshVar_ = inNewContext $ fmap SBV . svMkSymVar (Just EX) k Nothing+  where k = kindOf (undefined :: a)++-- | Create a fresh variable in query mode. You should prefer+-- creating input variables using 'sBool', 'sInt32', etc., which act+-- as primary inputs to the model and can be existential or universal.+-- Use 'freshVar' only in query mode for anonymous temporary variables.+-- Such variables are always existential. Note that 'freshVar' should hardly be+-- needed: Your input variables and symbolic expressions should suffice for+-- most major use cases.+freshVar :: forall a. SymWord a => String -> Query (SBV a)+freshVar nm = inNewContext $ fmap SBV . svMkSymVar (Just EX) k (Just nm)+  where k = kindOf (undefined :: a)++-- | Internal diagnostic messages.+queryDebug :: [String] -> Query ()+queryDebug msgs = do QueryState{queryConfig} <- getQueryState+                     io $ debug queryConfig msgs++-- | Send a string to the solver, and return the response+ask :: String -> Query String+ask s = do QueryState{queryAsk, queryTimeOutValue} <- getQueryState++           case queryTimeOutValue of+             Nothing -> queryDebug ["[SEND] " `alignPlain` s]+             Just i  -> queryDebug ["[SEND, TimeOut: " ++ showTimeoutValue i ++ "] " `alignPlain` s]+           r <- io $ queryAsk queryTimeOutValue s+           queryDebug ["[RECV] " `alignPlain` r]++           return r++-- | Send a string to the solver. If the first argument is 'True', we will require+-- a "success" response as well. Otherwise, we'll fire and forget.+send :: Bool -> String -> Query ()+send requireSuccess s = do++            QueryState{queryAsk, querySend, queryConfig, queryTimeOutValue} <- getQueryState++            if requireSuccess && supportsCustomQueries (capabilities (solver queryConfig))+               then do r <- io $ queryAsk queryTimeOutValue s++                       case words r of+                         ["success"] -> queryDebug ["[GOOD] " `alignPlain` s]+                         _           -> do case queryTimeOutValue of+                                             Nothing -> queryDebug ["[FAIL] " `alignPlain` s]+                                             Just i  -> queryDebug [("[FAIL, TimeOut: " ++ showTimeoutValue i ++ "]  ") `alignPlain` s]+                                           unexpected "Command" s "success" Nothing r Nothing++               else io $ querySend queryTimeOutValue s  -- fire and forget. if you use this, you're on your own!++-- | Retrieve a responses from the solver until it produces a synchronization tag. We make the tag+-- unique by attaching a time stamp, so no need to worry about getting the wrong tag unless it happens+-- in the very same picosecond! We return multiple valid s-expressions till the solver responds with the tag.+-- Should only be used for internal tasks or when we want to synchronize communications, and not on a+-- regular basis! Use 'send'/'ask' for that purpose. This comes in handy, however, when solvers respond+-- multiple times as in optimization for instance, where we both get a check-sat answer and some objective values.+retrieveResponse :: String -> Maybe Int -> Query [String]+retrieveResponse userTag mbTo = do+             ts  <- io (show <$> getZonedTime)++             let synchTag = show $ userTag ++ " (at: " ++ ts ++ ")"+                 cmd = "(echo " ++ synchTag ++ ")"++             queryDebug ["[SYNC] Attempting to synchronize with tag: " ++ synchTag]++             send False cmd++             QueryState{queryRetrieveResponse} <- getQueryState++             let loop sofar = do+                  s <- io $ queryRetrieveResponse mbTo++                  -- strictly speaking SMTLib requires solvers to print quotes around+                  -- echo'ed strings, but they don't always do. Accommodate for that+                  -- here, though I wish we didn't have to.+                  if s == synchTag || show s == synchTag+                     then do queryDebug ["[SYNC] Synchronization achieved using tag: " ++ synchTag]+                             return $ reverse sofar+                     else do queryDebug ["[RECV] " `alignPlain` s]+                             loop (s : sofar)++             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 _          = Nothing++instance SMTValue Double where+   sexprToVal (EDouble f) = Just f+   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 _         = Nothing++-- | Get the value of a term.+getValue :: SMTValue a => SBV a -> Query a+getValue s = do sw <- inNewContext (`sbvToSW` s)+                let nm  = show sw+                    cmd = "(get-value (" ++ nm ++ "))"+                    bad = unexpected "getValue" cmd "a model value" Nothing+                r <- ask cmd+                parse r bad $ \case EApp [EApp [ECon o,  v]] | o == show sw -> case sexprToVal v of+                                                                                 Nothing -> bad r Nothing+                                                                                 Just c  -> return c+                                    _                                       -> bad r Nothing++-- | Get the value of an uninterpreted sort, as a String+getUninterpretedValue :: HasKind a => SBV a -> Query String+getUninterpretedValue s =+        case kindOf s of+          KUserSort _ (Left _) -> do sw <- inNewContext (`sbvToSW` s)++                                     let nm  = show sw+                                         cmd = "(get-value (" ++ nm ++ "))"+                                         bad = unexpected "getValue" cmd "a model value" Nothing++                                     r <- ask cmd++                                     parse r bad $ \case EApp [EApp [ECon o,  ECon v]] | o == show sw -> return v+                                                         _                                             -> bad r Nothing++          k                    -> error $ unlines [""+                                                  , "*** SBV.getUninterpretedValue: Called on an 'interpreted' kind"+                                                  , "*** "+                                                  , "***    Kind: " ++ show k+                                                  , "***    Hint: Use 'getValue' to extract value for interpreted kinds."+                                                  , "*** "+                                                  , "*** Only truly uninterpreted sorts should be used with 'getUninterpretedValue.'"+                                                  ]++-- | Get the value of a term, but in CW form. Used internally. The model-index, in particular is extremely Z3 specific!+getValueCWHelper :: Maybe Int -> SW -> Query CW+getValueCWHelper mbi s = do+       let nm  = show s+           k   = kindOf s++           modelIndex = case mbi of+                          Nothing -> ""+                          Just i  -> " :model_index " ++ show i++           cmd        = "(get-value (" ++ nm ++ ")" ++ modelIndex ++ ")"++           bad = unexpected "getModel" cmd ("a value binding for kind: " ++ show k) Nothing++           getUIIndex (KUserSort  _ (Right xs)) i = i `elemIndex` xs+           getUIIndex _                         _ = Nothing++       r <- ask cmd++       let isIntegral sw = isBoolean sw || isBounded sw || isInteger sw++           extract (ENum    i) | isIntegral      s = return $ mkConstCW  k (fst i)+           extract (EReal   i) | isReal          s = return $ CW KReal   (CWAlgReal i)+           extract (EFloat  i) | isFloat         s = return $ CW KFloat  (CWFloat   i)+           extract (EDouble i) | isDouble        s = return $ CW KDouble (CWDouble  i)+           extract (ECon    i) | isUninterpreted s = return $ CW k       (CWUserSort (getUIIndex k i, i))+           extract _                               = bad r Nothing++       parse r bad $ \case EApp [EApp [ECon v, val]] | v == nm -> extract val+                           _                                   -> bad r Nothing++-- | Get the value of a term. If the kind is Real and solver supports decimal approximations,+-- we will "squash" the representations.+getValueCW :: Maybe Int -> SW -> Query CW+getValueCW mbi s+  | kindOf s /= KReal+  = getValueCWHelper mbi s+  | True+  = do cfg <- getConfig+       if not (supportsApproxReals (capabilities (solver cfg)))+          then getValueCWHelper mbi s+          else do send True "(set-option :pp.decimal false)"+                  rep1 <- getValueCWHelper mbi s+                  send True   "(set-option :pp.decimal true)"+                  send True $ "(set-option :pp.decimal_precision " ++ show (printRealPrec cfg) ++ ")"+                  rep2 <- getValueCWHelper mbi s++                  let bad = unexpected "getValueCW" "get-value" ("a real-valued binding for " ++ show s) Nothing (show (rep1, rep2)) Nothing++                  case (rep1, rep2) of+                    (CW KReal (CWAlgReal a), CW KReal (CWAlgReal b)) -> return $ CW KReal (CWAlgReal (mergeAlgReals ("Cannot merge real-values for " ++ show s) a b))+                    _                                                -> bad++-- | Check for satisfiability.+checkSat :: Query CheckSatResult+checkSat = do cfg <- getConfig+              checkSatUsing $ satCmd cfg++-- | Check for satisfiability with a custom check-sat-using command.+checkSatUsing :: String -> Query CheckSatResult+checkSatUsing cmd = do let bad = unexpected "checkSat" cmd "one of sat/unsat/unknown" Nothing++                       r <- ask cmd++                       parse r bad $ \case ECon "sat"     -> return Sat+                                           ECon "unsat"   -> return Unsat+                                           ECon "unknown" -> return Unk+                                           _              -> bad r Nothing++-- | What are the top level inputs?+getQuantifiedInputs :: Query [(Quantifier, NamedSymVar)]+getQuantifiedInputs = do State{rinps} <- get+                         liftIO $ reverse <$> readIORef rinps++-- | Repeatedly issue check-sat, after refuting the previous model.+-- The bool is true if the model is unique upto prefix existentials.+getAllSatResult :: Query (Bool, Bool, [SMTResult])+getAllSatResult = do queryDebug ["*** Checking Satisfiability, all solutions.."]++                     cfg <- getConfig++                     State{rUsedKinds} <- get++                     ki    <- liftIO $ readIORef rUsedKinds+                     qinps <- getQuantifiedInputs++                     let usorts = [s | us@(KUserSort s _) <- Set.toList ki, isFree us]++                     unless (null usorts) $ queryDebug [ "*** SBV.allSat: Uninterpreted sorts present: " ++ unwords usorts+                                                       , "***             SBV will use equivalence classes to generate all-satisfying instances."+                                                       ]++                     let vars :: [(SVal, NamedSymVar)]+                         vars = let allModelInputs = takeWhile ((/= ALL) . fst) qinps++                                    sortByNodeId :: [NamedSymVar] -> [NamedSymVar]+                                    sortByNodeId = sortBy (compare `on` (\(SW _ n, _) -> n))++                                    mkSVal :: NamedSymVar -> (SVal, NamedSymVar)+                                    mkSVal nm@(sw, _) = (SVal (kindOf sw) (Right (cache (const (return sw)))), nm)++                                in map mkSVal $ sortByNodeId [nv | (_, nv@(_, n)) <- allModelInputs, not (isNonModelVar cfg n)]++                         -- If we have any universals, then the solutions are unique upto prefix existentials.+                         w = ALL `elem` map fst qinps++                     (sc, ms) <- loop vars cfg+                     return (sc, w, reverse ms)++   where isFree (KUserSort _ (Left _)) = True+         isFree _                      = False++         loop vars cfg = go (1::Int) []+            where go :: Int -> [SMTResult] -> Query (Bool, [SMTResult])+                  go !cnt sofar+                   | Just maxModels <- allSatMaxModelCount cfg, cnt > maxModels+                   = do queryDebug ["*** Maximum model count request of " ++ show maxModels ++ " reached, stopping the search."]+                        return (True, sofar)+                   | True+                   = do queryDebug ["Looking for solution " ++ show cnt]+                        cs <- checkSat+                        case cs of+                          Unsat -> return (False, sofar)+                          Unk   -> do queryDebug ["*** Solver returned unknown, terminating query."]+                                      return (False, sofar)+                          Sat   -> do assocs <- mapM (\(sval, (sw, n)) -> do cw <- getValueCW Nothing sw+                                                                             return (n, (sval, cw))) vars++                                      let m = Satisfiable cfg SMTModel { modelObjectives = []+                                                                       , modelAssocs     = [(n, cw) | (n, (_, cw)) <- assocs]+                                                                       }++                                          (interpreteds, uninterpreteds) = partition (not . isFree . kindOf . fst) (map snd assocs)++                                          -- For each "interpreted" variable, figure out the model equivalence+                                          -- NB. When the kind is floating, we *have* to be careful, since +/- zero, and NaN's+                                          -- and equality don't get along!+                                          interpretedEqs :: [SVal]+                                          interpretedEqs = [mkNotEq (kindOf sv) sv (SVal (kindOf sv) (Left cw)) | (sv, cw) <- interpreteds]+                                             where mkNotEq k a b+                                                    | isDouble k || isFloat k = svNot (a `fpNotEq` b)+                                                    | True                    = a `svNotEqual` b++                                                   fpNotEq a b = SVal KBool $ Right $ cache r+                                                       where r st = do swa <- svToSW st a+                                                                       swb <- svToSW st b+                                                                       newExpr st KBool (SBVApp (IEEEFP FP_ObjEqual) [swa, swb])++                                          -- For each "uninterpreted" variable, use equivalence class+                                          uninterpretedEqs :: [SVal]+                                          uninterpretedEqs = concatMap pwDistinct         -- Assert that they are pairwise distinct+                                                           . filter (\l -> length l > 1)  -- Only need this class if it has at least two members+                                                           . map (map fst)                -- throw away values, we only need svals+                                                           . groupBy ((==) `on` snd)      -- make sure they belong to the same sort and have the same value+                                                           . sortBy (comparing snd)       -- sort them according to their CW (i.e., sort/value)+                                                           $ uninterpreteds+                                            where pwDistinct :: [SVal] -> [SVal]+                                                  pwDistinct ss = [x `svNotEqual` y | (x:ys) <- tails ss, y <- ys]++                                          eqs = interpretedEqs ++ uninterpretedEqs+                                          disallow = case eqs of+                                                       [] -> Nothing+                                                       _  -> Just $ SBV $ foldr1 svOr eqs++                                      let resultsSoFar = m : sofar++                                      -- make sure there's some var. This happens! 'allSat true' is the pathetic example.++                                      case disallow of+                                        Nothing -> return (False, resultsSoFar)+                                        Just d  -> do constrain d+                                                      go (cnt+1) resultsSoFar++-- | Retrieve the set of unsatisfiable assumptions, following a call to 'checkSatAssumingWithUnsatisfiableSet'. Note that+-- this function isn't exported to the user, but rather used internally. The user simple calls 'checkSatAssumingWithUnsatisfiableSet'.+getUnsatAssumptions :: [String] -> [(String, a)] -> Query [a]+getUnsatAssumptions originals proxyMap = do+        let cmd = "(get-unsat-assumptions)"++            bad = unexpected "getUnsatAssumptions" cmd "a list of unsatisfiable assumptions"+                           $ Just [ "Make sure you use:"+                                  , ""+                                  , "       setOption $ ProduceUnsatAssumptions True"+                                  , ""+                                  , "to make sure the solver is ready for producing unsat assumptions,"+                                  , "and that there is a model by first issuing a 'checkSat' call."+                                  ]++            fromECon (ECon s) = Just s+            fromECon _        = Nothing++        r <- ask cmd++        -- If unsat-cores are enabled, z3 might end-up printing an assumption that wasn't+        -- in the original list of assumptions for `check-sat-assuming`. So, we walk over+        -- and ignore those that weren't in the original list, and put a warning for those+        -- we couldn't find.+        let walk []     sofar = return $ reverse sofar+            walk (a:as) sofar = case a `lookup` proxyMap of+                                  Just v  -> walk as (v:sofar)+                                  Nothing -> do queryDebug [ "*** In call to 'getUnsatAssumptions'"+                                                           , "***"+                                                           , "***    Unexpected assumption named: " ++ show a+                                                           , "***    Was expecting one of       : " ++ show originals+                                                           , "***"+                                                           , "*** This can happen if unsat-cores are also enabled. Ignoring."+                                                           ]+                                                walk as sofar++        parse r bad $ \case+           EApp es | Just xs <- mapM fromECon es -> walk xs []+           _                                     -> bad r Nothing++-- | Timeout a query action, typically a command call to the underlying SMT solver.+-- The duration is in microseconds (@1\/10^6@ seconds). If the duration+-- is negative, then no timeout is imposed. When specifying long timeouts, be careful not to exceed+-- @maxBound :: Int@. (On a 64 bit machine, this bound is practically infinite. But on a 32 bit+-- machine, it corresponds to about 36 minutes!)+--+-- Semantics: The call @timeout n q@ causes the timeout value to be applied to all interactive calls that take place+-- as we execute the query @q@. That is, each call that happens during the execution of @q@ gets a separate+-- time-out value, as opposed to one timeout value that limits the whole query. This is typically the intended behavior.+-- It is advisible to apply this combinator to calls that involve a single call to the solver for+-- finer control, as opposed to an entire set of interactions. However, different use cases might call for different scenarios.+--+-- If the solver responds within the time-out specified, then we continue as usual. However, if the backend solver times-out+-- using this mechanism, there is no telling what the state of the solver will be. Thus, we raise an error in this case.+timeout :: Int -> Query a -> Query a+timeout n q = do modifyQueryState (\qs -> qs {queryTimeOutValue = Just n})+                 r <- q+                 modifyQueryState (\qs -> qs {queryTimeOutValue = Nothing})+                 return r++-- | Bail out if a parse goes bad+parse :: String -> (String -> Maybe [String] -> a) -> (SExpr -> a) -> a+parse r fCont sCont = case parseSExpr r of+                        Left  e   -> fCont r (Just [e])+                        Right res -> sCont res++-- | Bail out if we don't get what we expected+unexpected :: String -> String -> String -> Maybe [String] -> String -> Maybe [String] -> Query a+unexpected ctx sent expected mbHint received mbReason = do+        -- empty the response channel first+        extras <- retrieveResponse "terminating upon unexpected response" (Just 5000000)++        error $ unlines $ [ ""+                          , "*** Data.SBV: Unexpected response from the solver."+                          , "***    Context : " `alignDiagnostic` ctx+                          , "***    Sent    : " `alignDiagnostic` sent+                          , "***    Expected: " `alignDiagnostic` expected+                          , "***    Received: " `alignDiagnostic` unlines (received : extras)+                          ]+                       ++ [ "***    Reason  : " `alignDiagnostic` unlines r | Just r <- [mbReason]]+                       ++ [ "***    Hint    : " `alignDiagnostic` unlines r | Just r <- [mbHint]]++-- | Convert a query result to an SMT Problem+runProofOn :: SMTConfig -> Bool -> [String] -> Result -> SMTProblem+runProofOn config isSat comments res@(Result ki _qcInfo _codeSegs is consts tbls arrs uis axs pgm cstrs _assertions outputs) =+     let flipQ (ALL, x) = (EX,  x)+         flipQ (EX,  x) = (ALL, x)++         skolemize :: [(Quantifier, NamedSymVar)] -> [Either SW (SW, [SW])]+         skolemize quants = go quants ([], [])+           where go []                   (_,  sofar) = reverse sofar+                 go ((ALL, (v, _)):rest) (us, sofar) = go rest (v:us, Left v : sofar)+                 go ((EX,  (v, _)):rest) (us, sofar) = go rest (us,   Right (v, reverse us) : sofar)++         qinps      = if isSat then is else map flipQ is+         skolemMap  = skolemize qinps++         o = case outputs of+               []  -> trueSW+               [so] -> case so of+                        SW KBool _ -> so+                        _          -> trueSW+                                      {-+                                      -- TODO: We used to error out here, but "safeWith" might have a non-bool out+                                      -- I wish we can get rid of this and still check for it. Perhaps this entire+                                      -- runProofOn might disappear.+                                      error $ unlines [ "Impossible happened, non-boolean output: " ++ show so+                                                      , "Detected while generating the trace:\n" ++ show res+                                                      ]+                                      -}+               os  -> error $ unlines [ "User error: Multiple output values detected: " ++ show os+                                      , "Detected while generating the trace:\n" ++ show res+                                      , "*** Check calls to \"output\", they are typically not needed!"+                                      ]++     in SMTProblem { smtLibPgm = toSMTLib config ki isSat comments is skolemMap consts tbls arrs uis axs pgm cstrs o }++{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
Data/SBV/Core/Concrete.hs view
@@ -87,7 +87,7 @@ data ExtCW = Infinite  Kind         -- infinity            | Epsilon   Kind         -- epsilon            | Interval  ExtCW ExtCW  -- closed interval-           | BoundedCW CW           -- a bounded value (i.e., neither infinity, nor epsilon)+           | BoundedCW CW           -- a bounded value (i.e., neither infinity, nor epsilon). Note that this cannot appear at top, but can appear as a sub-expr.            | AddExtCW  ExtCW ExtCW  -- addition            | MulExtCW  ExtCW ExtCW  -- multiplication @@ -254,12 +254,12 @@ randomCWVal :: Kind -> IO CWVal randomCWVal k =   case k of-    KBool         -> fmap CWInteger (randomRIO (0,1))-    KBounded s w  -> fmap CWInteger (randomRIO (bounds s w))-    KUnbounded    -> fmap CWInteger randomIO-    KReal         -> fmap CWAlgReal randomIO-    KFloat        -> fmap CWFloat randomIO-    KDouble       -> fmap CWDouble randomIO+    KBool         -> CWInteger <$> randomRIO (0, 1)+    KBounded s w  -> CWInteger <$> randomRIO (bounds s w)+    KUnbounded    -> CWInteger <$> randomIO+    KReal         -> CWAlgReal <$> randomIO+    KFloat        -> CWFloat   <$> randomIO+    KDouble       -> CWDouble  <$> randomIO     KUserSort s _ -> error $ "Unexpected call to randomCWVal with uninterpreted kind: " ++ s   where     bounds :: Bool -> Int -> (Integer, Integer)@@ -268,4 +268,4 @@  -- | Generate a random constant value ('CW') of the correct kind. randomCW :: Kind -> IO CW-randomCW k = fmap (CW k) (randomCWVal k)+randomCW k = CW k <$> randomCWVal k
Data/SBV/Core/Data.hs view
@@ -18,6 +18,8 @@ {-# LANGUAGE PatternGuards         #-} {-# LANGUAGE DefaultSignatures     #-} {-# LANGUAGE NamedFieldPuns        #-}+{-# LANGUAGE DeriveAnyClass        #-}+{-# LANGUAGE DeriveGeneric         #-}  module Data.SBV.Core.Data  ( SBool, SWord8, SWord16, SWord32, SWord64@@ -36,50 +38,45 @@  , SBVExpr(..), newExpr  , cache, Cached, uncache, uncacheAI, HasKind(..)  , Op(..), PBOp(..), FPOp(..), NamedSymVar, getTableIndex- , SBVPgm(..), Symbolic, SExecutable(..), runSymbolic, runSymbolic', State, getPathCondition, extendPathCondition- , inProofMode, SBVRunMode(..), Kind(..), Outputtable(..), Result(..)- , Logic(..), SMTLibLogic(..)- , addConstraint, internalVariable, internalConstraint, isCodeGenMode+ , SBVPgm(..), Symbolic, runSymbolic, State, getPathCondition, extendPathCondition+ , inSMTMode, SBVRunMode(..), Kind(..), Outputtable(..), Result(..)+ , SolverContext(..), internalVariable, internalConstraint, isCodeGenMode  , SBVType(..), newUninterpreted, addAxiom  , Quantifier(..), needsExistentials  , SMTLibPgm(..), SMTLibVersion(..), smtLibVersionExtension, smtLibReservedNames  , SolverCapabilities(..)  , extractSymbolicSimulationState- , SMTScript(..), Solver(..), SMTSolver(..), SMTResult(..), SMTModel(..), SMTConfig(..), getSBranchRunConfig+ , SMTScript(..), Solver(..), SMTSolver(..), SMTResult(..), SMTModel(..), SMTConfig(..)  , declNewSArray, declNewSFunArray  , OptimizeStyle(..), Penalty(..), Objective(..)- , Tactic(..), CaseCond(..), SMTProblem(..), isParallelCaseAnywhere+ , QueryState(..), Query(..), SMTProblem(..)  ) where +import GHC.Generics (Generic)+ import Control.DeepSeq      (NFData(..)) import Control.Monad.Reader (ask) import Control.Monad.Trans  (liftIO) import Data.Int             (Int8, Int16, Int32, Int64) import Data.Word            (Word8, Word16, Word32, Word64)-import Data.List            (elemIndex, intercalate)-import Data.Maybe           (fromMaybe)+import Data.List            (elemIndex) -import qualified Data.Set as Set (Set) import qualified Data.Generics as G    (Data(..)) -import GHC.Stack.Compat-#if !MIN_VERSION_base(4,9,0)-import GHC.SrcLoc.Compat-#endif- import System.Random  import Data.SBV.Core.AlgReals import Data.SBV.Core.Kind import Data.SBV.Core.Concrete import Data.SBV.Core.Symbolic+import Data.SBV.Core.Operations +import Data.SBV.Control.Types+ import Data.SBV.SMT.SMTLibNames  import Data.SBV.Utils.Lib--import Prelude ()-import Prelude.Compat+import Data.SBV.Utils.Boolean  -- | Get the current path condition getPathCondition :: State -> SBool@@ -92,6 +89,7 @@ -- | The "Symbolic" value. The parameter 'a' is phantom, but is -- extremely important in keeping the user interface strongly typed. newtype SBV a = SBV { unSBV :: SVal }+              deriving (Generic, NFData)  -- | A symbolic boolean/bit type SBool   = SBV Bool@@ -152,6 +150,15 @@ sInfinity :: (Floating a, SymWord a) => SBV a sInfinity = literal infinity +-- Boolean combinators+instance Boolean SBool where+  true  = SBV (svBool True)+  false = SBV (svBool False)+  bnot (SBV b) = SBV (svNot b)+  SBV a &&& SBV b = SBV (svAnd a b)+  SBV a ||| SBV b = SBV (svOr a b)+  SBV a <+> SBV b = SBV (svXOr a b)+ -- | 'RoundingMode' can be used symbolically instance SymWord RoundingMode @@ -198,12 +205,15 @@ sRTZ :: SRoundingMode sRTZ = sRoundTowardZero --- Not particularly "desirable", but will do if needed+-- Not particularly "desirable," when the value is symbolic, but we do need this+-- instance as otherwise we cannot simply evaluate Haskell functions that return+-- symbolic values and have their constant values printed easily! instance Show (SBV a) where   show (SBV sv) = show sv  -- Equality constraint on SBV values. Not desirable since we can't really compare two--- symbolic values, but will do.+-- symbolic values, but will do. Note that we do need this instance since we want+-- Bits as a class for SBV that we implement, which necessiates the Eq class. instance Eq (SBV a) where   SBV a == SBV b = a == b   SBV a /= SBV b = a /= b@@ -221,7 +231,7 @@  -- | Create a symbolic variable. mkSymSBV :: forall a. Maybe Quantifier -> Kind -> Maybe String -> Symbolic (SBV a)-mkSymSBV mbQ k mbNm = fmap SBV (svMkSymVar mbQ k mbNm)+mkSymSBV mbQ k mbNm = SBV <$> (ask >>= liftIO . svMkSymVar mbQ k mbNm)  -- | Convert a symbolic value to an SW, inside the Symbolic monad sbvToSymSW :: SBV a -> Symbolic SW@@ -229,6 +239,33 @@         st <- ask         liftIO $ sbvToSW st sbv +-- | Actions we can do in a context: Either at problem description+-- time or while we are dynamically querying. 'Symbolic' and 'Query' are+-- two instances of this class. Note that we use this mechanism+-- internally and do not export it from SBV.+class SolverContext m where+   -- | Add a constraint, any satisfying instance must satisfy this condition+   constrain       :: SBool -> m ()+   -- | Add a named constraint. The name is used in unsat-core extraction.+   namedConstraint :: String -> SBool -> m ()+   -- | Set info. Example: @setInfo ":status" ["unsat"]@.+   setInfo :: String -> [String] -> m ()+   -- | Set an option.+   setOption :: SMTOption -> m ()+   -- | Set the logic.+   setLogic :: Logic -> 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+   -- is in milliseconds. Also see the function 'timeOut' for finer level+   -- control of time-outs, directly from SBV.+   setTimeOut :: Integer -> m ()++   -- time-out, logic, and info are  simply options in our implementation, so default implementation suffices+   setTimeOut t = setOption $ OptionKeyword ":timeout" [show t]+   setLogic     = setOption . SetLogic+   setInfo    k = setOption . SetInfo k+ -- | A class representing what can be returned from a symbolic computation. class Outputtable a where   -- | Mark an interim result as an output. Useful when constructing Symbolic programs@@ -348,7 +385,7 @@   fromCW cw                         = error $ "Cannot convert CW " ++ show cw ++ " to kind " ++ show (kindOf (undefined :: a))    default mkSymWord :: (Read a, G.Data a) => Maybe Quantifier -> Maybe String -> Symbolic (SBV a)-  mkSymWord mbQ mbNm = SBV <$> mkSValUserSort k mbQ mbNm+  mkSymWord mbQ mbNm = SBV <$> (ask >>= liftIO . svMkSymVar mbQ k mbNm)     where k = constructUKind (undefined :: a)  instance (Random a, SymWord a) => Random (SBV a) where@@ -361,10 +398,7 @@ ---------------------------------------------------------------------------------  -- | Flat arrays of symbolic values--- An @array a b@ is an array indexed by the type @'SBV' a@, with elements of type @'SBV' b@--- If an initial value is not provided in 'newArray_' and 'newArray' methods, then the elements--- are left unspecified, i.e., the solver is free to choose any value. This is the right thing--- to do if arrays are used as inputs to functions to be verified, typically. +-- An @array a b@ is an array indexed by the type @'SBV' a@, with elements of type @'SBV' b@. -- -- While it's certainly possible for user to create instances of 'SymArray', the -- 'SArray' and 'SFunArray' instances already provided should cover most use cases@@ -374,14 +408,12 @@ -- -- Minimal complete definition: All methods are required, no defaults. class SymArray array where-  -- | Create a new array, with an optional initial value-  newArray_      :: (HasKind a, HasKind b) => Maybe (SBV b) -> Symbolic (array a b)-  -- | Create a named new array, with an optional initial value-  newArray       :: (HasKind a, HasKind b) => String -> Maybe (SBV b) -> Symbolic (array a b)+  -- | Create a new anonymous array+  newArray_      :: (HasKind a, HasKind b) => Symbolic (array a b)+  -- | Create a named new array+  newArray       :: (HasKind a, HasKind b) => String -> Symbolic (array a b)   -- | Read the array element at @a@   readArray      :: array a b -> SBV a -> SBV b-  -- | Reset all the elements of the array to the value @b@-  resetArray     :: SymWord b => array a b -> SBV b -> array a b   -- | Update the element at @a@ to be @b@   writeArray     :: SymWord b => array a b -> SBV a -> SBV b -> array a b   -- | Merge two given arrays on the symbolic condition@@ -410,21 +442,22 @@   newArray_                                      = declNewSArray (\t -> "array_" ++ show t)   newArray n                                     = declNewSArray (const n)   readArray   (SArray arr) (SBV a)               = SBV (readSArr arr a)-  resetArray  (SArray arr) (SBV b)               = SArray (resetSArr arr b)   writeArray  (SArray arr) (SBV a)    (SBV b)    = SArray (writeSArr arr a b)   mergeArrays (SBV t)      (SArray a) (SArray b) = SArray (mergeSArr t a b)  -- | Declare a new symbolic array, with a potential initial value-declNewSArray :: forall a b. (HasKind a, HasKind b) => (Int -> String) -> Maybe (SBV b) -> Symbolic (SArray a b)-declNewSArray mkNm mbInit = do+declNewSArray :: forall a b. (HasKind a, HasKind b) => (Int -> String) -> Symbolic (SArray a b)+declNewSArray mkNm = do    let aknd = kindOf (undefined :: a)        bknd = kindOf (undefined :: b)-   arr <- newSArr (aknd, bknd) mkNm (fmap unSBV mbInit)+   arr <- newSArr (aknd, bknd) mkNm    return (SArray arr) --- | Declare a new functional symbolic array, with a potential initial value. Note that a read from an uninitialized cell will result in an error.-declNewSFunArray :: forall a b. (HasKind a, HasKind b) => Maybe (SBV b) -> Symbolic (SFunArray a b)-declNewSFunArray mbiVal = return $ SFunArray $ const $ fromMaybe (error "Reading from an uninitialized array entry") mbiVal+-- | Declare a new functional symbolic array. Note that a read from an uninitialized cell will result in an error.+declNewSFunArray :: forall a b. (HasKind a, HasKind b) => Maybe String -> Symbolic (SFunArray a b)+declNewSFunArray mbNm = return $ SFunArray $ error . msg mbNm+  where msg Nothing   i = "Reading from an uninitialized array entry, index: " ++ show i+        msg (Just nm) i = "Array " ++ show nm ++ ": Reading from an uninitialized array entry, index: " ++ show i  -- | Arrays implemented internally as functions --@@ -447,135 +480,5 @@ mkSFunArray :: (SBV a -> SBV b) -> SFunArray a b mkSFunArray = SFunArray --- | Add a constraint with a given probability.-addConstraint :: Maybe String -> Maybe Double -> SBool -> SBool -> Symbolic ()-addConstraint mn mt (SBV c) (SBV c') = addSValConstraint mn mt c c'---- | A case condition (internal)-data CaseCond = NoCase                         -- ^ No case-split-              | CasePath [SW]                  -- ^ In a case-path-              | CaseVac  [SW] SW               -- ^ For checking the vacuity of a case-              | CaseCov  [SW] [SW]             -- ^ In a case-path end, coverage (first arg is path cond, second arg is coverage cond)-              | CstrVac                        -- ^ In a constraint vacuity check (top-level)-              | Opt      [Objective (SW, SW)]  -- ^ In an optimization call--instance NFData CaseCond where-  rnf NoCase           = ()-  rnf (CasePath ps)    = rnf ps-  rnf (CaseVac  ps q)  = rnf ps `seq` rnf q  `seq` ()-  rnf (CaseCov  ps qs) = rnf ps `seq` rnf qs `seq` ()-  rnf CstrVac          = ()-  rnf (Opt os)         = rnf os `seq` ()- -- | Internal representation of a symbolic simulation result-data SMTProblem = SMTProblem { smtInputs    :: [(Quantifier, NamedSymVar)]        -- ^ inputs-                             , smtSkolemMap :: [Either SW (SW, [SW])]             -- ^ skolem-map-                             , kindsUsed    :: Set.Set Kind                       -- ^ kinds used-                             , smtAsserts   :: [(String, Maybe CallStack, SW)]    -- ^ assertions-                             , tactics      :: [Tactic SW]                        -- ^ tactics to use-                             , objectives   :: [Objective (SW, SW)]               -- ^ optimization goals, if any-                             , smtLibPgm    :: SMTConfig -> CaseCond -> SMTLibPgm -- ^ SMTLib representation, given the config and case-splits-                             }--instance NFData SMTProblem where-  rnf (SMTProblem i m k a t o p) = rnf i `seq` rnf m `seq` rnf k `seq` rnf a `seq` rnf t `seq` rnf o `seq` rnf p `seq` ()--instance NFData (SBV a) where-  rnf (SBV x) = rnf x `seq` ()---- | Symbolically executable program fragments. This class is mainly used for 'safe' calls, and is sufficently populated internally to cover most use--- cases. Users can extend it as they wish to allow 'safe' checks for SBV programs that return/take types that are user-defined.-class SExecutable a where-   sName_ :: a -> Symbolic ()-   sName  :: [String] -> a -> Symbolic ()--instance NFData a => SExecutable (Symbolic a) where-   sName_   a = a >>= \r -> rnf r `seq` return ()-   sName []   = sName_-   sName xs   = error $ "SBV.SExecutable.sName: Extra unmapped name(s): " ++ intercalate ", " xs--instance SExecutable (SBV a) where-   sName_   v = sName_ (output v)-   sName xs v = sName xs (output v)---- Unit output-instance SExecutable () where-   sName_   () = sName_   (output ())-   sName xs () = sName xs (output ())---- List output-instance SExecutable [SBV a] where-   sName_   vs = sName_   (output vs)-   sName xs vs = sName xs (output vs)---- 2 Tuple output-instance (NFData a, SymWord a, NFData b, SymWord b) => SExecutable (SBV a, SBV b) where-  sName_ (a, b) = sName_ (output a >> output b)-  sName _       = sName_---- 3 Tuple output-instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c) => SExecutable (SBV a, SBV b, SBV c) where-  sName_ (a, b, c) = sName_ (output a >> output b >> output c)-  sName _          = sName_---- 4 Tuple output-instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d) => SExecutable (SBV a, SBV b, SBV c, SBV d) where-  sName_ (a, b, c, d) = sName_ (output a >> output b >> output c >> output c >> output d)-  sName _             = sName_---- 5 Tuple output-instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d, NFData e, SymWord e) => SExecutable (SBV a, SBV b, SBV c, SBV d, SBV e) where-  sName_ (a, b, c, d, e) = sName_ (output a >> output b >> output c >> output d >> output e)-  sName _                = sName_---- 6 Tuple output-instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d, NFData e, SymWord e, NFData f, SymWord f) => SExecutable (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) where-  sName_ (a, b, c, d, e, f) = sName_ (output a >> output b >> output c >> output d >> output e >> output f)-  sName _                   = sName_---- 7 Tuple output-instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d, NFData e, SymWord e, NFData f, SymWord f, NFData g, SymWord g) => SExecutable (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) where-  sName_ (a, b, c, d, e, f, g) = sName_ (output a >> output b >> output c >> output d >> output e >> output f >> output g)-  sName _                      = sName_---- Functions-instance (SymWord a, SExecutable p) => SExecutable (SBV a -> p) where-   sName_        k = forall_   >>= \a -> sName_   $ k a-   sName (s:ss)  k = forall s  >>= \a -> sName ss $ k a-   sName []      k = sName_ k---- 2 Tuple input-instance (SymWord a, SymWord b, SExecutable p) => SExecutable ((SBV a, SBV b) -> p) where-  sName_        k = forall_  >>= \a -> sName_   $ \b -> k (a, b)-  sName (s:ss)  k = forall s >>= \a -> sName ss $ \b -> k (a, b)-  sName []      k = sName_ k---- 3 Tuple input-instance (SymWord a, SymWord b, SymWord c, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c) -> p) where-  sName_       k  = forall_  >>= \a -> sName_   $ \b c -> k (a, b, c)-  sName (s:ss) k  = forall s >>= \a -> sName ss $ \b c -> k (a, b, c)-  sName []     k  = sName_ k---- 4 Tuple input-instance (SymWord a, SymWord b, SymWord c, SymWord d, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d) -> p) where-  sName_        k = forall_  >>= \a -> sName_   $ \b c d -> k (a, b, c, d)-  sName (s:ss)  k = forall s >>= \a -> sName ss $ \b c d -> k (a, b, c, d)-  sName []      k = sName_ k---- 5 Tuple input-instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) where-  sName_        k = forall_  >>= \a -> sName_   $ \b c d e -> k (a, b, c, d, e)-  sName (s:ss)  k = forall s >>= \a -> sName ss $ \b c d e -> k (a, b, c, d, e)-  sName []      k = sName_ k---- 6 Tuple input-instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) where-  sName_        k = forall_  >>= \a -> sName_   $ \b c d e f -> k (a, b, c, d, e, f)-  sName (s:ss)  k = forall s >>= \a -> sName ss $ \b c d e f -> k (a, b, c, d, e, f)-  sName []      k = sName_ k---- 7 Tuple input-instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SymWord g, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) where-  sName_        k = forall_  >>= \a -> sName_   $ \b c d e f g -> k (a, b, c, d, e, f, g)-  sName (s:ss)  k = forall s >>= \a -> sName ss $ \b c d e f g -> k (a, b, c, d, e, f, g)-  sName []      k = sName_ k+newtype SMTProblem = SMTProblem {smtLibPgm :: SMTConfig -> SMTLibPgm} -- ^ SMTLib representation, given the config
Data/SBV/Core/Floating.hs view
@@ -385,14 +385,14 @@   | True   = SBV (SVal w32 (Right (cache y)))   where w32  = KBounded False 32-        y st | isCodeGenMode st-             = do f <- sbvToSW st fVal-                  newExpr st w32 (SBVApp (IEEEFP (FP_Reinterpret KFloat w32)) [f])-             | True-             = do n   <- internalVariable st w32-                  ysw <- newExpr st KFloat (SBVApp (IEEEFP (FP_Reinterpret w32 KFloat)) [n])-                  internalConstraint st Nothing $ unSBV $ fVal `fpIsEqualObject` SBV (SVal KFloat (Right (cache (\_ -> return ysw))))-                  return n+        y st = do cg <- isCodeGenMode st+                  if cg+                     then do f <- sbvToSW st fVal+                             newExpr st w32 (SBVApp (IEEEFP (FP_Reinterpret KFloat w32)) [f])+                     else do n   <- internalVariable st w32+                             ysw <- newExpr st KFloat (SBVApp (IEEEFP (FP_Reinterpret w32 KFloat)) [n])+                             internalConstraint st Nothing $ unSBV $ fVal `fpIsEqualObject` SBV (SVal KFloat (Right (cache (\_ -> return ysw))))+                             return n  -- | Convert an 'SDouble' to an 'SWord64', preserving the bit-correspondence. Note that since the -- representation for @NaN@s are not unique, this function will return a symbolic value when given a@@ -406,14 +406,14 @@   | True   = SBV (SVal w64 (Right (cache y)))   where w64  = KBounded False 64-        y st | isCodeGenMode st-             = do f <- sbvToSW st fVal-                  newExpr st w64 (SBVApp (IEEEFP (FP_Reinterpret KDouble w64)) [f])-             | True-             = do n   <- internalVariable st w64-                  ysw <- newExpr st KDouble (SBVApp (IEEEFP (FP_Reinterpret w64 KDouble)) [n])-                  internalConstraint st Nothing $ unSBV $ fVal `fpIsEqualObject` SBV (SVal KDouble (Right (cache (\_ -> return ysw))))-                  return n+        y st = do cg <- isCodeGenMode st+                  if cg+                     then do f <- sbvToSW st fVal+                             newExpr st w64 (SBVApp (IEEEFP (FP_Reinterpret KDouble w64)) [f])+                     else do n   <- internalVariable st w64+                             ysw <- newExpr st KDouble (SBVApp (IEEEFP (FP_Reinterpret w64 KDouble)) [n])+                             internalConstraint st Nothing $ unSBV $ fVal `fpIsEqualObject` SBV (SVal KDouble (Right (cache (\_ -> return ysw))))+                             return n  -- | Extract the sign\/exponent\/mantissa of a single-precision float. The output will have -- 8 bits in the second argument for exponent, and 23 in the third for the mantissa.
Data/SBV/Core/Kind.hs view
@@ -26,7 +26,7 @@           | KBounded !Bool !Int           | KUnbounded           | KReal-          | KUserSort String (Either String [String])+          | KUserSort String (Either String [String])  -- name. Left: uninterpreted. Right: enum constructors.           | KFloat           | KDouble
Data/SBV/Core/Model.hs view
@@ -28,26 +28,24 @@   , oneIf, blastBE, blastLE, fullAdder, fullMultiplier   , lsb, msb, genVar, genVar_, forall, forall_, exists, exists_   , pbAtMost, pbAtLeast, pbExactly, pbLe, pbGe, pbEq, pbMutexed, pbStronglyMutexed-  , constrain, namedConstraint, pConstrain, tactic, sBool, sBools, sWord8, sWord8s, sWord16, sWord16s, sWord32+  , sBool, sBools, sWord8, sWord8s, sWord16, sWord16s, sWord32   , sWord32s, sWord64, sWord64s, sInt8, sInt8s, sInt16, sInt16s, sInt32, sInt32s, sInt64   , sInt64s, sInteger, sIntegers, sReal, sReals, sFloat, sFloats, sDouble, sDoubles, slet   , sRealToSInteger, label   , sAssert   , liftQRem, liftDMod, symbolicMergeWithKind   , genLiteral, genFromCW, genMkSymVar-  , isSatisfiableInCurrentPath   , sbvQuickCheck   )   where  import Control.Monad        (when, unless, mplus)-import Control.Monad.Reader (ask)-import Control.Monad.Trans  (liftIO)  import GHC.Generics (U1(..), M1(..), (:*:)(..), K1(..)) import qualified GHC.Generics as G-import GHC.Stack.Compat +import GHC.Stack+ import Data.Array      (Array, Ix, listArray, elems, bounds, rangeSize) import Data.Bits       (Bits(..)) import Data.Int        (Int8, Int16, Int32, Int64)@@ -59,15 +57,14 @@ import qualified Test.QuickCheck.Test    as QC (isSuccess) import qualified Test.QuickCheck         as QC (quickCheckResult, counterexample) import qualified Test.QuickCheck.Monadic as QC (monadicIO, run, assert, pre, monitor)-import System.Random  import Data.SBV.Core.AlgReals import Data.SBV.Core.Data import Data.SBV.Core.Symbolic import Data.SBV.Core.Operations -import Data.SBV.Provers.Prover (isVacuous, prove, defaultSMTCfg, internalSATCheck)-import Data.SBV.SMT.SMT        (ThmResult, SatResult(..), showModel)+import Data.SBV.Provers.Prover (defaultSMTCfg)+import Data.SBV.SMT.SMT        (showModel)  import Data.SBV.Utils.Boolean @@ -427,7 +424,6 @@           isConc (SBV (SVal _ (Left _))) = True           isConc _                       = False - instance SymWord a => OrdSymbolic (SBV a) where   SBV x .<  SBV y = SBV (svLessThan x y)   SBV x .<= SBV y = SBV (svLessEq x y)@@ -543,15 +539,6 @@ instance SIntegral Int64 instance SIntegral Integer --- Boolean combinators-instance Boolean SBool where-  true  = literal True-  false = literal False-  bnot (SBV b) = SBV (svNot b)-  SBV a &&& SBV b = SBV (svAnd a b)-  SBV a ||| SBV b = SBV (svOr a b)-  SBV a <+> SBV b = SBV (svXOr a b)- -- | Returns 1 if the boolean is true, otherwise 0. oneIf :: (Num a, SymWord a) => SBool -> SBV a oneIf t = ite t 1 0@@ -1478,10 +1465,9 @@ -- force equality can be defined, any non-toy instance -- will suffer from efficiency issues; so we don't define it instance SymArray SFunArray where-  newArray _                                  = newArray_ -- the name is irrelevant in this case-  newArray_     mbiVal                        = declNewSFunArray mbiVal+  newArray nm                                 = declNewSFunArray (Just nm)+  newArray_                                   = declNewSFunArray Nothing   readArray     (SFunArray f)                 = f-  resetArray    (SFunArray _) a               = SFunArray $ const a   writeArray    (SFunArray f) a b             = SFunArray (\a' -> ite (a .== a') b (f a'))   mergeArrays t (SFunArray g)   (SFunArray h) = SFunArray (\x -> ite t (g x) (h x)) @@ -1524,9 +1510,11 @@      | Just (_, v) <- mbCgData = v      | True                    = SBV $ SVal ka $ Right $ cache result     where ka = kindOf (undefined :: a)-          result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st v-                    | True = do newUninterpreted st nm (SBVType [ka]) (fst `fmap` mbCgData)-                                newExpr st ka $ SBVApp (Uninterpreted nm) []+          result st = do isSMT <- inSMTMode st+                         case (isSMT, mbCgData) of+                           (True, Just (_, v)) -> sbvToSW st v+                           _                   -> do newUninterpreted st nm (SBVType [ka]) (fst `fmap` mbCgData)+                                                     newExpr st ka $ SBVApp (Uninterpreted nm) []  -- Functions of one argument instance (SymWord b, HasKind a) => Uninterpreted (SBV b -> SBV a) where@@ -1538,11 +1526,13 @@            = SBV $ SVal ka $ Right $ cache result            where ka = kindOf (undefined :: a)                  kb = kindOf (undefined :: b)-                 result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0)-                           | True = do newUninterpreted st nm (SBVType [kb, ka]) (fst `fmap` mbCgData)-                                       sw0 <- sbvToSW st arg0-                                       mapM_ forceSWArg [sw0]-                                       newExpr st ka $ SBVApp (Uninterpreted nm) [sw0]+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, mbCgData) of+                                  (True, Just (_, v)) -> sbvToSW st (v arg0)+                                  _                   -> do newUninterpreted st nm (SBVType [kb, ka]) (fst `fmap` mbCgData)+                                                            sw0 <- sbvToSW st arg0+                                                            mapM_ forceSWArg [sw0]+                                                            newExpr st ka $ SBVApp (Uninterpreted nm) [sw0]  -- Functions of two arguments instance (SymWord c, SymWord b, HasKind a) => Uninterpreted (SBV c -> SBV b -> SBV a) where@@ -1555,12 +1545,14 @@            where ka = kindOf (undefined :: a)                  kb = kindOf (undefined :: b)                  kc = kindOf (undefined :: c)-                 result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1)-                           | True = do newUninterpreted st nm (SBVType [kc, kb, ka]) (fst `fmap` mbCgData)-                                       sw0 <- sbvToSW st arg0-                                       sw1 <- sbvToSW st arg1-                                       mapM_ forceSWArg [sw0, sw1]-                                       newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1]+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, mbCgData) of+                                  (True, Just (_, v)) -> sbvToSW st (v arg0 arg1)+                                  _                   -> do newUninterpreted st nm (SBVType [kc, kb, ka]) (fst `fmap` mbCgData)+                                                            sw0 <- sbvToSW st arg0+                                                            sw1 <- sbvToSW st arg1+                                                            mapM_ forceSWArg [sw0, sw1]+                                                            newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1]  -- Functions of three arguments instance (SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted (SBV d -> SBV c -> SBV b -> SBV a) where@@ -1574,13 +1566,15 @@                  kb = kindOf (undefined :: b)                  kc = kindOf (undefined :: c)                  kd = kindOf (undefined :: d)-                 result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1 arg2)-                           | True = do newUninterpreted st nm (SBVType [kd, kc, kb, ka]) (fst `fmap` mbCgData)-                                       sw0 <- sbvToSW st arg0-                                       sw1 <- sbvToSW st arg1-                                       sw2 <- sbvToSW st arg2-                                       mapM_ forceSWArg [sw0, sw1, sw2]-                                       newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2]+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, mbCgData) of+                                  (True, Just (_, v)) -> sbvToSW st (v arg0 arg1 arg2)+                                  _                   -> do newUninterpreted st nm (SBVType [kd, kc, kb, ka]) (fst `fmap` mbCgData)+                                                            sw0 <- sbvToSW st arg0+                                                            sw1 <- sbvToSW st arg1+                                                            sw2 <- sbvToSW st arg2+                                                            mapM_ forceSWArg [sw0, sw1, sw2]+                                                            newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2]  -- Functions of four arguments instance (SymWord e, SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where@@ -1595,14 +1589,16 @@                  kc = kindOf (undefined :: c)                  kd = kindOf (undefined :: d)                  ke = kindOf (undefined :: e)-                 result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1 arg2 arg3)-                           | True = do newUninterpreted st nm (SBVType [ke, kd, kc, kb, ka]) (fst `fmap` mbCgData)-                                       sw0 <- sbvToSW st arg0-                                       sw1 <- sbvToSW st arg1-                                       sw2 <- sbvToSW st arg2-                                       sw3 <- sbvToSW st arg3-                                       mapM_ forceSWArg [sw0, sw1, sw2, sw3]-                                       newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3]+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, mbCgData) of+                                  (True, Just (_, v)) -> sbvToSW st (v arg0 arg1 arg2 arg3)+                                  _                   -> do newUninterpreted st nm (SBVType [ke, kd, kc, kb, ka]) (fst `fmap` mbCgData)+                                                            sw0 <- sbvToSW st arg0+                                                            sw1 <- sbvToSW st arg1+                                                            sw2 <- sbvToSW st arg2+                                                            sw3 <- sbvToSW st arg3+                                                            mapM_ forceSWArg [sw0, sw1, sw2, sw3]+                                                            newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3]  -- Functions of five arguments instance (SymWord f, SymWord e, SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where@@ -1618,15 +1614,17 @@                  kd = kindOf (undefined :: d)                  ke = kindOf (undefined :: e)                  kf = kindOf (undefined :: f)-                 result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1 arg2 arg3 arg4)-                           | True = do newUninterpreted st nm (SBVType [kf, ke, kd, kc, kb, ka]) (fst `fmap` mbCgData)-                                       sw0 <- sbvToSW st arg0-                                       sw1 <- sbvToSW st arg1-                                       sw2 <- sbvToSW st arg2-                                       sw3 <- sbvToSW st arg3-                                       sw4 <- sbvToSW st arg4-                                       mapM_ forceSWArg [sw0, sw1, sw2, sw3, sw4]-                                       newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4]+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, mbCgData) of+                                  (True, Just (_, v)) -> sbvToSW st (v arg0 arg1 arg2 arg3 arg4)+                                  _                   -> do newUninterpreted st nm (SBVType [kf, ke, kd, kc, kb, ka]) (fst `fmap` mbCgData)+                                                            sw0 <- sbvToSW st arg0+                                                            sw1 <- sbvToSW st arg1+                                                            sw2 <- sbvToSW st arg2+                                                            sw3 <- sbvToSW st arg3+                                                            sw4 <- sbvToSW st arg4+                                                            mapM_ forceSWArg [sw0, sw1, sw2, sw3, sw4]+                                                            newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4]  -- Functions of six arguments instance (SymWord g, SymWord f, SymWord e, SymWord d, SymWord c, SymWord b, HasKind a) => Uninterpreted (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where@@ -1643,16 +1641,18 @@                  ke = kindOf (undefined :: e)                  kf = kindOf (undefined :: f)                  kg = kindOf (undefined :: g)-                 result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1 arg2 arg3 arg4 arg5)-                           | True = do newUninterpreted st nm (SBVType [kg, kf, ke, kd, kc, kb, ka]) (fst `fmap` mbCgData)-                                       sw0 <- sbvToSW st arg0-                                       sw1 <- sbvToSW st arg1-                                       sw2 <- sbvToSW st arg2-                                       sw3 <- sbvToSW st arg3-                                       sw4 <- sbvToSW st arg4-                                       sw5 <- sbvToSW st arg5-                                       mapM_ forceSWArg [sw0, sw1, sw2, sw3, sw4, sw5]-                                       newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5]+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, mbCgData) of+                                  (True, Just (_, v)) -> sbvToSW st (v arg0 arg1 arg2 arg3 arg4 arg5)+                                  _                   -> do newUninterpreted st nm (SBVType [kg, kf, ke, kd, kc, kb, ka]) (fst `fmap` mbCgData)+                                                            sw0 <- sbvToSW st arg0+                                                            sw1 <- sbvToSW st arg1+                                                            sw2 <- sbvToSW st arg2+                                                            sw3 <- sbvToSW st arg3+                                                            sw4 <- sbvToSW st arg4+                                                            sw5 <- sbvToSW st arg5+                                                            mapM_ forceSWArg [sw0, sw1, sw2, sw3, sw4, sw5]+                                                            newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5]  -- Functions of seven arguments instance (SymWord h, SymWord g, SymWord f, SymWord e, SymWord d, SymWord c, SymWord b, HasKind a)@@ -1671,17 +1671,19 @@                  kf = kindOf (undefined :: f)                  kg = kindOf (undefined :: g)                  kh = kindOf (undefined :: h)-                 result st | Just (_, v) <- mbCgData, inProofMode st = sbvToSW st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6)-                           | True = do newUninterpreted st nm (SBVType [kh, kg, kf, ke, kd, kc, kb, ka]) (fst `fmap` mbCgData)-                                       sw0 <- sbvToSW st arg0-                                       sw1 <- sbvToSW st arg1-                                       sw2 <- sbvToSW st arg2-                                       sw3 <- sbvToSW st arg3-                                       sw4 <- sbvToSW st arg4-                                       sw5 <- sbvToSW st arg5-                                       sw6 <- sbvToSW st arg6-                                       mapM_ forceSWArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6]-                                       newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6]+                 result st = do isSMT <- inSMTMode st+                                case (isSMT, mbCgData) of+                                  (True, Just (_, v)) -> sbvToSW st (v arg0 arg1 arg2 arg3 arg4 arg5 arg6)+                                  _                   -> do newUninterpreted st nm (SBVType [kh, kg, kf, ke, kd, kc, kb, ka]) (fst `fmap` mbCgData)+                                                            sw0 <- sbvToSW st arg0+                                                            sw1 <- sbvToSW st arg1+                                                            sw2 <- sbvToSW st arg2+                                                            sw3 <- sbvToSW st arg3+                                                            sw4 <- sbvToSW st arg4+                                                            sw5 <- sbvToSW st arg5+                                                            sw6 <- sbvToSW st arg6+                                                            mapM_ forceSWArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6]+                                                            newExpr st ka $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6]  -- Uncurried functions of two arguments instance (SymWord c, SymWord b, HasKind a) => Uninterpreted ((SBV c, SBV b) -> SBV a) where@@ -1717,56 +1719,11 @@   sbvUninterpret mbCgData nm = let f = sbvUninterpret (uc7 `fmap` mbCgData) nm in \(arg0, arg1, arg2, arg3, arg4, arg5, arg6) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6     where uc7 (cs, fn) = (cs, \a b c d e f g -> fn (a, b, c, d, e, f, g)) --- | Adding arbitrary constraints. When adding constraints, one has to be careful about--- making sure they are not inconsistent. The function 'isVacuous' can be use for this purpose.--- Here is an example. Consider the following predicate:------ >>> let pred = do { x <- forall "x"; constrain $ x .< x; return $ x .>= (5 :: SWord8) }------ This predicate asserts that all 8-bit values are larger than 5, subject to the constraint that the--- values considered satisfy @x .< x@, i.e., they are less than themselves. Since there are no values that--- satisfy this constraint, the proof will pass vacuously:------ >>> prove pred--- Q.E.D.------ We can use 'isVacuous' to make sure to see that the pass was vacuous:------ >>> isVacuous pred--- True------ While the above example is trivial, things can get complicated if there are multiple constraints with--- non-straightforward relations; so if constraints are used one should make sure to check the predicate--- is not vacuously true. Here's an example that is not vacuous:------  >>> let pred' = do { x <- forall "x"; constrain $ x .> 6; return $ x .>= (5 :: SWord8) }------ This time the proof passes as expected:------  >>> prove pred'---  Q.E.D.------ And the proof is not vacuous:------  >>> isVacuous pred'---  False-constrain :: SBool -> Symbolic ()-constrain c = addConstraint Nothing Nothing c (bnot c)---- | A version of constrain, that also attaches a name. This variant is useful--- for extracting unsat cores.-namedConstraint :: String -> SBool -> Symbolic ()-namedConstraint nm c = addConstraint (Just nm) Nothing c (bnot c)---- | Adding a probabilistic constraint. The 'Double' argument is the probability--- threshold. Probabilistic constraints are useful for 'genTest' and 'quickCheck'--- calls where we restrict our attention to /interesting/ parts of the input domain.-pConstrain :: Double -> SBool -> Symbolic ()-pConstrain t c = addConstraint Nothing (Just t) c (bnot c)---- | Provide a tactic for the solver engine-tactic :: Tactic SBool -> Symbolic ()-tactic t = addSValTactic $ unSBV `fmap` t+-- | Symbolic computations provide a context for writing symbolic programs.+instance SolverContext Symbolic where+   constrain          (SBV c) = imposeConstraint Nothing   c+   namedConstraint nm (SBV c) = imposeConstraint (Just nm) c+   setOption o                = addNewSMTOption  o  -- | Introduce a soft assertion, with an optional penalty assertSoft :: String -> SBool -> Penalty -> Symbolic ()@@ -1803,19 +1760,23 @@   property s                       = error $ "Cannot quick-check in the presence of uninterpreted constants! (" ++ show s ++ ")"  instance Testable (Symbolic SBool) where-   property prop = QC.monadicIO $ do (cond, r, tvals) <- QC.run (newStdGen >>= test)+   property prop = QC.monadicIO $ do (cond, r, tvals) <- QC.run test                                      QC.pre cond                                      unless (r || null tvals) $ QC.monitor (QC.counterexample (complain tvals))                                      QC.assert r-     where test g = do (r, Result{resTraces=tvals, resConsts=cs, resConstraints=cstrs, resUIConsts=unints}) <- runSymbolic' (Concrete g) prop-                       let cval = fromMaybe (error "Cannot quick-check in the presence of uninterpeted constants!") . (`lookup` cs)-                           cond = all (cwToBool . cval . snd) cstrs-                       case map fst unints of-                         [] -> case unliteral r of-                                 Nothing -> noQC [show r]-                                 Just b  -> return (cond, b, tvals)-                         us -> noQC us+     where test = do (r, Result{resTraces=tvals, resConsts=cs, resConstraints=cstrs, resUIConsts=unints}) <- runSymbolic Concrete prop++                     let cval = fromMaybe (error "Cannot quick-check in the presence of uninterpeted constants!") . (`lookup` cs)+                         cond = all (cwToBool . cval . snd) cstrs++                     case map fst unints of+                       [] -> case unliteral r of+                               Nothing -> noQC [show r]+                               Just b  -> return (cond, b, tvals)+                       us -> noQC us+            complain qcInfo = showModel defaultSMTCfg (SMTModel [] qcInfo)+            noQC us         = error $ "Cannot quick-check in the presence of uninterpreted constants: " ++ intercalate ", " us  -- | Quick check an SBV property. Note that a regular 'quickCheck' call will work just as@@ -1843,28 +1804,5 @@                         res  = f xsbv                     sbvToSW st res --- | Check if a boolean condition is satisfiable in the current state. This function can be useful in contexts where an--- interpreter implemented on top of SBV needs to decide if a particular stae (represented by the boolean) is reachable--- in the current if-then-else paths implied by the 'ite' calls. Returns Nothing if not satisfiable, otherwise the--- satisfying model.-isSatisfiableInCurrentPath :: SBool -> Symbolic (Maybe SatResult)-isSatisfiableInCurrentPath cond = do-       st <- ask-       let cfg  = fromMaybe defaultSMTCfg (getSBranchRunConfig st)-           msg  = when (verbose cfg) . putStrLn . ("** " ++)-           pc   = getPathCondition st-       check <- liftIO $ internalSATCheck cfg (pc &&& cond) st "isSatisfiableInCurrentPath: Checking satisfiability"-       let res = case check of-                   SatResult Satisfiable{}   -> True-                   SatResult Unsatisfiable{} -> False-                   _                         -> error $ "isSatisfiableInCurrentPath: Unexpected external result: " ++ show check-       res `seq` liftIO $ msg $ "isSatisfiableInCurrentPath: Conclusion: " ++ if res then "Satisfiable" else "Unsatisfiable"-       return $ if res then Just check-                       else Nothing---- We use 'isVacuous' and 'prove' only for the "test" section in this file, and GHC complains about that. So, this shuts it up.-__unused :: a-__unused = error "__unused" (isVacuous :: SBool -> IO Bool) (prove :: SBool -> IO ThmResult)--{-# ANN module   ("HLint: ignore Reduce duplication" :: String)#-}-{-# ANN module   ("HLint: ignore Eta reduce" :: String)        #-}+{-# ANN module   ("HLint: ignore Reduce duplication" :: String) #-}+{-# ANN module   ("HLint: ignore Eta reduce" :: String)         #-}
Data/SBV/Core/Operations.hs view
@@ -20,7 +20,7 @@   , svAsBool, svAsInteger, svNumerator, svDenominator   -- ** Basic operations   , svPlus, svTimes, svMinus, svUNeg, svAbs-  , svDivide, svQuot, svRem+  , svDivide, svQuot, svRem, svQuotRem   , svEqual, svNotEqual   , svLessThan, svGreaterThan, svLessEq, svGreaterEq   , svAnd, svOr, svXOr, svNot@@ -207,11 +207,12 @@ -- "div" operator ("Euclidean" division, which always has a -- non-negative remainder). For unsigned bitvectors, it is "bvudiv"; -- and for signed bitvectors it is "bvsdiv", which rounds toward zero.--- All operations have unspecified semantics in case @y = 0@.+-- Division by 0 is defined s.t. @x/0 = 0@, which holds even when @x@ itself is @0@. svQuot :: SVal -> SVal -> SVal svQuot x y   | isConcreteZero x = x-  | isConcreteOne y  = x+  | isConcreteZero y = svInteger (kindOf x) 0+  | isConcreteOne  y = x   | True             = liftSym2 (mkSymOp Quot) nonzeroCheck                                 (noReal "quot") quot' (noFloat "quot") (noDouble "quot") x y   where@@ -222,17 +223,22 @@ -- it is used: For unbounded integers, it corresponds to the SMT-Lib -- "mod" operator (always non-negative). For unsigned bitvectors, it -- is "bvurem"; and for signed bitvectors it is "bvsrem", which rounds--- toward zero (sign of remainder matches that of @x@). All operations--- have unspecified semantics in case @y = 0@.+-- toward zero (sign of remainder matches that of @x@). Division by 0 is+-- defined s.t. @x/0 = 0@, which holds even when @x@ itself is @0@. svRem :: SVal -> SVal -> SVal svRem x y   | isConcreteZero x = x-  | isConcreteOne y  = svInteger (kindOf x) 0+  | isConcreteZero y = x+  | isConcreteOne  y = svInteger (kindOf x) 0   | True             = liftSym2 (mkSymOp Rem) nonzeroCheck                                 (noReal "rem") rem' (noFloat "rem") (noDouble "rem") x y   where     rem' a b | kindOf x == KUnbounded = mod a (abs b)              | otherwise              = rem a b++-- | Combination of quot and rem+svQuotRem :: SVal -> SVal -> (SVal, SVal)+svQuotRem x y = (x `svQuot` y, x `svRem` y)  -- | Optimize away x == true and x /= false to x; otherwise just do eqOpt eqOptBool :: Op -> SW -> SW -> SW -> Maybe SW
Data/SBV/Core/Symbolic.hs view
@@ -19,6 +19,7 @@ {-# LANGUAGE    NamedFieldPuns             #-} {-# LANGUAGE    DeriveDataTypeable         #-} {-# LANGUAGE    DeriveFunctor              #-}+{-# LANGUAGE    Rank2Types                 #-} {-# LANGUAGE    CPP                        #-} {-# OPTIONS_GHC -fno-warn-orphans          #-} @@ -39,32 +40,35 @@   , NamedSymVar   , getSValPathCondition, extendSValPathCondition   , getTableIndex-  , SBVPgm(..), Symbolic, runSymbolic, runSymbolic', State-  , inProofMode, SBVRunMode(..), Result(..)-  , Logic(..), SMTLibLogic(..), registerKind, registerLabel-  , addAssertion, addSValConstraint, internalConstraint, internalVariable+  , SBVPgm(..), Symbolic, runSymbolic, State(..), withNewIncState, IncState(..), incrementInternalCounter+  , inSMTMode, SBVRunMode(..), IStage(..), Result(..)+  , registerKind, registerLabel+  , addAssertion, addNewSMTOption, imposeConstraint, internalConstraint, internalVariable   , SMTLibPgm(..), SMTLibVersion(..), smtLibVersionExtension   , SolverCapabilities(..)   , extractSymbolicSimulationState   , OptimizeStyle(..), Objective(..), Penalty(..), objectiveName, addSValOptGoal-  , Tactic(..), addSValTactic, isParallelCaseAnywhere-  , SMTScript(..), Solver(..), SMTSolver(..), SMTResult(..), SMTModel(..), SMTConfig(..), SMTEngine, getSBranchRunConfig+  , Query(..), QueryState(..)+  , SMTScript(..), Solver(..), SMTSolver(..), SMTResult(..), SMTModel(..), SMTConfig(..), SMTEngine   , outputSVal-  , mkSValUserSort-  , SArr(..), readSArr, resetSArr, writeSArr, mergeSArr, newSArr, eqSArr+  , SArr(..), readSArr, writeSArr, mergeSArr, newSArr, eqSArr   ) where -import Control.DeepSeq      (NFData(..))-import Control.Monad        (when, unless)-import Control.Monad.Reader (MonadReader, ReaderT, ask, runReaderT)-import Control.Monad.Trans  (MonadIO, liftIO)-import Data.Char            (isAlpha, isAlphaNum, toLower)-import Data.IORef           (IORef, newIORef, modifyIORef, readIORef, writeIORef)-import Data.List            (intercalate, sortBy)-import Data.Maybe           (isJust, fromJust, fromMaybe)+import Control.DeepSeq          (NFData(..))+import Control.Monad            (when, unless)+import Control.Monad.Reader     (MonadReader, ReaderT, ask, runReaderT)+import Control.Monad.State.Lazy (MonadState, StateT(..))+import Control.Monad.Trans      (MonadIO, liftIO)+import Data.Char                (isAlpha, isAlphaNum, toLower)+import Data.IORef               (IORef, newIORef, readIORef)+import Data.List                (intercalate, sortBy)+import Data.Maybe               (isJust, fromJust, fromMaybe) -import GHC.Stack.Compat+import Data.Time (getCurrentTime, UTCTime) +import GHC.Stack++import qualified Data.IORef    as R    (modifyIORef') import qualified Data.Generics as G    (Data(..)) import qualified Data.IntMap   as IMap (IntMap, empty, size, toAscList, lookup, insert, insertWith) import qualified Data.Map      as Map  (Map, empty, toList, size, insert, lookup)@@ -73,15 +77,13 @@ import qualified Data.Sequence as S    (Seq, empty, (|>))  import System.Mem.StableName-import System.Random  import Data.SBV.Core.Kind import Data.SBV.Core.Concrete import Data.SBV.SMT.SMTLibNames import Data.SBV.Utils.TDiff(Timing) -import Prelude ()-import Prelude.Compat+import Data.SBV.Control.Types  -- | A symbolic node id newtype NodeId = NodeId Int deriving (Eq, Ord)@@ -102,8 +104,8 @@ swKind (SW k _) = k  -- | Forcing an argument; this is a necessary evil to make sure all the arguments--- to an uninterpreted function and sBranch test conditions are evaluated before called;--- the semantics of uinterpreted functions is necessarily strict; deviating from Haskell's+-- to an uninterpreted function are evaluated before called; the semantics of uinterpreted+-- functions is necessarily strict; deviating from Haskell's forceSWArg :: SW -> IO () forceSWArg (SW k n) = k `seq` n `seq` return () @@ -175,7 +177,7 @@           | FP_IsPositive           deriving (Eq, Ord) --- | Note that the show instance maps to the SMTLib names. We need to make sure+-- Note that the show instance maps to the SMTLib names. We need to make sure -- this mapping stays correct through SMTLib changes. The only exception -- is FP_Cast; where we handle different source/origins explicitly later on. instance Show FPOp where@@ -214,7 +216,7 @@           | PB_Eq      [Int] Int  -- ^ Exactly k,  with coefficients given. Generalized PB_Exactly           deriving (Eq, Ord, Show) --- | Show instance for 'Op'. Note that this is largely for debugging purposes, not used+-- Show instance for 'Op'. Note that this is largely for debugging purposes, not used -- for being read by any tool. instance Show Op where   show (Shl i) = "<<"  ++ show i@@ -276,7 +278,7 @@   where isCommutative :: Op -> Bool         isCommutative o = o `elem` [Plus, Times, Equal, NotEqual, And, Or, XOr] --- | Show instance for 'SBVExpr'. Again, only for debugging purposes.+-- Show instance for 'SBVExpr'. Again, only for debugging purposes. instance Show SBVExpr where   show (SBVApp Ite [t, a, b])             = unwords ["if", show t, "then", show a, "else", show b]   show (SBVApp (Shl i) [a])               = unwords [show a, "<<", show i]@@ -293,10 +295,14 @@ -- | 'NamedSymVar' pairs symbolic words and user given/automatically generated names type NamedSymVar = (SW, String) --- | Style of optimization-data OptimizeStyle = Lexicographic -- ^ Objectives are optimized in the order given, earlier objectives have higher priority. This is the default.-                   | Independent   -- ^ Each objective is optimized independently.-                   | Pareto        -- ^ Objectives are optimized according to pareto front: That is, no objective can be made better without making some other worse.+-- | Style of optimization. Note that in the pareto case the user is allowed+-- to specify a max number of fronts to query the solver for, since there might+-- potentially be an infinite number of them and there is no way to know exactly+-- how many ahead of time. If 'Nothing' is given, SBV will possibly loop forever+-- if the number is really infinite.+data OptimizeStyle = Lexicographic      -- ^ Objectives are optimized in the order given, earlier objectives have higher priority. This is the default.+                   | Independent        -- ^ Each objective is optimized independently.+                   | Pareto (Maybe Int) -- ^ Objectives are optimized according to pareto front: That is, no objective can be made better without making some other worse.                    deriving (Eq, Show)  -- | Penalty for a soft-assertion. The default penalty is @1@, with all soft-assertions belonging@@ -319,18 +325,20 @@ objectiveName (Maximize   s _)   = s objectiveName (AssertSoft s _ _) = s --- | Solver tactic-data Tactic a = CaseSplit          Bool [(String, a, [Tactic a])]  -- ^ Case-split, with implicit coverage. Bool says whether we should be verbose.-              | CheckCaseVacuity   Bool                            -- ^ Should the case-splits be checked for vacuity? (Default: True.)-              | ParallelCase                                       -- ^ Run case-splits in parallel. (Default: Sequential.)-              | CheckConstrVacuity Bool                            -- ^ Should "constraints" be checked for vacuity? (Default: False.)-              | StopAfter          Int                             -- ^ Time-out given to solver, in seconds.-              | CheckUsing         String                          -- ^ Invoke with check-sat-using command, instead of check-sat-              | UseLogic           Logic                           -- ^ Use this logic, a custom one can be specified too-              | UseSolver          SMTConfig                       -- ^ Use this solver (z3, yices, etc.)-              | OptimizePriority   OptimizeStyle                   -- ^ Use this style for optimize calls. (Default: Lexicographic)-              deriving (Show, Functor)+-- | The state we keep track of as we interact with the solver+data QueryState = QueryState { queryAsk                 :: Maybe Int -> String -> IO String+                             , querySend                :: Maybe Int -> String -> IO ()+                             , queryRetrieveResponse    :: Maybe Int -> IO String+                             , queryConfig              :: SMTConfig+                             , queryTerminate           :: IO ()+                             , queryTimeOutValue        :: Maybe Int+                             , queryAssertionStackDepth :: Int+                             } +-- | A query is a user-guided mechanism to directly communicate and extract results from the solver.+newtype Query a = Query (StateT State IO a)+             deriving (Applicative, Functor, Monad, MonadIO, MonadState State)+ instance NFData OptimizeStyle where    rnf x = x `seq` () @@ -343,47 +351,31 @@    rnf (Maximize   s a)   = rnf s `seq` rnf a `seq` ()    rnf (AssertSoft s a p) = rnf s `seq` rnf a `seq` rnf p `seq` () -instance NFData a => NFData (Tactic a) where-   rnf (CaseSplit   b l)      = rnf b `seq` rnf l `seq` ()-   rnf (CheckCaseVacuity b)   = rnf b `seq` ()-   rnf ParallelCase           = ()-   rnf (CheckConstrVacuity b) = rnf b `seq` ()-   rnf (StopAfter        i)   = rnf i `seq` ()-   rnf (CheckUsing       s)   = rnf s `seq` ()-   rnf (UseLogic         l)   = rnf l `seq` ()-   rnf (UseSolver        s)   = rnf s `seq` ()-   rnf (OptimizePriority s)   = rnf s `seq` ()---- | Is there a parallel-case anywhere?-isParallelCaseAnywhere :: Tactic a -> Bool-isParallelCaseAnywhere ParallelCase{}   = True-isParallelCaseAnywhere (CaseSplit _ cs) = or [any isParallelCaseAnywhere t | (_, _, t) <- cs]-isParallelCaseAnywhere _                = False- -- | Result of running a symbolic computation-data Result = Result { reskinds       :: Set.Set Kind                            -- ^ kinds used in the program-                     , resTraces      :: [(String, CW)]                          -- ^ quick-check counter-example information (if any)-                     , resUISegs      :: [(String, [String])]                    -- ^ uninterpeted code segments-                     , resInputs      :: [(Quantifier, NamedSymVar)]             -- ^ inputs (possibly existential)-                     , resConsts      :: [(SW, CW)]                              -- ^ constants-                     , resTables      :: [((Int, Kind, Kind), [SW])]             -- ^ tables (automatically constructed) (tableno, index-type, result-type) elts-                     , resArrays      :: [(Int, ArrayInfo)]                      -- ^ arrays (user specified)-                     , resUIConsts    :: [(String, SBVType)]                     -- ^ uninterpreted constants-                     , resAxioms      :: [(String, [String])]                    -- ^ axioms-                     , resAsgns       :: SBVPgm                                  -- ^ assignments-                     , resConstraints :: [(Maybe String, SW)]                    -- ^ additional constraints (boolean)-                     , resTactics     :: [Tactic SW]                             -- ^ User given tactics-                     , resGoals       :: [Objective (SW, SW)]                    -- ^ User specified optimization goals-                     , resAssertions  :: [(String, Maybe CallStack, SW)]         -- ^ assertions-                     , resOutputs     :: [SW]                                    -- ^ outputs+data Result = Result { reskinds       :: Set.Set Kind                    -- ^ kinds used in the program+                     , resTraces      :: [(String, CW)]                  -- ^ quick-check counter-example information (if any)+                     , resUISegs      :: [(String, [String])]            -- ^ uninterpeted code segments+                     , resInputs      :: [(Quantifier, NamedSymVar)]     -- ^ inputs (possibly existential)+                     , resConsts      :: [(SW, CW)]                      -- ^ constants+                     , resTables      :: [((Int, Kind, Kind), [SW])]     -- ^ tables (automatically constructed) (tableno, index-type, result-type) elts+                     , resArrays      :: [(Int, ArrayInfo)]              -- ^ arrays (user specified)+                     , resUIConsts    :: [(String, SBVType)]             -- ^ uninterpreted constants+                     , resAxioms      :: [(String, [String])]            -- ^ axioms+                     , resAsgns       :: SBVPgm                          -- ^ assignments+                     , resConstraints :: [(Maybe String, SW)]            -- ^ additional constraints (boolean)+                     , resAssertions  :: [(String, Maybe CallStack, SW)] -- ^ assertions+                     , resOutputs     :: [SW]                            -- ^ outputs                      } --- | Show instance for 'Result'. Only for debugging purposes.+-- Show instance for 'Result'. Only for debugging purposes. instance Show Result where-  show (Result _ _ _ _ cs _ _ [] [] _ [] _ _ _ [r])+  -- If there's nothing interesting going on, just print the constant. Note that the+  -- definiton of interesting here is rather subjective; but essentially if we reduced+  -- the result to a single constant already, without any reference to anything.+  show Result{resConsts=cs, resOutputs=[r]}     | Just c <- r `lookup` cs     = show c-  show (Result kinds _ cgs is cs ts as uis axs xs cstrs tacs goals asserts os) = intercalate "\n" $+  show (Result kinds _ cgs is cs ts as uis axs xs cstrs asserts os) = intercalate "\n" $                    (if null usorts then [] else "SORTS" : map ("  " ++) usorts)                 ++ ["INPUTS"]                 ++ map shn is@@ -399,10 +391,6 @@                 ++ concatMap shcg cgs                 ++ ["AXIOMS"]                 ++ map shax axs-                ++ ["TACTICS"]-                ++ map show tacs-                ++ ["GOALS"]-                ++ map show goals                 ++ ["DEFINE"]                 ++ map (\(s, e) -> "  " ++ shs s ++ " = " ++ show e) (F.toList (pgmAssignments xs))                 ++ ["CONSTRAINTS"]@@ -410,8 +398,11 @@                 ++ ["ASSERTIONS"]                 ++ map (("  "++) . shAssert) asserts                 ++ ["OUTPUTS"]-                ++ map (("  " ++) . show) os-    where usorts = [sh s t | KUserSort s t <- Set.toList kinds]+                ++ sh2 os+    where sh2 :: Show a => [a] -> [String]+          sh2 = map (("  "++) . show)++          usorts = [sh s t | KUserSort s t <- Set.toList kinds]                    where sh s (Left   _) = s                          sh s (Right es) = s ++ " (" ++ intercalate ", " es ++ ")" @@ -452,17 +443,14 @@                 stk ++ ": " ++ show p  -- | The context of a symbolic array as created-data ArrayContext = ArrayFree (Maybe SW)     -- ^ A new array, with potential initializer for each cell-                  | ArrayReset Int SW        -- ^ An array created from another array by fixing each element to another value+data ArrayContext = ArrayFree                -- ^ A new array, the contents are uninitialized                   | ArrayMutate Int SW SW    -- ^ An array created by mutating another array at a given cell                   | ArrayMerge  SW Int Int   -- ^ An array created by symbolically merging two other arrays  instance Show ArrayContext where-  show (ArrayFree Nothing)  = " initialized with random elements"-  show (ArrayFree (Just s)) = " initialized with " ++ show s ++ " :: " ++ show (swKind s)-  show (ArrayReset i s)     = " reset array_" ++ show i ++ " with " ++ show s ++ " :: " ++ show (swKind s)-  show (ArrayMutate i a b)  = " cloned from array_" ++ show i ++ " with " ++ show a ++ " :: " ++ show (swKind a) ++ " |-> " ++ show b ++ " :: " ++ show (swKind b)-  show (ArrayMerge s i j)   = " merged arrays " ++ show i ++ " and " ++ show j ++ " on condition " ++ show s+  show ArrayFree           = " initialized with random elements"+  show (ArrayMutate i a b) = " cloned from array_" ++ show i ++ " with " ++ show a ++ " :: " ++ show (swKind a) ++ " |-> " ++ show b ++ " :: " ++ show (swKind b)+  show (ArrayMerge  s i j) = " merged arrays " ++ show i ++ " and " ++ show j ++ " on condition " ++ show s  -- | Expression map, used for hash-consing type ExprMap   = Map.Map SBVExpr SW@@ -491,29 +479,68 @@ -- | Cached values, implementing sharing type Cache a   = IMap.IntMap [(StableName (State -> IO a), a)] +-- | Stage of an interactive run+data IStage = ISetup    -- Before we initiate contact+            | IRun      -- After the contact is started+ -- | Different means of running a symbolic piece of code-data SBVRunMode = Proof (Bool, SMTConfig) -- ^ Fully Symbolic, proof mode.-                | CodeGen                 -- ^ Code generation mode.-                | Concrete StdGen         -- ^ Concrete simulation mode. The StdGen is for the pConstrain acceptance in cross runs.+data SBVRunMode = SMTMode  IStage Bool SMTConfig -- ^ In regular mode, with a stage. Bool is True if this is SAT.+                | CodeGen                        -- ^ Code generation mode.+                | Concrete                       -- ^ Concrete simulation mode. --- | Is this a concrete run? (i.e., quick-check or test-generation like)-isConcreteMode :: State -> Bool-isConcreteMode State{runMode} = case runMode of-                                  Concrete{} -> True-                                  Proof{}    -> False-                                  CodeGen    -> False+-- Show instance for SBVRunMode; debugging purposes only+instance Show SBVRunMode where+   show (SMTMode ISetup True  _) = "Satisfiability setup"+   show (SMTMode IRun   True  _) = "Satisfiability"+   show (SMTMode ISetup False _) = "Proof setup"+   show (SMTMode IRun   False _) = "Proof"+   show CodeGen                  = "Code generation"+   show Concrete                 = "Concrete evaluation"  -- | Is this a CodeGen run? (i.e., generating code)-isCodeGenMode :: State -> Bool-isCodeGenMode State{runMode} = case runMode of-                                 Concrete{} -> False-                                 Proof{}    -> False-                                 CodeGen    -> True+isCodeGenMode :: State -> IO Bool+isCodeGenMode State{runMode} = do rm <- readIORef runMode+                                  return $ case rm of+                                             Concrete{} -> False+                                             SMTMode{}  -> False+                                             CodeGen    -> True +-- | The state in query mode, i.e., additional context+data IncState = IncState { rNewInps   :: IORef [NamedSymVar]   -- always existential!+                         , rNewKinds  :: IORef KindSet+                         , rNewConsts :: IORef CnstMap+                         , rNewAsgns  :: IORef SBVPgm+                         }++-- | Get a new IncState+newIncState :: IO IncState+newIncState = do+        is  <- newIORef []+        ks  <- newIORef Set.empty+        nc  <- newIORef Map.empty+        pgm <- newIORef (SBVPgm S.empty)+        return IncState { rNewInps   = is+                        , rNewKinds  = ks+                        , rNewConsts = nc+                        , rNewAsgns  = pgm+                        }++-- | Get a new IncState+withNewIncState :: State -> (State -> IO a) -> IO (IncState, a)+withNewIncState st cont = do+        is <- newIncState+        R.modifyIORef' (rIncState st) (const is)+        r  <- cont st+        finalIncState <- readIORef (rIncState st)+        return (finalIncState, r)++-- | Return and clean and incState+ -- | The state of the symbolic interpreter-data State  = State { runMode      :: SBVRunMode-                    , pathCond     :: SVal                             -- ^ kind KBool-                    , rStdGen      :: IORef StdGen+data State  = State { pathCond     :: SVal                             -- ^ kind KBool+                    , startTime    :: UTCTime+                    , runMode      :: IORef SBVRunMode+                    , rIncState    :: IORef IncState                     , rCInfo       :: IORef [(String, CW)]                     , rctr         :: IORef Int                     , rUsedKinds   :: IORef KindSet@@ -529,13 +556,18 @@                     , rUIMap       :: IORef UIMap                     , rCgMap       :: IORef CgMap                     , raxioms      :: IORef [(String, [String])]-                    , rTacs        :: IORef [Tactic SW]+                    , rSMTOptions  :: IORef [SMTOption]                     , rOptGoals    :: IORef [Objective (SW, SW)]                     , rAsserts     :: IORef [(String, Maybe CallStack, SW)]                     , rSWCache     :: IORef (Cache SW)                     , rAICache     :: IORef (Cache Int)+                    , queryState   :: IORef (Maybe QueryState)                     } +-- NFData is a bit of a lie, but it's sufficient, most of the content is iorefs that we don't want to touch+instance NFData State where+   rnf State{} = ()+ -- | Get the current path condition getSValPathCondition :: State -> SVal getSValPathCondition = pathCond@@ -545,17 +577,12 @@ extendSValPathCondition st f = st{pathCond = f (pathCond st)}  -- | Are we running in proof mode?-inProofMode :: State -> Bool-inProofMode s = case runMode s of-                  Proof{}    -> True-                  CodeGen    -> False-                  Concrete{} -> False---- | If in proof mode, get the underlying configuration (used for 'sBranch')-getSBranchRunConfig :: State -> Maybe SMTConfig-getSBranchRunConfig st = case runMode st of-                           Proof (_, s)  -> Just s-                           _             -> Nothing+inSMTMode :: State -> IO Bool+inSMTMode State{runMode} = do rm <- readIORef runMode+                              return $ case rm of+                                         CodeGen    -> False+                                         Concrete{} -> False+                                         SMTMode{}  -> True  -- | The "Symbolic" value. Either a constant (@Left@) or a symbolic -- value (@Right Cached@). Note that caching is essential for making@@ -565,7 +592,7 @@ instance HasKind SVal where   kindOf (SVal k _) = k --- | Show instance for 'SVal'. Not particularly "desirable", but will do if needed+-- Show instance for 'SVal'. Not particularly "desirable", but will do if needed -- NB. We do not show the type info on constant KBool values, since there's no -- implicit "fromBoolean" applied to Booleans in Haskell; and thus a statement -- of the form "True :: SBool" is just meaningless. (There should be a fromBoolean!)@@ -582,20 +609,37 @@   SVal _ (Left a) /= SVal _ (Left b) = a /= b   a /= b = error $ "Comparing symbolic bit-vectors; Use (./=) instead. Received: " ++ show (a, b) --- | Increment the variable counter-incCtr :: State -> IO Int-incCtr s = do ctr <- readIORef (rctr s)-              let i = ctr + 1-              i `seq` writeIORef (rctr s) i-              return ctr+-- | Things we do not support in interactive mode, at least for now!+noInteractive :: [String] -> a+noInteractive ss = error $ unlines $  ""+                                   :  "*** Data.SBV: Unsupported interactive/query mode feature."+                                   :  map ("***  " ++) ss+                                   ++ ["*** Data.SBV: Please report this as a feature request!"] --- | Generate a random value, for quick-check and test-gen purposes-throwDice :: State -> IO Double-throwDice st = do g <- readIORef (rStdGen st)-                  let (r, g') = randomR (0, 1) g-                  writeIORef (rStdGen st) g'-                  return r+-- | Modification of the state, but carefully handling the interactive tasks.+-- Note that the state is always updated regardless of the mode, but we get+-- to also perform extra operation in interactive mode. (Typically error out, but also simply+-- ignore if it has no impact.)+modifyState :: State -> (State -> IORef a) -> (a -> a) -> IO () -> IO ()+modifyState st@State{runMode} field update interactiveUpdate = do+        R.modifyIORef' (field st) update+        rm <- readIORef runMode+        case rm of+          SMTMode IRun _ _ -> interactiveUpdate+          _                -> return () +-- | Modify the incremental state+modifyIncState  :: State -> (IncState -> IORef a) -> (a -> a) -> IO ()+modifyIncState State{rIncState} field update = do+        incState <- readIORef rIncState+        R.modifyIORef' (field incState) update++-- | Increment the variable counter+incrementInternalCounter :: State -> IO Int+incrementInternalCounter st = do ctr <- readIORef (rctr st)+                                 modifyState st rctr (+1) (return ())+                                 return ctr+ -- | Create a new uninterpreted symbol, possibly with user given code newUninterpreted :: State -> String -> SBVType -> Maybe [String] -> IO () newUninterpreted st nm t mbCode@@ -607,42 +651,65 @@           Just t' -> when (t /= t') $ error $  "Uninterpreted constant " ++ show nm ++ " used at incompatible types\n"                                             ++ "      Current type      : " ++ show t ++ "\n"                                             ++ "      Previously used at: " ++ show t'-          Nothing -> do modifyIORef (rUIMap st) (Map.insert nm t)-                        when (isJust mbCode) $ modifyIORef (rCgMap st) (Map.insert nm (fromJust mbCode))+          Nothing -> do modifyState st rUIMap (Map.insert nm t) $ noInteractive [ "Uninterpreted function introduction:"+                                                                                , "  Named:  " ++ nm+                                                                                , "  Type :  " ++ show t+                                                                                ]+                        when (isJust mbCode) $ modifyState st rCgMap (Map.insert nm (fromJust mbCode)) (return ())   where validChar x = isAlphaNum x || x `elem` "_"         enclosed    = head nm == '|' && last nm == '|' && length nm > 2 && not (any (`elem` "|\\") (tail (init nm)))  -- | Add a new sAssert based constraint addAssertion :: State -> Maybe CallStack -> String -> SW -> IO ()-addAssertion st cs msg cond = modifyIORef (rAsserts st) ((msg, cs, cond):)+addAssertion st cs msg cond = modifyState st rAsserts ((msg, cs, cond):)+                                        $ noInteractive [ "Named assertions (sAssert):"+                                                        , "  Tag: " ++ msg+                                                        , "  Loc: " ++ maybe "Unknown" show cs+                                                        ]  -- | Create an internal variable, which acts as an input but isn't visible to the user. -- Such variables are existentially quantified in a SAT context, and universally quantified -- in a proof context. internalVariable :: State -> Kind -> IO SW internalVariable st k = do (sw, nm) <- newSW st k-                           let q = case runMode st of-                                     Proof (True,  _) -> EX-                                     _                -> ALL-                           modifyIORef (rinps st) ((q, (sw, "__internal_sbv_" ++ nm)):)+                           rm <- readIORef (runMode st)+                           let q = case rm of+                                     SMTMode    _ True  _ -> EX+                                     SMTMode    _ False _ -> ALL+                                     CodeGen              -> ALL+                                     Concrete{}           -> ALL+                           modifyState st rinps ((q, (sw, "__internal_sbv_" ++ nm)):)+                                     $ noInteractive [ "Internal variable creation:"+                                                     , "  Named: " ++ nm+                                                     ]                            return sw {-# INLINE internalVariable #-}  -- | Create a new SW newSW :: State -> Kind -> IO (SW, String)-newSW st k = do ctr <- incCtr st+newSW st k = do ctr <- incrementInternalCounter st                 let sw = SW k (NodeId ctr)                 registerKind st k                 return (sw, 's' : show ctr) {-# INLINE newSW #-} --- | Register a new kind with the system, used for uninterpreted sorts+-- | Register a new kind with the system, used for uninterpreted sorts.+-- NB: Is it safe to have new kinds in query mode? It could be that+-- the new kind might introduce a constraint that effects the logic. For+-- instance, if we're seeing 'Double' for the first time and using a BV+-- logic, then things would fall apart. But this should be rare, and hopefully+-- the 'success' checking mechanism will catch the rare cases where this+-- is an issue. In either case, the user can always arrange for the right+-- logic by calling 'setLogic' appropriately, so it seems safe to just+-- allow for this. registerKind :: State -> Kind -> IO () registerKind st k   | KUserSort sortName _ <- k, map toLower sortName `elem` smtLibReservedNames   = error $ "SBV: " ++ show sortName ++ " is a reserved sort; please use a different name."   | True-  = modifyIORef (rUsedKinds st) (Set.insert k)+  = do ks <- readIORef (rUsedKinds st)+       unless (k `Set.member` ks) $ modifyState st rUsedKinds (Set.insert k)+                                              $ modifyIncState st rNewKinds (Set.insert k)  -- | Register a new label with the system, making sure they are unique and have no '|'s in them registerLabel :: State -> String -> IO ()@@ -657,7 +724,7 @@   = do old <- readIORef $ rUsedLbls st        if nm `Set.member` old           then error $ "SBV: " ++ show nm ++ " is used as a label multiple times. Please do not use duplicate names!"-          else modifyIORef (rUsedLbls st) (Set.insert nm)+          else modifyState st rUsedLbls (Set.insert nm) (return ())  -- | Create a new constant; hash-cons as necessary -- NB. For each constant, we also store weather it's negative-0 or not,@@ -672,7 +739,8 @@     Just sw -> return sw     Nothing -> do let k = kindOf c                   (sw, _) <- newSW st k-                  modifyIORef (rconstMap st) (Map.insert key sw)+                  let ins = Map.insert key sw+                  modifyState st rconstMap ins $ modifyIncState st rNewConsts ins                   return sw   where isNeg0 (CWFloat  f) = isNegativeZero f         isNeg0 (CWDouble d) = isNegativeZero d@@ -687,7 +755,12 @@   case key `Map.lookup` tblMap of     Just i -> return i     _      -> do let i = Map.size tblMap-                 modifyIORef (rtblMap st) (Map.insert key i)+                 modifyState st rtblMap (Map.insert key i)+                            $ noInteractive [ "Creation of a new table:"+                                            , "   Index kind: " ++ show at+                                            , "   Value kind: " ++ show rt+                                            , "   Elements  : " ++ unwords (map show elts)+                                            ]                  return i  -- | Create a new expression; hash-cons as necessary@@ -698,8 +771,9 @@    case e `Map.lookup` exprMap of      Just sw -> return sw      Nothing -> do (sw, _) <- newSW st k-                   modifyIORef (spgm st)     (\(SBVPgm xs) -> SBVPgm (xs S.|> (sw, e)))-                   modifyIORef (rexprMap st) (Map.insert e sw)+                   let append (SBVPgm xs) = SBVPgm (xs S.|> (sw, e))+                   modifyState st spgm append $ modifyIncState st rNewAsgns append+                   modifyState st rexprMap (Map.insert e sw) (return ())                    return sw {-# INLINE newExpr #-} @@ -724,53 +798,58 @@  -- | Create a symbolic value, based on the quantifier we have. If an -- explicit quantifier is given, we just use that. If not, then we--- pick existential for SAT calls and universal for everything else.+-- pick the quantifier appropriately based on the run-mode. -- @randomCW@ is used for generating random values for this variable--- when used for 'quickCheck' purposes.-svMkSymVar :: Maybe Quantifier -> Kind -> Maybe String -> Symbolic SVal-svMkSymVar mbQ k mbNm = do-        st <- ask-        let q = case (mbQ, runMode st) of-                  (Just x,  _)                -> x   -- user given, just take it-                  (Nothing, Concrete{})       -> ALL -- concrete simulation, pick universal-                  (Nothing, Proof (True,  _)) -> EX  -- sat mode, pick existential-                  (Nothing, Proof (False, _)) -> ALL -- proof mode, pick universal-                  (Nothing, CodeGen)          -> ALL -- code generation, pick universal-        case runMode st of-          Concrete _ | q == EX -> case mbNm of-                                    Nothing -> error $ "Cannot quick-check in the presence of existential variables, type: " ++ show k-                                    Just nm -> error $ "Cannot quick-check in the presence of existential variable " ++ nm ++ " :: " ++ show k-          Concrete _           -> do cw <- liftIO (randomCW k)-                                     liftIO $ modifyIORef (rCInfo st) ((fromMaybe "_" mbNm, cw):)-                                     return (SVal k (Left cw))-          _          -> do (sw, internalName) <- liftIO $ newSW st k-                           let nm = fromMaybe internalName mbNm-                           introduceUserName st nm k q sw+-- when used for 'quickCheck' or 'genTest' purposes.+svMkSymVar :: Maybe Quantifier -> Kind -> Maybe String -> State -> IO SVal+svMkSymVar mbQ k mbNm st = do+        rm <- readIORef (runMode st) --- | Create a properly quantified variable of a user defined sort. Only valid--- in proof contexts.-mkSValUserSort :: Kind -> Maybe Quantifier -> Maybe String -> Symbolic SVal-mkSValUserSort k mbQ mbNm = do-        st <- ask-        let (KUserSort sortName _) = k-        liftIO $ registerKind st k-        let q = case (mbQ, runMode st) of-                  (Just x,  _)                -> x-                  (Nothing, Proof (True,  _)) -> EX-                  (Nothing, Proof (False, _)) -> ALL-                  (Nothing, CodeGen)          -> error $ "SBV: Uninterpreted sort " ++ sortName ++ " can not be used in code-generation mode."-                  (Nothing, Concrete{})       -> error $ "SBV: Uninterpreted sort " ++ sortName ++ " can not be used in concrete simulation mode."-        ctr <- liftIO $ incCtr st-        let sw = SW k (NodeId ctr)-            nm = fromMaybe ('s':show ctr) mbNm-        introduceUserName st nm k q sw+        let varInfo = case mbNm of+                        Nothing -> ", of type " ++ show k+                        Just nm -> ", while defining " ++ nm ++ " :: " ++ show k +            disallow what  = error $ "Data.SBV: Unsupported: " ++ what ++ varInfo ++ " in mode: " ++ show rm++            noUI cont+              | isUninterpreted k  = disallow "Uninterpreted sorts"+              | True               = cont++            mkS q = do (sw, internalName) <- newSW st k+                       let nm = fromMaybe internalName mbNm+                       introduceUserName st nm k q sw++            mkC   = do cw <- randomCW k+                       do registerKind st k+                          modifyState st rCInfo ((fromMaybe "_" mbNm, cw):) (return ())+                       return $ SVal k (Left cw)++        case (mbQ, rm) of+          (Just q,  SMTMode{}        ) -> mkS q+          (Nothing, SMTMode _ isSAT _) -> mkS (if isSAT then EX else ALL)++          (Just EX, CodeGen{})         -> disallow "Existentially quantified variables"+          (_      , CodeGen)           -> noUI $ mkS ALL  -- code generation, pick universal++          (Just EX,  Concrete{})       -> disallow "Existentially quantified variables"+          (_      ,  Concrete{})       -> noUI mkC+ -- | Introduce a new user name. We die if repeated.-introduceUserName :: State -> String -> Kind -> Quantifier -> SW -> Symbolic SVal-introduceUserName st nm k q sw = do is <- liftIO $ readIORef (rinps st)+introduceUserName :: State -> String -> Kind -> Quantifier -> SW -> IO SVal+introduceUserName st nm k q sw = do is <- readIORef (rinps st)                                     if nm `elem` [n | (_, (_, n)) <- is]                                        then error $ "SBV: Repeated user given name: " ++ show nm ++ ". Please use unique names."-                                       else do liftIO $ modifyIORef (rinps st) ((q, (sw, nm)):)+                                       else do let newInp olds = case q of+                                                                   EX  -> (sw, nm) : olds+                                                                   ALL -> noInteractive [ "Adding a new universally quantified: "+                                                                                        , "  Name      : " ++ show nm+                                                                                        , "  Kind      : " ++ show k+                                                                                        , "  Quantifier: Universal"+                                                                                        , "  Node      : " ++ show sw+                                                                                        , "Only existential variables are supported in query mode."+                                                                                        ]+                                               modifyState st rinps ((q, (sw, nm)):)+                                                         $ modifyIncState st rNewInps newInp                                                return $ SVal k $ Right $ cache (const (return sw))  -- | Add a user specified axiom to the generated SMT-Lib file. The first argument is a mere@@ -781,16 +860,17 @@ addAxiom :: String -> [String] -> Symbolic () addAxiom nm ax = do         st <- ask-        liftIO $ modifyIORef (raxioms st) ((nm, ax) :)---- | Run a symbolic computation in Proof mode and return a 'Result'. The boolean--- argument indicates if this is a sat instance or not.-runSymbolic :: (Bool, SMTConfig) -> Symbolic a -> IO Result-runSymbolic m c = snd `fmap` runSymbolic' (Proof m) c+        liftIO $ modifyState st raxioms ((nm, ax) :)+                           $ noInteractive [ "Adding a new axiom:"+                                           , "  Named: " ++ show nm+                                           , "  Axiom: " ++ unlines ax+                                           ]  -- | Run a symbolic computation, and return a extra value paired up with the 'Result'-runSymbolic' :: SBVRunMode -> Symbolic a -> IO (a, Result)-runSymbolic' currentRunMode (Symbolic c) = do+runSymbolic :: SBVRunMode -> Symbolic a -> IO (a, Result)+runSymbolic currentRunMode (Symbolic c) = do+   currTime  <- getCurrentTime+   rm        <- newIORef currentRunMode    ctr       <- newIORef (-2) -- start from -2; False and True will always occupy the first two elements    cInfo     <- newIORef []    pgm       <- newIORef (SBVPgm S.empty)@@ -808,15 +888,15 @@    usedKinds <- newIORef Set.empty    usedLbls  <- newIORef Set.empty    cstrs     <- newIORef []-   tacs      <- newIORef []+   smtOpts   <- newIORef []    optGoals  <- newIORef []    asserts   <- newIORef []-   rGen      <- case currentRunMode of-                  Concrete g -> newIORef g-                  _          -> newStdGen >>= newIORef-   let st = State { runMode      = currentRunMode+   istate    <- newIORef =<< newIncState+   qstate    <- newIORef Nothing+   let st = State { runMode      = rm+                  , startTime    = currTime                   , pathCond     = SVal KBool (Left trueCW)-                  , rStdGen      = rGen+                  , rIncState    = istate                   , rCInfo       = cInfo                   , rctr         = ctr                   , rUsedKinds   = usedKinds@@ -834,47 +914,58 @@                   , rSWCache     = swCache                   , rAICache     = aiCache                   , rConstraints = cstrs-                  , rTacs        = tacs+                  , rSMTOptions  = smtOpts                   , rOptGoals    = optGoals                   , rAsserts     = asserts+                  , queryState   = qstate                   }    _ <- newConst st falseCW -- s(-2) == falseSW    _ <- newConst st trueCW  -- s(-1) == trueSW    r <- runReaderT c st    res <- extractSymbolicSimulationState st++   -- Clean-up after ourselves+   qs <- readIORef qstate+   case qs of+     Nothing                         -> return ()+     Just QueryState{queryTerminate} -> queryTerminate+    return (r, res) --- | Grab the program from a running symbolic simulation state. This is useful for internal purposes, for--- instance when implementing 'sBranch'.+-- | Grab the program from a running symbolic simulation state. extractSymbolicSimulationState :: State -> IO Result extractSymbolicSimulationState st@State{ spgm=pgm, rinps=inps, routs=outs, rtblMap=tables, rArrayMap=arrays, rUIMap=uis, raxioms=axioms                                        , rAsserts=asserts, rUsedKinds=usedKinds, rCgMap=cgs, rCInfo=cInfo, rConstraints=cstrs-                                       , rTacs=tacs, rOptGoals=optGoals } = do+                                       } = do    SBVPgm rpgm  <- readIORef pgm-   inpsO <- reverse `fmap` readIORef inps-   outsO <- reverse `fmap` readIORef outs+   inpsO <- reverse <$> readIORef inps+   outsO <- reverse <$> readIORef outs    let swap  (a, b)              = (b, a)        swapc ((_, a), b)         = (b, a)        cmp   (a, _) (b, _)       = a `compare` b        arrange (i, (at, rt, es)) = ((i, at, rt), es)-   cnsts <- (sortBy cmp . map swapc . Map.toList) `fmap` readIORef (rconstMap st)-   tbls  <- (map arrange . sortBy cmp . map swap . Map.toList) `fmap` readIORef tables-   arrs  <- IMap.toAscList `fmap` readIORef arrays-   unint <- Map.toList `fmap` readIORef uis-   axs   <- reverse `fmap` readIORef axioms+   cnsts <- (sortBy cmp . map swapc . Map.toList) <$> readIORef (rconstMap st)+   tbls  <- (map arrange . sortBy cmp . map swap . Map.toList) <$> readIORef tables+   arrs  <- IMap.toAscList <$> readIORef arrays+   unint <- Map.toList <$> readIORef uis+   axs   <- reverse <$> readIORef axioms    knds  <- readIORef usedKinds-   cgMap <- Map.toList `fmap` readIORef cgs-   traceVals  <- reverse `fmap` readIORef cInfo-   extraCstrs <- reverse `fmap` readIORef cstrs-   tactics    <- reverse `fmap` readIORef tacs-   goals      <- reverse `fmap` readIORef optGoals-   assertions <- reverse `fmap` readIORef asserts-   return $ Result knds traceVals cgMap inpsO cnsts tbls arrs unint axs (SBVPgm rpgm) extraCstrs tactics goals assertions outsO+   cgMap <- Map.toList <$> readIORef cgs+   traceVals  <- reverse <$> readIORef cInfo+   extraCstrs <- reverse <$> readIORef cstrs+   assertions <- reverse <$> readIORef asserts+   return $ Result knds traceVals cgMap inpsO cnsts tbls arrs unint axs (SBVPgm rpgm) extraCstrs assertions outsO +-- | Add a new option+addNewSMTOption :: SMTOption -> Symbolic ()+addNewSMTOption o =  do st <- ask+                        liftIO $ modifyState st rSMTOptions (o:) (return ())+ -- | Handling constraints imposeConstraint :: Maybe String -> SVal -> Symbolic () imposeConstraint mbNm c = do st <- ask-                             case runMode st of+                             rm <- liftIO $ readIORef (runMode st)+                             case rm of                                CodeGen -> error "SBV: constraints are not allowed in code-generation"                                _       -> do () <- case mbNm of                                                      Nothing -> return ()@@ -884,56 +975,30 @@ -- | Require a boolean condition to be true in the state. Only used for internal purposes. internalConstraint :: State -> Maybe String -> SVal -> IO () internalConstraint st mbNm b = do v <- svToSW st b-                                  modifyIORef (rConstraints st) ((mbNm, v):)---- | Add a tactic-addSValTactic :: Tactic SVal -> Symbolic ()-addSValTactic tac = do st <- ask-                       let walk (CaseSplit b cs)       = let app (nm, v, ts) = do ts' <- mapM walk ts-                                                                                  v' <- svToSW st v-                                                                                  return (nm, v', ts')-                                                         in CaseSplit b `fmap` mapM app cs-                           walk ParallelCase           = return   ParallelCase-                           walk (CheckCaseVacuity b)   = return $ CheckCaseVacuity b-                           walk (StopAfter i)          = return $ StopAfter  i-                           walk (CheckConstrVacuity b) = return $ CheckConstrVacuity b-                           walk (CheckUsing s)         = return $ CheckUsing s-                           walk (UseLogic   l)         = return $ UseLogic   l-                           walk (UseSolver  s)         = return $ UseSolver  s-                           walk (OptimizePriority s)   = return $ OptimizePriority s-                       tac' <- liftIO $ walk tac-                       liftIO $ modifyIORef (rTacs st) (tac':)+                                  modifyState st rConstraints ((mbNm, v):)+                                            $ noInteractive [ "Adding an internal constraint:"+                                                            , "  Named: " ++ fromMaybe "<unnamed>" mbNm+                                                            ]  -- | Add an optimization goal addSValOptGoal :: Objective SVal -> Symbolic () addSValOptGoal obj = do st <- ask                          -- create the tracking variable here for the metric-                        let mkGoal nm orig = do origSW  <- liftIO $ svToSW st orig-                                                track   <- svMkSymVar (Just EX) (kindOf orig) (Just nm)-                                                trackSW <- liftIO $ svToSW st track-                                                return (origSW, trackSW)+                        let mkGoal nm orig = liftIO $ do origSW  <- svToSW st orig+                                                         track   <- svMkSymVar (Just EX) (kindOf orig) (Just nm) st+                                                         trackSW <- svToSW st track+                                                         return (origSW, trackSW) -                        let walk (Minimize   nm v)     = Minimize nm              `fmap` mkGoal nm v-                            walk (Maximize   nm v)     = Maximize nm              `fmap` mkGoal nm v-                            walk (AssertSoft nm v mbP) = flip (AssertSoft nm) mbP `fmap` mkGoal nm v+                        let walk (Minimize   nm v)     = Minimize nm              <$> mkGoal nm v+                            walk (Maximize   nm v)     = Maximize nm              <$> mkGoal nm v+                            walk (AssertSoft nm v mbP) = flip (AssertSoft nm) mbP <$> mkGoal nm v                          obj' <- walk obj-                        liftIO $ modifyIORef (rOptGoals st) (obj' :)---- | Add a constraint with a given probability, and possibly a name-addSValConstraint :: Maybe String -> Maybe Double -> SVal -> SVal -> Symbolic ()-addSValConstraint mbNm Nothing  c _  = imposeConstraint mbNm c-addSValConstraint mbNm (Just t) c c'-  | t < 0 || t > 1-  = error $ "SBV: pConstrain: Invalid probability threshold: " ++ show t ++ ", must be in [0, 1]."-  | True-  = do st <- ask-       unless (isConcreteMode st) $ error "SBV: pConstrain only allowed in 'genTest' or 'quickCheck' contexts."-       case () of-         () | t > 0 && t < 1 -> liftIO (throwDice st) >>= \d -> imposeConstraint mbNm (if d <= t then c else c')-            | t > 0          -> imposeConstraint mbNm c-            | True           -> imposeConstraint mbNm c'+                        liftIO $ modifyState st rOptGoals (obj' :)+                                           $ noInteractive [ "Adding an optimization objective:"+                                                           , "  Objective: " ++ show obj+                                                           ]  -- | Mark an interim result as an output. Useful when constructing Symbolic programs -- that return multiple values, or when the result is programmatically computed.@@ -941,11 +1006,11 @@ outputSVal (SVal _ (Left c)) = do   st <- ask   sw <- liftIO $ newConst st c-  liftIO $ modifyIORef (routs st) (sw:)+  liftIO $ modifyState st routs (sw:) (return ()) outputSVal (SVal _ (Right f)) = do   st <- ask   sw <- liftIO $ uncache f st-  liftIO $ modifyIORef (routs st) (sw:)+  liftIO $ modifyState st routs (sw:) (return ())  --------------------------------------------------------------------------------- -- * Symbolic Arrays@@ -973,16 +1038,6 @@                   i   <- svToSW st a                   newExpr st bk (SBVApp (ArrRead arr) [i]) --- | Reset all the elements of the array to the value @b@-resetSArr :: SArr -> SVal -> SArr-resetSArr (SArr ainfo f) b = SArr ainfo $ cache g-  where g st = do amap <- readIORef (rArrayMap st)-                  val <- svToSW st b-                  i <- uncacheAI f st-                  let j = IMap.size amap-                  j `seq` modifyIORef (rArrayMap st) (IMap.insert j ("array_" ++ show j, ainfo, ArrayReset i val))-                  return j- -- | Update the element at @a@ to be @b@ writeSArr :: SArr -> SVal -> SVal -> SArr writeSArr (SArr ainfo f) a b = SArr ainfo $ cache g@@ -991,7 +1046,10 @@                   val  <- svToSW st b                   amap <- readIORef (rArrayMap st)                   let j = IMap.size amap-                  j `seq` modifyIORef (rArrayMap st) (IMap.insert j ("array_" ++ show j, ainfo, ArrayMutate arr addr val))+                  j `seq` modifyState st rArrayMap (IMap.insert j ("array_" ++ show j, ainfo, ArrayMutate arr addr val))+                                      (noInteractive [ "An array update:"+                                                     , "  Array info: " ++ show ainfo+                                                     ])                   return j  -- | Merge two given arrays on the symbolic condition@@ -1004,20 +1062,25 @@                   ts <- svToSW st t                   amap <- readIORef (rArrayMap st)                   let k = IMap.size amap-                  k `seq` modifyIORef (rArrayMap st) (IMap.insert k ("array_" ++ show k, ainfo, ArrayMerge ts ai bi))+                  k `seq` modifyState st rArrayMap (IMap.insert k ("array_" ++ show k, ainfo, ArrayMerge ts ai bi))+                                      (noInteractive [ "An array merge:"+                                                     , "  Array info: " ++ show ainfo+                                                     ])                   return k  -- | Create a named new array, with an optional initial value-newSArr :: (Kind, Kind) -> (Int -> String) -> Maybe SVal -> Symbolic SArr-newSArr ainfo mkNm mbInit = do+newSArr :: (Kind, Kind) -> (Int -> String) -> Symbolic SArr+newSArr ainfo mkNm = do     st <- ask     amap <- liftIO $ readIORef $ rArrayMap st     let i = IMap.size amap         nm = mkNm i-    actx <- liftIO $ case mbInit of-                       Nothing   -> return $ ArrayFree Nothing-                       Just ival -> svToSW st ival >>= \sw -> return $ ArrayFree (Just sw)-    liftIO $ modifyIORef (rArrayMap st) (IMap.insert i (nm, ainfo, actx))+    actx <- liftIO $ return ArrayFree+    liftIO $ modifyState st rArrayMap (IMap.insert i (nm, ainfo, actx))+                       $ noInteractive [ "A new array creation:"+                                       , "  Array info: " ++ show ainfo+                                       , "  Named     : " ++ show nm+                                       ]     return $ SArr ainfo $ cache $ const $ return i  -- | Compare two arrays for equality@@ -1070,7 +1133,7 @@         case maybe Nothing (sn `lookup`) (h `IMap.lookup` stored) of           Just r  -> return r           Nothing -> do r <- f st-                        r `seq` modifyIORef rCache (IMap.insertWith (++) h [(sn, r)])+                        r `seq` R.modifyIORef' rCache (IMap.insertWith (++) h [(sn, r)])                         return r  -- | Representation of SMTLib Program versions. As of June 2015, we're dropping support@@ -1108,12 +1171,11 @@ #endif  instance NFData Result where-  rnf (Result kindInfo qcInfo cgs inps consts tbls arrs uis axs pgm cstr tacs goals asserts outs)+  rnf (Result kindInfo qcInfo cgs inps consts tbls arrs uis axs pgm cstr asserts outs)         = rnf kindInfo `seq` rnf qcInfo  `seq` rnf cgs  `seq` rnf inps                        `seq` rnf consts  `seq` rnf tbls `seq` rnf arrs                        `seq` rnf uis     `seq` rnf axs  `seq` rnf pgm-                       `seq` rnf cstr    `seq` rnf tacs `seq` rnf goals-                       `seq` rnf asserts `seq` rnf outs+                       `seq` rnf cstr    `seq` rnf asserts `seq` rnf outs instance NFData Kind         where rnf a          = seq a () instance NFData ArrayContext where rnf a          = seq a () instance NFData SW           where rnf a          = seq a ()@@ -1125,12 +1187,11 @@ instance NFData SVal         where rnf (SVal x y) = rnf x `seq` rnf y `seq` ()  instance NFData SMTResult where-  rnf (Unsatisfiable _ uc) = rnf uc `seq` ()+  rnf Unsatisfiable{}      = ()   rnf (Satisfiable _   xs) = rnf xs `seq` ()   rnf (SatExtField _   xs) = rnf xs `seq` ()   rnf (Unknown _       xs) = rnf xs `seq` ()   rnf (ProofError _    xs) = rnf xs `seq` ()-  rnf TimeOut{}            = ()  instance NFData SMTModel where   rnf (SMTModel objs assocs) = rnf objs `seq` rnf assocs `seq` ()@@ -1138,72 +1199,18 @@ instance NFData SMTScript where   rnf (SMTScript b m) = rnf b `seq` rnf m `seq` () --- | SMT-Lib logics. If left unspecified SBV will pick the logic based on what it determines is needed. However, the--- user can override this choice using the 'useLogic' parameter to the configuration. This is especially handy if--- one is experimenting with custom logics that might be supported on new solvers. See <http://smtlib.cs.uiowa.edu/logics.shtml>--- for the official list.-data SMTLibLogic-  = AUFLIA    -- ^ Formulas over the theory of linear integer arithmetic and arrays extended with free sort and function symbols but restricted to arrays with integer indices and values.-  | AUFLIRA   -- ^ Linear formulas with free sort and function symbols over one- and two-dimentional arrays of integer index and real value.-  | AUFNIRA   -- ^ Formulas with free function and predicate symbols over a theory of arrays of arrays of integer index and real value.-  | LRA       -- ^ Linear formulas in linear real arithmetic.-  | QF_ABV    -- ^ Quantifier-free formulas over the theory of bitvectors and bitvector arrays.-  | QF_AUFBV  -- ^ Quantifier-free formulas over the theory of bitvectors and bitvector arrays extended with free sort and function symbols.-  | QF_AUFLIA -- ^ Quantifier-free linear formulas over the theory of integer arrays extended with free sort and function symbols.-  | QF_AX     -- ^ Quantifier-free formulas over the theory of arrays with extensionality.-  | QF_BV     -- ^ Quantifier-free formulas over the theory of fixed-size bitvectors.-  | QF_IDL    -- ^ Difference Logic over the integers. Boolean combinations of inequations of the form x - y < b where x and y are integer variables and b is an integer constant.-  | QF_LIA    -- ^ Unquantified linear integer arithmetic. In essence, Boolean combinations of inequations between linear polynomials over integer variables.-  | QF_LRA    -- ^ Unquantified linear real arithmetic. In essence, Boolean combinations of inequations between linear polynomials over real variables.-  | QF_NIA    -- ^ Quantifier-free integer arithmetic.-  | QF_NRA    -- ^ Quantifier-free real arithmetic.-  | QF_RDL    -- ^ Difference Logic over the reals. In essence, Boolean combinations of inequations of the form x - y < b where x and y are real variables and b is a rational constant.-  | QF_UF     -- ^ Unquantified formulas built over a signature of uninterpreted (i.e., free) sort and function symbols.-  | QF_UFBV   -- ^ Unquantified formulas over bitvectors with uninterpreted sort function and symbols.-  | QF_UFIDL  -- ^ Difference Logic over the integers (in essence) but with uninterpreted sort and function symbols.-  | QF_UFLIA  -- ^ Unquantified linear integer arithmetic with uninterpreted sort and function symbols.-  | QF_UFLRA  -- ^ Unquantified linear real arithmetic with uninterpreted sort and function symbols.-  | QF_UFNRA  -- ^ Unquantified non-linear real arithmetic with uninterpreted sort and function symbols.-  | QF_UFNIRA -- ^ Unquantified non-linear real integer arithmetic with uninterpreted sort and function symbols.-  | UFLRA     -- ^ Linear real arithmetic with uninterpreted sort and function symbols.-  | UFNIA     -- ^ Non-linear integer arithmetic with uninterpreted sort and function symbols.-  | QF_FPBV   -- ^ Quantifier-free formulas over the theory of floating point numbers, arrays, and bit-vectors.-  | QF_FP     -- ^ Quantifier-free formulas over the theory of floating point numbers.-  | QF_FD     -- ^ Quantifier-free finite domains-  deriving Show---- | NFData instance for SMTLibLogic-instance NFData SMTLibLogic where-   rnf x = x `seq` ()---- | Chosen logic for the solver-data Logic = PredefinedLogic SMTLibLogic  -- ^ Use one of the logics as defined by the standard-           | CustomLogic     String       -- ^ Use this name for the logic--instance Show Logic where-  show (PredefinedLogic l) = show l-  show (CustomLogic     s) = s---- | NFData instance for Logic-instance NFData Logic where-  rnf (PredefinedLogic l) = rnf l-  rnf (CustomLogic s)     = rnf s `seq` ()- -- | Translation tricks needed for specific capabilities afforded by each solver data SolverCapabilities = SolverCapabilities {-         capSolverName              :: String               -- ^ Name of the solver-       , mbDefaultLogic             :: Bool -> Maybe String -- ^ set-logic string to use in case not automatically determined (if any). If Bool is True, then reals are present.-       , supportsDefineFun          :: Bool                 -- ^ Does the solver understand SMT-Lib2 define-funs?-       , supportsProduceModels      :: Bool                 -- ^ Does the solver understand produce-models option setting-       , supportsQuantifiers        :: Bool                 -- ^ Does the solver understand SMT-Lib2 style quantifiers?-       , supportsUninterpretedSorts :: Bool                 -- ^ Does the solver understand SMT-Lib2 style uninterpreted-sorts-       , supportsUnboundedInts      :: Bool                 -- ^ Does the solver support unbounded integers?-       , supportsReals              :: Bool                 -- ^ Does the solver support reals?-       , supportsFloats             :: Bool                 -- ^ Does the solver support single-precision floating point numbers?-       , supportsDoubles            :: Bool                 -- ^ Does the solver support double-precision floating point numbers?-       , supportsOptimization       :: Bool                 -- ^ Does the solver support optimization routines?-       , supportsPseudoBooleans     :: Bool                 -- ^ Does the solver support pseudo-boolean operations?-       , supportsUnsatCores         :: Bool                 -- ^ Does the solver support extraction of unsat-cores?+         supportsQuantifiers        :: Bool    -- ^ Support for SMT-Lib2 style quantifiers?+       , supportsUninterpretedSorts :: Bool    -- ^ Support for SMT-Lib2 style uninterpreted-sorts+       , supportsUnboundedInts      :: Bool    -- ^ Support for unbounded integers?+       , supportsReals              :: Bool    -- ^ Support for reals?+       , supportsApproxReals        :: Bool    -- ^ Supports printing of approximations of reals?+       , supportsIEEE754            :: Bool    -- ^ Support for floating point numbers?+       , supportsOptimization       :: Bool    -- ^ Support for optimization routines?+       , supportsPseudoBooleans     :: Bool    -- ^ Support for pseudo-boolean operations?+       , supportsCustomQueries      :: Bool    -- ^ Support for interactive queries per SMT-Lib?+       , supportsGlobalDecls        :: Bool    -- ^ Support for global decls, needed for push-pop.        }  -- | Rounding mode to be used for the IEEE floating-point operations.@@ -1241,31 +1248,26 @@ -- The 'printBase' field can be used to print numbers in base 2, 10, or 16. If base 2 or 16 is used, then floating-point values will -- be printed in their internal memory-layout format as well, which can come in handy for bit-precise analysis. data SMTConfig = SMTConfig {-         verbose        :: Bool           -- ^ Debug mode-       , timing         :: Timing         -- ^ Print timing information on how long different phases took (construction, solving, etc.)-       , sBranchTimeOut :: Maybe Int      -- ^ How much time to give to the solver for each call of 'sBranch' check. (In seconds. Default: No limit.)-       , timeOut        :: Maybe Int      -- ^ How much time to give to the solver. (In seconds. Default: No limit.)-       , printBase      :: Int            -- ^ Print integral literals in this base (2, 10, and 16 are supported.)-       , printRealPrec  :: Int            -- ^ Print algebraic real values with this precision. (SReal, default: 16)-       , solverTweaks   :: [String]       -- ^ Additional lines of script to give to the solver (user specified)-       , optimizeArgs   :: [String]       -- ^ Additional commands to pass before check-sat is issued-       , satCmd         :: String         -- ^ Usually "(check-sat)". However, users might tweak it based on solver characteristics.-       , isNonModelVar  :: String -> Bool -- ^ When constructing a model, ignore variables whose name satisfy this predicate. (Default: (const False), i.e., don't ignore anything)-       , smtFile        :: Maybe FilePath -- ^ If Just, the generated SMT script will be put in this file (for debugging purposes mostly)-       , smtLibVersion  :: SMTLibVersion  -- ^ What version of SMT-lib we use for the tool-       , solver         :: SMTSolver      -- ^ The actual SMT solver.-       , roundingMode   :: RoundingMode   -- ^ Rounding mode to use for floating-point conversions-       , useLogic       :: Maybe Logic    -- ^ If Nothing, pick automatically. Otherwise, either use the given one, or use the custom string.-       , getUnsatCore   :: Bool           -- ^ Should we query unsat-core?+         verbose             :: Bool           -- ^ Debug mode+       , timing              :: Timing         -- ^ Print timing information on how long different phases took (construction, solving, etc.)+       , printBase           :: Int            -- ^ Print integral literals in this base (2, 10, and 16 are supported.)+       , printRealPrec       :: Int            -- ^ Print algebraic real values with this precision. (SReal, default: 16)+       , satCmd              :: String         -- ^ Usually "(check-sat)". However, users might tweak it based on solver characteristics.+       , allSatMaxModelCount :: Maybe Int      -- ^ In an allSat call, return at most this many models. If nothing, return all.+       , isNonModelVar       :: String -> Bool -- ^ When constructing a model, ignore variables whose name satisfy this predicate. (Default: (const False), i.e., don't ignore anything)+       , transcript          :: Maybe FilePath -- ^ If Just, the entire interaction will be recorded as a playable file (for debugging purposes mostly)+       , smtLibVersion       :: SMTLibVersion  -- ^ What version of SMT-lib we use for the tool+       , solver              :: SMTSolver      -- ^ The actual SMT solver.+       , roundingMode        :: RoundingMode   -- ^ Rounding mode to use for floating-point conversions+       , solverSetOptions    :: [SMTOption]    -- ^ Options to set as we start the solver+       , ignoreExitCode      :: Bool           -- ^ If true, we shall ignore the exit code upon exit. Otherwise we require ExitSuccess.+       , redirectVerbose     :: Maybe FilePath -- ^ Redirect the verbose output to this file if given. If Nothing, stdout is implied.        }  -- We're just seq'ing top-level here, it shouldn't really matter. (i.e., no need to go deeper.) instance NFData SMTConfig where   rnf SMTConfig{} = () -instance Show SMTConfig where-  show = show . solver- -- | A model, as returned by a solver data SMTModel = SMTModel {         modelObjectives :: [(String, GeneralizedCW)]  -- ^ Mapping of symbolic values to objective values.@@ -1278,27 +1280,25 @@ -- and build layers of results, if needed. For ordinary uses of the library, -- this type should not be needed, instead use the accessor functions on -- it. (Custom Show instances and model extractors.)-data SMTResult = Unsatisfiable SMTConfig (Maybe [String]) -- ^ Unsatisfiable, with unsat-core if requested-               | Satisfiable   SMTConfig SMTModel         -- ^ Satisfiable with model-               | SatExtField   SMTConfig SMTModel         -- ^ Prover returned a model, but in an extension field containing Infinite/epsilon-               | Unknown       SMTConfig SMTModel         -- ^ Prover returned unknown, with a potential (possibly bogus) model-               | ProofError    SMTConfig [String]         -- ^ Prover errored out-               | TimeOut       SMTConfig                  -- ^ Computation timed out (see the 'timeout' combinator)+data SMTResult = Unsatisfiable SMTConfig           -- ^ Unsatisfiable+               | Satisfiable   SMTConfig SMTModel  -- ^ Satisfiable with model+               | SatExtField   SMTConfig SMTModel  -- ^ Prover returned a model, but in an extension field containing Infinite/epsilon+               | Unknown       SMTConfig String    -- ^ Prover returned unknown, with the given reason+               | ProofError    SMTConfig [String]  -- ^ Prover errored out  -- | A script, to be passed to the solver. data SMTScript = SMTScript {-          scriptBody  :: String        -- ^ Initial feed-        , scriptModel :: Maybe String  -- ^ Optional continuation script, if the result is sat+          scriptBody  :: String   -- ^ Initial feed+        , scriptModel :: [String] -- ^ Continuation script, to extract results         }  -- | An SMT engine-type SMTEngine = SMTConfig                     -- ^ current configuration-               -> Bool                         -- ^ is sat?-               -> Maybe (OptimizeStyle, Int)   -- ^ if optimizing, the style and #of objectives-               -> [(Quantifier, NamedSymVar)]  -- ^ quantified inputs-               -> [Either SW (SW, [SW])]       -- ^ skolem map-               -> String                       -- ^ program-               -> IO [SMTResult]+type SMTEngine =  forall res.+                  SMTConfig         -- ^ current configuration+               -> State             -- ^ the state in which to run the engine+               -> String            -- ^ program+               -> (State -> IO res) -- ^ continuation+               -> IO res  -- | Solvers that SBV is aware of data Solver = Z3@@ -1311,15 +1311,12 @@  -- | An SMT solver data SMTSolver = SMTSolver {-         name           :: Solver             -- ^ The solver in use-       , executable     :: String             -- ^ The path to its executable-       , options        :: [String]           -- ^ Options to provide to the solver-       , engine         :: SMTEngine          -- ^ The solver engine, responsible for interpreting solver output-       , capabilities   :: SolverCapabilities -- ^ Various capabilities of the solver+         name           :: Solver                -- ^ The solver in use+       , executable     :: String                -- ^ The path to its executable+       , options        :: SMTConfig -> [String] -- ^ Options to provide to the solver+       , engine         :: SMTEngine             -- ^ The solver engine, responsible for interpreting solver output+       , capabilities   :: SolverCapabilities    -- ^ Various capabilities of the solver        }--instance Show SMTSolver where-   show = show . name  {-# ANN type FPOp ("HLint: ignore Use camelCase" :: String) #-} {-# ANN type PBOp ("HLint: ignore Use camelCase" :: String) #-}
Data/SBV/Dynamic.hs view
@@ -20,8 +20,7 @@     SVal   , HasKind(..), Kind(..), CW(..), CWVal(..), cwToBool   -- *** Arrays of symbolic values-  , SArr-  , readSArr, resetSArr, writeSArr, mergeSArr, newSArr, eqSArr+  , SArr, readSArr, writeSArr, mergeSArr, newSArr, eqSArr    -- ** Creating a symbolic variable   , Symbolic@@ -44,7 +43,7 @@   , svLessThan, svGreaterThan, svLessEq, svGreaterEq   -- *** Arithmetic operations   , svPlus, svTimes, svMinus, svUNeg, svAbs-  , svDivide, svQuot, svRem, svExp+  , svDivide, svQuot, svRem, svQuotRem, svExp   , svAddConstant, svIncrement, svDecrement   -- *** Logical operations   , svAnd, svOr, svXOr, svNot@@ -65,7 +64,6 @@   , svBlastLE, svBlastBE   -- ** Conditionals: Mergeable values   , svIte, svLazyIte, svSymbolicMerge-  , svIsSatisfiableInCurrentPath   -- * Uninterpreted sorts, constants, and functions   , svUninterpreted   -- * Properties, proofs, and satisfiability@@ -86,9 +84,9 @@   , ThmResult(..), SatResult(..), AllSatResult(..), SafeResult(..), OptimizeResult(..), SMTResult(..)    -- ** Programmable model extraction-  , genParse, getModel, getModelDictionary+  , genParse, getModelAssignment, getModelDictionary   -- * SMT Interface: Configurations and solvers-  , SMTConfig(..), SMTLibVersion(..), SMTLibLogic(..), Logic(..), Solver(..), SMTSolver(..), boolector, cvc4, yices, z3, mathSAT, abc, defaultSolverConfig, sbvCurrentSolver, defaultSMTCfg, sbvCheckSolverInstallation, sbvAvailableSolvers+  , SMTConfig(..), SMTLibVersion(..), Solver(..), SMTSolver(..), boolector, cvc4, yices, z3, mathSAT, abc, defaultSolverConfig, defaultSMTCfg, sbvCheckSolverInstallation, sbvAvailableSolvers    -- * Symbolic computations   , outputSVal@@ -118,7 +116,7 @@   , compileToC, compileToCLib    -- ** Compilation to SMTLib-  , compileToSMTLib, generateSMTBenchmarks+  , generateSMTBenchmark   ) where  import Data.Map (Map)@@ -140,17 +138,15 @@  import Data.SBV.Provers.Prover (boolector, cvc4, yices, z3, mathSAT, abc, defaultSMTCfg) import Data.SBV.SMT.SMT        (ThmResult(..), SatResult(..), SafeResult(..), OptimizeResult(..), AllSatResult(..), genParse)-import Data.SBV                (sbvCurrentSolver, sbvCheckSolverInstallation, defaultSolverConfig, sbvAvailableSolvers)+import Data.SBV                (sbvCheckSolverInstallation, defaultSolverConfig, sbvAvailableSolvers)  import qualified Data.SBV                as SBV (SBool, proveWithAll, proveWithAny, satWithAll, satWithAny) import qualified Data.SBV.Core.Data      as SBV (SBV(..))-import qualified Data.SBV.Core.Model     as SBV (isSatisfiableInCurrentPath, sbvQuickCheck)-import qualified Data.SBV.Provers.Prover as SBV (proveWith, satWith, safeWith, allSatWith, compileToSMTLib, generateSMTBenchmarks)-import qualified Data.SBV.SMT.SMT        as SBV (Modelable(getModel, getModelDictionary))+import qualified Data.SBV.Core.Model     as SBV (sbvQuickCheck)+import qualified Data.SBV.Provers.Prover as SBV (proveWith, satWith, safeWith, allSatWith, generateSMTBenchmark)+import qualified Data.SBV.SMT.SMT        as SBV (Modelable(getModelAssignment, getModelDictionary)) --- | Reduce a condition (i.e., try to concretize it) under the given path-svIsSatisfiableInCurrentPath :: SVal -> Symbolic (Maybe SatResult)-svIsSatisfiableInCurrentPath = SBV.isSatisfiableInCurrentPath . toSBool+import Data.Time (NominalDiffTime)  -- | Dynamic variant of quick-check svQuickCheck :: Symbolic SVal -> IO Bool@@ -159,28 +155,11 @@ toSBool :: SVal -> SBV.SBool toSBool = SBV.SBV --- | Compiles to SMT-Lib and returns the resulting program as a string. Useful for saving--- the result to a file for off-line analysis, for instance if you have an SMT solver that's not natively--- supported out-of-the box by the SBV library. It takes two arguments:------    * version: The SMTLib-version to produce. Note that we currently only support SMTLib2.------    * isSat  : If 'True', will translate it as a SAT query, i.e., in the positive. If 'False', will---               translate as a PROVE query, i.e., it will negate the result. (In this case, the check-sat---               call to the SMT solver will produce UNSAT if the input is a theorem, as usual.)-compileToSMTLib :: SMTLibVersion   -- ^ If True, output SMT-Lib2, otherwise SMT-Lib1-                -> Bool            -- ^ If True, translate directly, otherwise negate the goal. (Use True for SAT queries, False for PROVE queries.)-                -> Symbolic SVal-                -> IO String-compileToSMTLib version isSat s = SBV.compileToSMTLib version isSat (fmap toSBool s)---- | Create both SMT-Lib1 and SMT-Lib2 benchmarks. The first argument is the basename of the file,--- SMT-Lib1 version will be written with suffix ".smt1" and SMT-Lib2 version will be written with--- suffix ".smt2". 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. (See the second boolean argument to--- 'compileToSMTLib' for details.)-generateSMTBenchmarks :: Bool -> FilePath -> Symbolic SVal -> IO ()-generateSMTBenchmarks isSat f s = SBV.generateSMTBenchmarks isSat f (fmap toSBool s)+-- | Create SMT-Lib benchmarks. The first argument is the basename of the file, we will automatically+-- add ".smt2" per SMT-Lib2 convention. 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 :: Bool -> Symbolic SVal -> IO String+generateSMTBenchmark isSat s = SBV.generateSMTBenchmark isSat (fmap toSBool s)  -- | Proves the predicate using the given SMT-solver proveWith :: SMTConfig -> Symbolic SVal -> IO ThmResult@@ -200,31 +179,31 @@  -- | Prove a property with multiple solvers, running them in separate threads. The -- results will be returned in the order produced.-proveWithAll :: [SMTConfig] -> Symbolic SVal -> IO [(Solver, ThmResult)]+proveWithAll :: [SMTConfig] -> Symbolic SVal -> IO [(Solver, NominalDiffTime, ThmResult)] proveWithAll cfgs s = SBV.proveWithAll cfgs (fmap toSBool s)  -- | 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.-proveWithAny :: [SMTConfig] -> Symbolic SVal -> IO (Solver, ThmResult)+proveWithAny :: [SMTConfig] -> Symbolic SVal -> IO (Solver, NominalDiffTime, ThmResult) proveWithAny cfgs s = SBV.proveWithAny cfgs (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.-satWithAll :: [SMTConfig] -> Symbolic SVal -> IO [(Solver, SatResult)]+satWithAll :: [SMTConfig] -> Symbolic SVal -> IO [(Solver, NominalDiffTime, SatResult)] satWithAll cfgs s = SBV.satWithAll cfgs (fmap toSBool s)  -- | 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.-satWithAny :: [SMTConfig] -> Symbolic SVal -> IO (Solver, SatResult)+satWithAny :: [SMTConfig] -> Symbolic SVal -> IO (Solver, NominalDiffTime, SatResult) satWithAny cfgs s = SBV.satWithAny cfgs (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.)-getModel :: SMTResult -> Either String (Bool, [CW])-getModel = SBV.getModel+getModelAssignment :: SMTResult -> Either String (Bool, [CW])+getModelAssignment = SBV.getModelAssignment  -- | Extract a model dictionary. Extract a dictionary mapping the variables to -- their respective values as returned by the SMT solver. Also see `getModelDictionaries`.
Data/SBV/Examples/BitPrecise/Legato.hs view
@@ -40,6 +40,7 @@  import Data.SBV import Data.SBV.Tools.CodeGen+import Data.SBV.Internals (Timing(PrintTiming))  import GHC.Generics (Generic) @@ -247,7 +248,6 @@ -- | Helper synonym for capturing relevant bits of Mostek type InitVals = ( Value      -- Content of Register X                 , Value      -- Content of Register A-                , Value      -- Initial contents of memory                 , Bit        -- Value of FlagC                 , Bit        -- Value of FlagZ                 )@@ -255,10 +255,10 @@ -- | Create an instance of the Mostek machine, initialized by the memory and the relevant -- values of the registers and the flags initMachine :: Memory -> InitVals -> Mostek-initMachine mem (rx, ra, mc, fc, fz) = Mostek { memory    = resetArray mem mc-                                              , registers = array (minBound, maxBound) [(RegX, rx),  (RegA, ra)]-                                              , flags     = array (minBound, maxBound) [(FlagC, fc), (FlagZ, fz)]-                                              }+initMachine mem (rx, ra, fc, fz) = Mostek { memory    = mem+                                          , registers = array (minBound, maxBound) [(RegX, rx),  (RegA, ra)]+                                          , flags     = array (minBound, maxBound) [(FlagC, fc), (FlagZ, fz)]+                                          }  -- | The correctness theorem. For all possible memory configurations, the factors (@x@ and @y@ below), the location -- of the low-byte result and the initial-values of registers and the flags, this function will return True only if@@ -284,13 +284,28 @@ -- type Model = SArray  -- | The correctness theorem.---   On a decent MacBook Pro, this proof takes about 3 minutes with the 'SFunArray' memory model---   and about 30 minutes with the 'SArray' model, using yices as the SMT solver+-- On a 2011 MacBook, this proof takes about 1 minute 45 seconds with the 'SFunArray' memory model+-- using boolector as the solver. correctnessTheorem :: IO ThmResult-correctnessTheorem = proveWith yices{timing = PrintTiming} $-    forAll ["mem", "addrX", "x", "addrY", "y", "addrLow", "regX", "regA", "memVals", "flagC", "flagZ"]-           legatoIsCorrect+correctnessTheorem = proveWith boolector{timing = PrintTiming} $ do+        let mem = mkSFunArray (const 0) +        addrX <- sWord32 "addrX"+        x     <- sWord8  "x"++        addrY <- sWord32 "addrY"+        y     <- sWord8  "y"++        addrLow <- sWord32 "addrLow"++        regX  <- sWord8 "regX"+        regA  <- sWord8 "regA"++        flagC <- sBool "flagC"+        flagZ <- sBool "flagZ"++        return $ legatoIsCorrect mem (addrX, x) (addrY, y) addrLow (regX, regA, flagC, flagZ)+ ------------------------------------------------------------------ -- * C Code generation ------------------------------------------------------------------@@ -300,7 +315,7 @@ legatoInC = compileToC Nothing "runLegato" $ do                 x <- cgInput "x"                 y <- cgInput "y"-                let (hi, lo) = runLegato (0, x) (1, y) 2 (initMachine (mkSFunArray (const 0)) (0, 0, 0, false, false))+                let (hi, lo) = runLegato (0, x) (1, y) 2 (initMachine (mkSFunArray (const 0)) (0, 0, false, false))                 cgOutput "hi" hi                 cgOutput "lo" lo
Data/SBV/Examples/BitPrecise/PrefixSum.hs view
@@ -18,7 +18,6 @@ module Data.SBV.Examples.BitPrecise.PrefixSum where  import Data.SBV-import Data.SBV.Internals (runSymbolic)  ---------------------------------------------------------------------- -- * Formalizing power-lists@@ -82,117 +81,17 @@         return $ ps zf args .== lf zf args  -- | Proves Ladner-Fischer is equivalent to reference specification for addition.--- @0@ is the left-unit element, and we use a power-list of size @8@.+-- @0@ is the left-unit element, and we use a power-list of size @8@. We have:+--+-- >>> thm1+-- Q.E.D. thm1 :: IO ThmResult thm1 = prove $ flIsCorrect  8 (0, (+))  -- | Proves Ladner-Fischer is equivalent to reference specification for the function @max@.--- @0@ is the left-unit element, and we use a power-list of size @16@.+-- @0@ is the left-unit element, and we use a power-list of size @16@. We have:+--+-- >>> thm2+-- Q.E.D. thm2 :: IO ThmResult thm2 = prove $ flIsCorrect 16 (0, smax)--------------------------------------------------------------------------- * Inspecting symbolic traces--------------------------------------------------------------------------- | A symbolic trace can help illustrate the action of Ladner-Fischer. This--- generator produces the actions of Ladner-Fischer for addition, showing how--- the computation proceeds:------ >>> ladnerFischerTrace 8--- INPUTS---   s0 :: SWord8---   s1 :: SWord8---   s2 :: SWord8---   s3 :: SWord8---   s4 :: SWord8---   s5 :: SWord8---   s6 :: SWord8---   s7 :: SWord8--- CONSTANTS---   s_2 = False :: Bool---   s_1 = True :: Bool--- TABLES--- ARRAYS--- UNINTERPRETED CONSTANTS--- USER GIVEN CODE SEGMENTS--- AXIOMS--- TACTICS--- GOALS--- DEFINE---   s8 :: SWord8 = s0 + s1---   s9 :: SWord8 = s2 + s8---   s10 :: SWord8 = s2 + s3---   s11 :: SWord8 = s8 + s10---   s12 :: SWord8 = s4 + s11---   s13 :: SWord8 = s4 + s5---   s14 :: SWord8 = s11 + s13---   s15 :: SWord8 = s6 + s14---   s16 :: SWord8 = s6 + s7---   s17 :: SWord8 = s13 + s16---   s18 :: SWord8 = s11 + s17--- CONSTRAINTS--- ASSERTIONS--- OUTPUTS---   s0---   s8---   s9---   s11---   s12---   s14---   s15---   s18-ladnerFischerTrace :: Int -> IO ()-ladnerFischerTrace n = gen >>= print-  where gen = runSymbolic (True, defaultSMTCfg) $ do args :: [SWord8] <- mkForallVars n-                                                     mapM_ output $ lf (0, (+)) args---- | Trace generator for the reference spec. It clearly demonstrates that the reference--- implementation fewer operations, but is not parallelizable at all:------ >>> scanlTrace 8--- INPUTS---   s0 :: SWord8---   s1 :: SWord8---   s2 :: SWord8---   s3 :: SWord8---   s4 :: SWord8---   s5 :: SWord8---   s6 :: SWord8---   s7 :: SWord8--- CONSTANTS---   s_2 = False :: Bool---   s_1 = True :: Bool--- TABLES--- ARRAYS--- UNINTERPRETED CONSTANTS--- USER GIVEN CODE SEGMENTS--- AXIOMS--- TACTICS--- GOALS--- DEFINE---   s8 :: SWord8 = s0 + s1---   s9 :: SWord8 = s2 + s8---   s10 :: SWord8 = s3 + s9---   s11 :: SWord8 = s4 + s10---   s12 :: SWord8 = s5 + s11---   s13 :: SWord8 = s6 + s12---   s14 :: SWord8 = s7 + s13--- CONSTRAINTS--- ASSERTIONS--- OUTPUTS---   s0---   s8---   s9---   s10---   s11---   s12---   s13---   s14----scanlTrace :: Int -> IO ()-scanlTrace n = gen >>= print-  where gen = runSymbolic (True, defaultSMTCfg) $ do args :: [SWord8] <- mkForallVars n-                                                     mapM_ output $ ps (0, (+)) args--{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
Data/SBV/Examples/CodeGeneration/PopulationCount.hs view
@@ -64,10 +64,12 @@ -}  -- | States the correctness of faster population-count algorithm, with respect--- to the reference slow version. (We use yices here as it's quite fast for--- this problem. Z3 seems to take much longer.) We have:+-- to the reference slow version. Turns out Z3's default tactic is rather slow+-- for this one, but there's a magic incantation to make it go fast.+-- See <https://github.com/Z3Prover/z3/issues/1150> for details. ----- >>> proveWith yices fastPopCountIsCorrect+-- >>> let cmd = "(check-sat-using (then (using-params ackermannize_bv :div0_ackermann_limit 1000000) simplify bit-blast sat))"+-- >>> proveWith z3{satCmd = cmd} fastPopCountIsCorrect -- Q.E.D. fastPopCountIsCorrect :: SWord64 -> SBool fastPopCountIsCorrect x = popCountFast x .== popCountSlow x
Data/SBV/Examples/Crypto/AES.hs view
@@ -7,7 +7,7 @@ -- Stability   :  experimental -- -- An implementation of AES (Advanced Encryption Standard), using SBV.--- For details on AES, see FIPS-197: <http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf>.+-- For details on AES, see <http://en.wikipedia.org/wiki/Advanced_Encryption_Standard>. -- -- We do a T-box implementation, which leads to good C code as we can take -- advantage of look-up tables. Note that we make virtually no attempt to@@ -33,7 +33,10 @@ import Data.SBV.Tools.Polynomial  import Data.List (transpose)+import Data.Maybe (fromJust) +import Numeric (showHex)+ ----------------------------------------------------------------------------- -- * Formalizing GF(2^8) -----------------------------------------------------------------------------@@ -358,7 +361,7 @@  -- | 128-bit encryption test, from Appendix C.1 of the AES standard: ----- >>> map hex t128Enc+-- >>> map hex8 t128Enc -- ["69c4e0d8","6a7b0430","d8cdb780","70b4c55a"] -- t128Enc :: [SWord32]@@ -369,7 +372,7 @@  -- | 128-bit decryption test, from Appendix C.1 of the AES standard: ----- >>> map hex t128Dec+-- >>> map hex8 t128Dec -- ["00112233","44556677","8899aabb","ccddeeff"] -- t128Dec :: [SWord32]@@ -384,7 +387,7 @@  -- | 192-bit encryption test, from Appendix C.2 of the AES standard: ----- >>> map hex t192Enc+-- >>> map hex8 t192Enc -- ["dda97ca4","864cdfe0","6eaf70a0","ec0d7191"] -- t192Enc :: [SWord32]@@ -395,7 +398,7 @@  -- | 192-bit decryption test, from Appendix C.2 of the AES standard: ----- >>> map hex t192Dec+-- >>> map hex8 t192Dec -- ["00112233","44556677","8899aabb","ccddeeff"] -- t192Dec :: [SWord32]@@ -410,7 +413,7 @@  -- | 256-bit encryption, from Appendix C.3 of the AES standard: ----- >>> map hex t256Enc+-- >>> map hex8 t256Enc -- ["8ea2b7ca","516745bf","eafc4990","4b496089"] -- t256Enc :: [SWord32]@@ -421,7 +424,7 @@  -- | 256-bit decryption, from Appendix C.3 of the AES standard: ----- >>> map hex t256Dec+-- >>> map hex8 t256Dec -- ["00112233","44556677","8899aabb","ccddeeff"] -- t256Dec :: [SWord32]@@ -579,6 +582,12 @@ -- somewhat simplistically, so these numbers should be considered very rough estimates.) cgAES128Library :: IO () cgAES128Library = compileToCLib Nothing "aes128Lib" aes128LibComponents++--------------------------------------------------------------------------------------------+-- | For doctest purposes only+hex8 :: (SymWord a, Show a, Integral a) => SBV a -> String+hex8 v = replicate (8 - length s) '0' ++ s+  where s = flip showHex "" . fromJust . unliteral $ v  {-# ANN aesRound    ("HLint: ignore Use head" :: String) #-} {-# ANN aesInvRound ("HLint: ignore Use head" :: String) #-}
Data/SBV/Examples/Crypto/RC4.hs view
@@ -26,6 +26,8 @@  import Data.SBV.Tools.STree +import Numeric (showHex)+ ----------------------------------------------------------------------------- -- * Types -----------------------------------------------------------------------------@@ -97,13 +99,13 @@ -- | RC4 encryption. We generate key-words and xor it with the input. The -- following test-vectors are from Wikipedia <http://en.wikipedia.org/wiki/RC4>: ----- >>> concatMap hex $ encrypt "Key" "Plaintext"+-- >>> concatMap hex2 $ encrypt "Key" "Plaintext" -- "bbf316e8d940af0ad3" ----- >>> concatMap hex $ encrypt "Wiki" "pedia"+-- >>> concatMap hex2 $ encrypt "Wiki" "pedia" -- "1021bf0420" ----- >>> concatMap hex $ encrypt "Secret" "Attack at dawn"+-- >>> concatMap hex2 $ encrypt "Secret" "Attack at dawn" -- "45a01f645fc35b383552544b9bf5" encrypt :: String -> String -> [SWord8] encrypt key pt = zipWith xor (keyScheduleString key) (map cvt pt)@@ -143,3 +145,9 @@             ct  = zipWith xor ks pt             pt' = zipWith xor ks ct         return $ pt .== pt'++--------------------------------------------------------------------------------------------+-- | For doctest purposes only+hex2 :: (SymWord a, Show a, Integral a) => SBV a -> String+hex2 v = replicate (2 - length s) '0' ++ s+  where s = flip showHex "" . fromJust . unliteral $ v
Data/SBV/Examples/Existentials/Diophantine.hs view
@@ -12,6 +12,7 @@ module Data.SBV.Examples.Existentials.Diophantine where  import Data.SBV+import Data.SBV.Control  -------------------------------------------------------------------------------------------------- -- * Representing solutions@@ -27,14 +28,16 @@ -- * Solving diophantine equations -------------------------------------------------------------------------------------------------- -- | ldn: Solve a (L)inear (D)iophantine equation, returning minimal solutions over (N)aturals.--- The input is given as a rows of equations, with rhs values separated into a tuple.-ldn :: [([Integer], Integer)] -> IO Solution-ldn problem = do solution <- basis (map (map literal) m)-                 if homogeneous-                    then return $ Homogeneous solution-                    else do let ones  = [xs | (1:xs) <- solution]-                                zeros = [xs | (0:xs) <- solution]-                            return $ NonHomogeneous ones zeros+-- The input is given as a rows of equations, with rhs values separated into a tuple. The first+-- parameter limits the search to bound: In case there are too many solutions, you might want+-- to limit your search space.+ldn :: Maybe Int -> [([Integer], Integer)] -> IO Solution+ldn mbLim problem = do solution <- basis mbLim (map (map literal) m)+                       if homogeneous+                           then return $ Homogeneous solution+                           else do let ones  = [xs | (1:xs) <- solution]+                                       zeros = [xs | (0:xs) <- solution]+                                   return $ NonHomogeneous ones zeros   where rhs = map snd problem         lhs = map fst problem         homogeneous = all (== 0) rhs@@ -47,12 +50,18 @@ -- order using the ordinary less-than relation. (NB. We explicitly tell z3 to use the logic -- AUFLIA for this problem, as the BV solver that is chosen automatically has a performance -- issue. See: <https://z3.codeplex.com/workitem/88>.)-basis :: [[SInteger]] -> IO [[Integer]]-basis m = extractModels `fmap` allSatWith z3{useLogic = Just (PredefinedLogic AUFLIA)} cond+basis :: Maybe Int -> [[SInteger]] -> IO [[Integer]]+basis mbLim m = extractModels `fmap` allSatWith z3{allSatMaxModelCount = mbLim} cond  where cond = do as <- mkExistVars  n                  bs <- mkForallVars n++                 -- Tell the solver to use this logic!+                 setLogic AUFLIA+                  return $ ok as &&& (ok bs ==> as .== bs ||| bnot (bs `less` as))+        n = if null m then 0 else length (head m)+        ok xs = bAny (.> 0) xs &&& bAll (.>= 0) xs &&& bAnd [sum (zipWith (*) r xs) .== 0 | r <- m]        as `less` bs = bAnd (zipWith (.<=) as bs) &&& bOr (zipWith (.<) as bs) @@ -81,7 +90,7 @@ -- to the equation given. It's harder to see that they cover all possibilities, -- but a moments thought reveals that is indeed the case. test :: IO Solution-test = ldn [([2,1,-1], 2)]+test = ldn Nothing [([2,1,-1], 2)]  -- | A puzzle: Five sailors and a monkey escape from a naufrage and reach an island with -- coconuts. Before dawn, they gather a few of them and decide to sleep first and share@@ -121,12 +130,18 @@ -- Note that this is the minimum solution, that is, we are guaranteed that there's -- no solution with less number of coconuts. In fact, any member of @[15625*k-4 | k <- [1..]]@ -- is a solution, i.e., so are @31246@, @46871@, @62496@, @78121@, etc.+--+-- Note that we iteratively deepen our search by requesting increasing number of+-- solutions to avoid the all-sat pitfall. sailors :: IO [Integer]-sailors = do NonHomogeneous (xs:_) _ <- ldn [ ([1, -5,  0,  0,  0,  0,  0], 1)-                                            , ([0,  4, -5 , 0,  0,  0,  0], 1)-                                            , ([0,  0,  4, -5 , 0,  0,  0], 1)-                                            , ([0,  0,  0,  4, -5,  0,  0], 1)-                                            , ([0,  0,  0,  0,  4, -5,  0], 1)-                                            , ([0,  0,  0,  0,  0,  4, -5], 1)-                                            ]-             return xs+sailors = search 1+  where search i = do soln <- ldn (Just i) [ ([1, -5,  0,  0,  0,  0,  0], 1)+                                           , ([0,  4, -5 , 0,  0,  0,  0], 1)+                                           , ([0,  0,  4, -5 , 0,  0,  0], 1)+                                           , ([0,  0,  0,  4, -5,  0,  0], 1)+                                           , ([0,  0,  0,  0,  4, -5,  0], 1)+                                           , ([0,  0,  0,  0,  0,  4, -5], 1)+                                           ]+                      case soln of+                        NonHomogeneous (xs:_) _ -> return xs+                        _                       -> search (i+1)
Data/SBV/Examples/Misc/Auxiliary.hs view
@@ -35,11 +35,11 @@ --   x = 0 :: Integer --   y = 0 :: Integer -- Solution #2:---   x =  1 :: Integer---   y = -1 :: Integer--- Solution #3: --   x = 1 :: Integer --   y = 1 :: Integer+-- Solution #3:+--   x =  1 :: Integer+--   y = -1 :: Integer -- Found 3 different solutions. -- -- Note that solutions @2@ and @3@ share the value @x = 1@, since there are
Data/SBV/Examples/Misc/Enumerate.hs view
@@ -12,6 +12,8 @@ -- example involving enumerations. ----------------------------------------------------------------------------- +{-# LANGUAGE TemplateHaskell     #-}+{-# LANGUAGE StandaloneDeriving  #-} {-# LANGUAGE DeriveDataTypeable  #-} {-# LANGUAGE DeriveAnyClass      #-} {-# LANGUAGE ScopedTypeVariables #-}@@ -19,17 +21,16 @@ module Data.SBV.Examples.Misc.Enumerate where  import Data.SBV-import Data.Generics  -- | A simple enumerated type, that we'd like to translate to SMT-Lib intact; -- i.e., this type will not be uninterpreted but rather preserved and will--- be just like any other symbolic type SBV provides. Note the automatically--- derived classes we need: 'Eq', 'Ord', 'Data', 'Read', 'Show', 'SymWord',--- 'HasKind', and 'SatModel'. (The last one is only needed if 'getModel' and friends are used.)+-- be just like any other symbolic type SBV provides. ----- Also note that we need to @import Data.Generics@ and have the @LANGUAGE@--- option @DeriveDataTypeable@ and @DeriveAnyClass@ set.-data E = A | B | C deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind)+-- Also note that we need to have the following @LANGUAGE@ options defined:+-- @TemplateHaskell@, @StandaloneDeriving@, @DeriveDataTypeable@, @DeriveAnyClass@ for+-- this to work.+data E = A | B | C+mkSymbolicEnumeration ''E  -- | Give a name to the symbolic variants of 'E', for convenience type SE = SBV E
− Data/SBV/Examples/Misc/UnsatCore.hs 
@@ -1,45 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Data.SBV.Examples.Misc.UnsatCore--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Demonstrates extraction of unsat-cores.--------------------------------------------------------------------------------module Data.SBV.Examples.Misc.UnsatCore where--import Data.SBV---- | A simple goal with three constraints, two of which are--- conflicting with each other. The third is irrelevant, in the sense--- that it does not contribute to the fact that the goal is unsatisfiable.-p :: Goal-p = do a <- sInteger "a"-       b <- sInteger "b"--       -- create named constraints, which will allow-       -- unsat-core extraction with the given names-       namedConstraint "less than 5"  $ a .< 5-       namedConstraint "more than 10" $ a .> (10::SInteger)-       namedConstraint "irrelevant"   $ a .> b---- | Extract the unsat-core of 'p'. We have:------ >>> ucCore--- Unsatisfiable. Unsat core:---   less than 5---   more than 10--- =====================================--- Unsat core is: ["less than 5","more than 10"]------ Demonstrating that the constraint @a .> b@ is /not/ needed for unsatisfiablity in this case.-ucCore :: IO ()-ucCore = do r <- satWith z3{getUnsatCore=True} p-            print r-            putStrLn "====================================="-            case extractUnsatCore r of-              Nothing -> putStrLn "No unsat core!"-              Just xs -> putStrLn $ "Unsat core is: " ++ show xs
+ Data/SBV/Examples/Optimization/ExtField.hs view
@@ -0,0 +1,45 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Optimization.ExtField+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Demonstrates the extension field (@oo@/@epsilon@) optimization results.+-----------------------------------------------------------------------------++module Data.SBV.Examples.Optimization.ExtField where++import Data.SBV++-- | Optimization goals where min/max values might require assignments+-- to values that are infinite (integer case), or infinite/epsion (real case).+-- This simple example demostrates how SBV can be used to extract such values.+--+-- We have:+--+-- >>> 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+-- 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+-- 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+problem :: Goal+problem = do x <- sInteger "x"+             y <- sReal "y"+             z <- sReal "z"++             maximize "one-x" $ 1 - x++             constrain $ y .> 0 &&& z .> 5+             minimize "min_y" $ 2+y+z++             minimize "min_z" z
Data/SBV/Examples/Optimization/LinearOpt.hs view
@@ -24,7 +24,7 @@ --          4. x1 >= 0 --          5. x2 >= 0 ----- >>> optimize problem+-- >>> optimize Lexicographic problem -- Optimal model: --   x1   =  47 % 9 :: Real --   x2   =  20 % 9 :: Real
Data/SBV/Examples/Optimization/Production.hs view
@@ -37,7 +37,7 @@ -- -- We have: ----- >>> optimize production+-- >>> optimize Lexicographic production -- Optimal model: --   X     = 45 :: Integer --   Y     =  6 :: Integer
Data/SBV/Examples/Optimization/VM.hs view
@@ -27,7 +27,7 @@ -- -- We have: ----- >>> optimize allocate+-- >>> optimize Lexicographic allocate -- Optimal model: --   x11         = False :: Bool --   x12         = False :: Bool
Data/SBV/Examples/Puzzles/Birthday.hs view
@@ -6,7 +6,7 @@ -- Maintainer  :  erkokl@gmail.com -- Stability   :  experimental ----- This is a formalization of the Cheryl's birtday problem, which went viral in April 2015.+-- This is a formalization of the Cheryl's birthday problem, which went viral in April 2015. -- (See <http://www.nytimes.com/2015/04/15/science/a-math-problem-from-singapore-goes-viral-when-is-cheryls-birthday.html>.) -- -- Here's the puzzle:
Data/SBV/Examples/Puzzles/Fish.hs view
@@ -27,29 +27,35 @@ -- Who owns the fish? ------------------------------------------------------------------------------ -{-# LANGUAGE DeriveAnyClass      #-}+{-# LANGUAGE TemplateHaskell     #-}+{-# LANGUAGE StandaloneDeriving  #-} {-# LANGUAGE DeriveDataTypeable  #-}+{-# LANGUAGE DeriveAnyClass      #-} {-# LANGUAGE ScopedTypeVariables #-}  module Data.SBV.Examples.Puzzles.Fish where -import Data.Generics import Data.SBV  -- | Colors of houses-data Color       = Red      | Green    | White      | Yellow    | Blue   deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind)+data Color = Red | Green | White | Yellow | Blue+mkSymbolicEnumeration ''Color  -- | Nationalities of the occupants-data Nationality = Briton   | Dane     | Swede      | Norwegian | German deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind)+data Nationality = Briton | Dane | Swede | Norwegian | German+mkSymbolicEnumeration ''Nationality  -- | Beverage choices-data Beverage    = Tea      | Coffee   | Milk       | Beer      | Water  deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind)+data Beverage = Tea | Coffee | Milk | Beer | Water+mkSymbolicEnumeration ''Beverage  -- | Pets they keep-data Pet         = Dog      | Horse    | Cat        | Bird      | Fish   deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind)+data Pet = Dog | Horse | Cat | Bird | Fish+mkSymbolicEnumeration ''Pet  -- | Sports they engage in-data Sport       = Football | Baseball | Volleyball | Hockey    | Tennis deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind)+data Sport = Football | Baseball | Volleyball | Hockey | Tennis+mkSymbolicEnumeration ''Sport  -- | We have: --
Data/SBV/Examples/Puzzles/Sudoku.hs view
@@ -53,7 +53,7 @@ -- | Solve a given puzzle and print the results sudoku :: Puzzle -> IO () sudoku p@(i, f) = do putStrLn "Solving the puzzle.."-                     model <- getModel `fmap` sat ((valid . f) `fmap` mkExistVars i)+                     model <- getModelAssignment `fmap` sat ((valid . f) `fmap` mkExistVars i)                      case model of                        Right sln -> dispSolution p sln                        Left m    -> putStrLn $ "Unsolvable puzzle: " ++ m
Data/SBV/Examples/Puzzles/U2Bridge.hs view
@@ -9,18 +9,19 @@ -- The famous U2 bridge crossing puzzle: <http://www.braingle.com/brainteasers/515/u2.html> ----------------------------------------------------------------------------- +{-# LANGUAGE FlexibleInstances    #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE TemplateHaskell      #-}+{-# LANGUAGE StandaloneDeriving   #-} {-# LANGUAGE DeriveAnyClass       #-} {-# LANGUAGE DeriveDataTypeable   #-} {-# LANGUAGE DeriveGeneric        #-}-{-# LANGUAGE FlexibleInstances    #-}-{-# LANGUAGE TypeSynonymInstances #-}  module Data.SBV.Examples.Puzzles.U2Bridge where  import Control.Monad       (unless) import Control.Monad.State (State, runState, put, get, modify, evalState) -import Data.Generics (Data) import GHC.Generics (Generic)  import Data.SBV@@ -29,9 +30,10 @@ -- * Modeling the puzzle ------------------------------------------------------------- --- | U2 band members. We want to translate this to SMT-Lib--- as a data-type, and hence the deriving mechanism.-data U2Member = Bono | Edge | Adam | Larry deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind, SatModel)+-- | U2 band members. We want to translate this to SMT-Lib as a data-type, and hence the+-- call to mkSymbolicEnumeration.+data U2Member = Bono | Edge | Adam | Larry+mkSymbolicEnumeration ''U2Member  -- | Symbolic shorthand for a 'U2Member' type SU2Member = SBV U2Member@@ -61,7 +63,8 @@                                   (literal (crossTime Larry)) -- Must be Larry  -- | Location of the flash-data Location = Here | There deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind, SatModel)+data Location = Here | There+mkSymbolicEnumeration ''Location  -- | Symbolic variant of 'Location' type SLocation = SBV Location
+ Data/SBV/Examples/Queries/AllSat.hs view
@@ -0,0 +1,86 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Queries.AllSat+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- When we would like to find all solutions to a problem, we can query the+-- solver repeatedly, telling it to give us a new model each time. SBV already+-- provides 'allSat' that precisely does this. However, this example demonstrates+-- how the query mode can be used to achieve the same, and can also incorporate+-- extra conditions with easy as we walk through solutions.+-----------------------------------------------------------------------------++module Data.SBV.Examples.Queries.AllSat where++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+-- 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)]+goodSum = do x <- sInteger "x"+             y <- sInteger "y"++             -- constrain positive and sum:+             constrain $ x .>= 0+             constrain $ y .>= 0+             constrain $ x + y .== 10++             -- Capture the "next" solution function:+             let next i sofar = do+                    io $ putStrLn $ "Iteration: " ++ show (i :: Int)++                    cs <- checkSat+                    case cs of+                      Unk   -> error "Too bad, solver said unknown.." -- Won't happen+                      Unsat -> do io $ putStrLn "No other solution!"+                                  return sofar++                      Sat   -> do xv <- getValue x+                                  yv <- getValue y++                                  io $ putStrLn $ "Current solution is: " ++ show (xv, yv)++                                  -- For next iteration: Put in constraints outlawing the current one:+                                  -- Note that we do *not* put these separately, as we do want+                                  -- to allow repetition on one value if the other is different!+                                  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)++             -- Go into query mode and execute the loop:+             query $ do io $ putStrLn "Starting the all-sat engine!"+                        next 1 []++-- | Run the query. We have:+--+-- >>> demo+-- Starting the all-sat engine!+-- Iteration: 1+-- Current solution is: (0,10)+-- Iteration: 2+-- Current solution is: (1,9)+-- Iteration: 3+-- Current solution is: (2,8)+-- Iteration: 4+-- Current solution is: (4,6)+-- Iteration: 5+-- Current solution is: (8,2)+-- Iteration: 6+-- No other solution!+-- [(0,10),(1,9),(2,8),(4,6),(8,2)]+demo :: IO ()+demo = do ss <- runSMT goodSum+          print $ sort ss
+ Data/SBV/Examples/Queries/CaseSplit.hs view
@@ -0,0 +1,81 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Queries.CaseSplit+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- A couple of demonstrations for the caseSplit tactic.+-----------------------------------------------------------------------------++module Data.SBV.Examples.Queries.CaseSplit where++import Data.SBV+import Data.SBV.Control++-- | A simple floating-point problem, but we do the sat-analysis via a case-split.+-- Due to the nature of floating-point numbers, a case-split on the characteristics+-- of the number (such as NaN, negative-zero, etc. is most suitable.)+--+-- We have:+-- >>> csDemo1+-- Case fpIsNegativeZero: Starting+-- Case fpIsNegativeZero: Unsatisfiable+-- Case fpIsPositiveZero: Starting+-- Case fpIsPositiveZero: Unsatisfiable+-- Case fpIsNormal: Starting+-- Case fpIsNormal: Unsatisfiable+-- Case fpIsSubnormal: Starting+-- Case fpIsSubnormal: Unsatisfiable+-- Case fpIsPoint: Starting+-- Case fpIsPoint: Unsatisfiable+-- Case fpIsNaN: Starting+-- Case fpIsNaN: Satisfiable+-- ("fpIsNaN",NaN)+csDemo1 :: IO (String, Float)+csDemo1 = runSMT $ do++       x <- sFloat "x"++       constrain $ x ./= x -- yes, in the FP land, this does hold++       query $ do mbR <- caseSplit True [ ("fpIsNegativeZero", fpIsNegativeZero x)+                                        , ("fpIsPositiveZero", fpIsPositiveZero x)+                                        , ("fpIsNormal",       fpIsNormal       x)+                                        , ("fpIsSubnormal",    fpIsSubnormal    x)+                                        , ("fpIsPoint",        fpIsPoint        x)+                                        , ("fpIsNaN",          fpIsNaN          x)+                                        ]++                  case mbR of+                    Nothing     -> error "Cannot find a FP number x such that x == x + 1"  -- Won't happen!+                    Just (s, _) -> do xv <- getValue x+                                      return (s, xv)++-- | Demonstrates the "coverage" case.+--+-- We have:+-- >>> csDemo2+-- Case negative: Starting+-- Case negative: Unsatisfiable+-- Case less than 8: Starting+-- Case less than 8: Unsatisfiable+-- Case Coverage: Starting+-- Case Coverage: Satisfiable+-- ("Coverage",10)+csDemo2 :: IO (String, Integer)+csDemo2 = runSMT $ do++       x <- sInteger "x"++       constrain $ x .== 10++       query $ do mbR <- caseSplit True [ ("negative"   , x .< 0)+                                        , ("less than 8", x .< 8)+                                        ]++                  case mbR of+                    Nothing     -> error "Cannot find a solution!" -- Won't happen!+                    Just (s, _) -> do xv <- getValue x+                                      return (s, xv)
+ Data/SBV/Examples/Queries/Enums.hs view
@@ -0,0 +1,65 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Queries.Enums+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Demonstrates the use of enumeration values during queries.+-----------------------------------------------------------------------------++{-# LANGUAGE TemplateHaskell     #-}+{-# LANGUAGE StandaloneDeriving  #-}+{-# LANGUAGE DeriveDataTypeable  #-}+{-# LANGUAGE DeriveAnyClass      #-}+{-# LANGUAGE ScopedTypeVariables #-}++module Data.SBV.Examples.Queries.Enums where++import Data.SBV+import Data.SBV.Control++-- | Days of the week. We make it symbolic using the 'mkSymbolicEnumeration' splice.+data Day = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday+mkSymbolicEnumeration ''Day++-- | The type synonym 'SDay' is the symbolic variant of 'Day'. (Similar to 'SInteger'/'Integer'+-- and others.)+type SDay = SBV Day++-- | A trivial query to find three consecutive days that's all before 'Thursday'. The point+-- here is that we can perform queries on such enumerated values and use 'getValue' on them+-- and return their values from queries just like any other value. We have:+--+-- >>> findDays+-- [Monday,Tuesday,Wednesday]+findDays :: IO [Day]+findDays = runSMT $ do (d1 :: SDay) <- free "d1"+                       (d2 :: SDay) <- free "d2"+                       (d3 :: SDay) <- free "d3"++                       -- Assert that they are ordered+                       constrain $ d1 .<= d2+                       constrain $ d2 .<= d3++                       -- Assert that last day is before 'Thursday'+                       constrain $ d3 .< literal Thursday++                       -- Constraints can be given before or after+                       -- the query mode starts. We will assert that+                       -- they are different after we start interacting+                       -- with the solver. Note that we can query the+                       -- values based on other values obtained too,+                       -- if we want to guide the search.++                       query $ do constrain $ distinct [d1, d2, d3]++                                  cs <- checkSat+                                  case cs of+                                    Sat -> do a <- getValue d1+                                              b <- getValue d2+                                              c <- getValue d3+                                              return [a, b, c]++                                    _   -> error "Impossible, can't find days!"
+ Data/SBV/Examples/Queries/FourFours.hs view
@@ -0,0 +1,188 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Queries.FourFours+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- A query based solution to the four-fours puzzle.+-- Inspired by <http://www.gigamonkeys.com/trees/>+--+-- @+-- Try to make every number between 0 and 20 using only four 4s and any+-- mathematical operation, with all four 4s being used each time.+-- @+--+-- We pretty much follow the structure of <http://www.gigamonkeys.com/trees/>,+-- with the exception that we generate the trees filled with symbolic operators+-- and ask the SMT solver to find the appropriate fillings.+-----------------------------------------------------------------------------++{-# LANGUAGE FlexibleInstances  #-}+{-# LANGUAGE TemplateHaskell     #-}+{-# LANGUAGE StandaloneDeriving  #-}+{-# LANGUAGE DeriveDataTypeable  #-}+{-# LANGUAGE DeriveAnyClass      #-}+{-# LANGUAGE ScopedTypeVariables #-}++module Data.SBV.Examples.Queries.FourFours where++import Data.SBV+import Data.SBV.Control++import Data.List (inits, tails)+import Data.Maybe++-- | Supported binary operators. To keep the search-space small, we will only allow division by @2@ or @4@,+-- and exponentiation will only be to the power @0@. This does restrict the search space, but is sufficient to+-- solve all the instances.+data BinOp = Plus | Minus | Times | Divide | Expt+mkSymbolicEnumeration ''BinOp++-- | Supported unary operators. Similar to 'BinOp' case, we will restrict square-root and factorial to+-- be only applied to the value @4.+data UnOp  = Negate | Sqrt | Factorial+mkSymbolicEnumeration ''UnOp++-- | Symbolic variant of 'BinOp'.+type SBinOp = SBV BinOp++-- | Symbolic variant of 'UnOp'.+type SUnOp  = SBV UnOp++-- | The shape of a tree, either a binary node, or a unary node, or the number @4@, represented hear by+-- the constructor @F@. We parameterize by the operator type: When doing symbolic computations, we'll fill+-- those with 'SBinOp' and 'SUnOp'. When finding the shapes, we will simply put unit values, i.e., holes.+data T b u = B b (T b u) (T b u)+           | U u (T b u)+           | F++-- | A rudimentary 'Show' instance for trees, nothing fancy.+instance Show (T BinOp UnOp) where+   show F       = "4"+   show (U u t) = case u of+                    Negate    -> "-" ++ show t+                    Sqrt      -> "sqrt(" ++ show t ++ ")"+                    Factorial -> show t ++ "!"+   show (B o l r) = "(" ++ show l ++ " " ++ so ++ " " ++ show r ++ ")"+     where so = fromMaybe (error $ "Unexpected operator: " ++ show o)+                        $ o `lookup` [(Plus, "+"), (Minus, "-"), (Times, "*"), (Divide, "/"), (Expt, "^")]++-- | Construct all possible tree shapes. The argument here follows the logic in <http://www.gigamonkeys.com/trees/>:+-- We simply construct all possible shapes and extend with the operators. The number of such trees is:+--+-- >>> length allPossibleTrees+-- 640+--+-- Note that this is a /lot/ smaller than what is generated by <http://www.gigamonkeys.com/trees/>. (There, the+-- number of trees is 10240000: 16000 times more than what we have to consider!)+allPossibleTrees :: [T () ()]+allPossibleTrees = trees $ replicate 4 F+  where trees :: [T () ()] -> [T () ()]+        trees [x] = [x, U () x]+        trees xs  = do (left, right) <- splits+                       t1            <- trees left+                       t2            <- trees right+                       trees [B () t1 t2]+          where splits = init $ tail $ zip (inits xs) (tails xs)++-- | Given a tree with hols, fill it with symbolic operators. This is the /trick/ that allows+-- us to consider only 640 trees as opposed to over 10 million.+fill :: T () () -> Symbolic (T SBinOp SUnOp)+fill (B _ l r) = B <$> free_ <*> fill l <*> fill r+fill (U _ t)   = U <$> free_ <*> fill t+fill F         = return F++-- | Minor helper for writing "symbolic" case statements. Simply walks down a list+-- of values to match against a symbolic version of the key.+sCase :: (SymWord a, Mergeable v) => SBV a -> [(a, v)] -> v+sCase k = walk+  where walk []              = error "sCase: Expected a non-empty list of cases!"+        walk [(_, v)]        = v+        walk ((k1, v1):rest) = ite (k .== literal k1) v1 (walk rest)++-- | Evaluate a symbolic tree, obtaining a symbolic value. Note how we structure+-- this evaluation so we impose extra constraints on what values square-root, divide+-- etc. can take. This is the power of the symbolic approach: We can put arbitrary+-- symbolic constraints as we evaluate the tree.+eval :: T SBinOp SUnOp -> Symbolic SInteger+eval tree = case tree of+              B b l r -> eval l >>= \l' -> eval r >>= \r' -> binOp b l' r'+              U u t   -> eval t >>= uOp u+              F       -> return 4++  where binOp :: SBinOp -> SInteger -> SInteger -> Symbolic SInteger+        binOp o l r = do constrain $ o .== literal Divide ==> r .== 4 ||| r .== 2+                         constrain $ o .== literal Expt   ==> r .== 0+                         return $ sCase o+                                    [ (Plus,    l+r)+                                    , (Minus,   l-r)+                                    , (Times,   l*r)+                                    , (Divide,  l `sDiv` r)+                                    , (Expt,    1)   -- exponent is restricted to 0, so the value is 1+                                    ]++        uOp :: SUnOp -> SInteger -> Symbolic SInteger+        uOp o v = do constrain $ o .== literal Sqrt      ==> v .== 4+                     constrain $ o .== literal Factorial ==> v .== 4+                     return $ sCase o+                                [ (Negate,    -v)+                                , (Sqrt,       2)  -- argument is restricted to 4, so the value is 2+                                , (Factorial, 24)  -- argument is restricted to 4, so the value is 24+                                ]++-- | In the query mode, find a filling of a given tree shape /t/, such that it evalutes to the+-- requested number /i/. Note that we return back a concrete tree.+generate :: Integer -> T () () -> IO (Maybe (T BinOp UnOp))+generate i t = runSMT $ do symT <- fill t+                           val  <- eval symT+                           constrain $ val .== literal i+                           query $ do cs <- checkSat+                                      case cs of+                                        Sat -> Just <$> construct symT+                                        _   -> return Nothing+    where -- Walk through the tree, ask the solver for+          -- the assignment to symbolic operators and fill back.+          construct F           = return F+          construct (U o s')    = do uo <- getValue o+                                     U uo <$> construct s'+          construct (B b l' r') = do bo <- getValue b+                                     B bo <$> construct l' <*> construct r'++-- | Given an integer, walk through all possible tree shapes (at most 640 of them), and find a+-- filling that solves the puzzle.+find :: Integer -> IO ()+find i = go allPossibleTrees+  where go []     = putStrLn $ show i ++ ": No solution found."+        go (t:ts) = do chk <- generate i t+                       case chk of+                         Nothing -> go ts+                         Just r  -> putStrLn $ show i ++ ": " ++ show r++-- | Solution to the puzzle. We have:+--+-- >>> puzzle+-- 0: (4 + (4 - (4 + 4)))+-- 1: (4 / (4 + (4 - 4)))+-- 2: sqrt((4 + (4 * (4 - 4))))+-- 3: (4 - (4 ^ (4 - 4)))+-- 4: (4 * (4 ^ (4 - 4)))+-- 5: (4 + (4 ^ (4 - 4)))+-- 6: (4 + sqrt((4 * (4 / 4))))+-- 7: (4 + (4 - (4 / 4)))+-- 8: (4 - (4 - (4 + 4)))+-- 9: (4 + (4 + (4 / 4)))+-- 10: (4 + (4 + (4 - sqrt(4))))+-- 11: (4 + ((4 + 4!) / 4))+-- 12: (4 * (4 - (4 / 4)))+-- 13: (4! + ((sqrt(4) - 4!) / sqrt(4)))+-- 14: (4 + (4 + (4 + sqrt(4))))+-- 15: (4 + ((4! - sqrt(4)) / sqrt(4)))+-- 16: (4 + (4 + (4 + 4)))+-- 17: (4 + ((sqrt(4) + 4!) / sqrt(4)))+-- 18: -(4 + (4 - (4! + sqrt(4))))+-- 19: -(4 - (4! - (4 / 4)))+-- 20: (4 * (4 + (4 / 4)))+puzzle :: IO ()+puzzle = mapM_ find [0 .. 20]
+ Data/SBV/Examples/Queries/GuessNumber.hs view
@@ -0,0 +1,78 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Queries.GuessNumber+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- A simple number-guessing game implementation via queries. Clearly an+-- SMT solver is hardly needed for this problem, but it is a nice demo+-- for the interactive-query programming.+-----------------------------------------------------------------------------++module Data.SBV.Examples.Queries.GuessNumber where++import Data.SBV+import Data.SBV.Control++-- | Use the backend solver to guess the number given as argument.+-- The number is assumed to be between @0@ and @1000@, and we use a simple+-- binary search. Returns the sequence of guesses we performed during+-- the search process.+guess :: Integer -> Symbolic [Integer]+guess input = do g <- sInteger "guess"++                 -- A simple loop to find the value in a query. lb and up+                 -- correspond to the current lower/upper bound we operate in.+                 let loop lb ub sofar = do++                          io $ putStrLn $ "Current bounds: " ++ show (lb, ub)++                          -- Assert the current bound:+                          constrain $ g .>= literal lb+                          constrain $ g .<= literal ub++                          -- Issue a check-sat+                          cs <- checkSat+                          case cs of+                            Unk   -> error "Too bad, solver said Unknown.." -- Won't really happen+                            Unsat ->+                                  -- This cannot happen! If it does, the input was+                                  -- not properly constrainted. Note that we found this+                                  -- by getting an Unsat, not by checking the value!+                                  error $ unlines [ "There's no solution!"+                                                  , "Guess sequence: " ++ show (reverse sofar)+                                                  ]+                            Sat   -> do gv <- getValue g+                                        case gv `compare` input of+                                          EQ -> -- Got it, return:+                                                return (reverse (gv : sofar))+                                          LT -> -- Solver guess is too small, increase the lower bound:+                                                loop ((lb+1) `max` (lb + (input - lb) `div` 2)) ub (gv : sofar)+                                          GT -> -- Solver guess is too big, decrease the upper bound:+                                                loop lb ((ub-1) `min` (ub - (ub - input) `div` 2)) (gv : sofar)++                 -- Start the search+                 query $ loop 0 1000 []++-- | Play a round of the game, making the solver guess the secret number 42.+-- Note that you can generate a random-number and make the solver guess it too!+-- We have:+--+-- >>> play+-- Current bounds: (0,1000)+-- Current bounds: (0,521)+-- Current bounds: (21,521)+-- Current bounds: (31,521)+-- Current bounds: (36,521)+-- Current bounds: (39,521)+-- Current bounds: (40,521)+-- Current bounds: (41,521)+-- Current bounds: (42,521)+-- Solved in: 9 guesses:+--   1000 0 21 31 36 39 40 41 42+play :: IO ()+play = do gs <- runSMT (guess 42)+          putStrLn $ "Solved in: " ++ show (length gs) ++ " guesses:"+          putStrLn $ "  " ++ unwords (map show gs)
+ Data/SBV/Examples/Queries/UnsatCore.hs view
@@ -0,0 +1,50 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Queries.UnsatCore+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Demonstrates extraction of unsat-cores via queries.+-----------------------------------------------------------------------------++module Data.SBV.Examples.Queries.UnsatCore where++import Data.SBV+import Data.SBV.Control++-- | A simple goal with three constraints, two of which are+-- conflicting with each other. The third is irrelevant, in the sense+-- that it does not contribute to the fact that the goal is unsatisfiable.+p :: Symbolic (Maybe [String])+p = do a <- sInteger "a"+       b <- sInteger "b"++       -- tell the solver we want unsat-cores+       setOption $ ProduceUnsatCores True++       -- create named constraints, which will allow+       -- unsat-core extraction with the given names+       namedConstraint "less than 5"  $ a .< 5+       namedConstraint "more than 10" $ a .> 10+       namedConstraint "irrelevant"   $ a .> b++       -- To obtain the unsat-core, we run a query+       query $ do cs <- checkSat+                  case cs of+                    Unsat -> Just <$> getUnsatCore+                    _     -> return Nothing+++-- | Extract the unsat-core of 'p'. We have:+--+-- >>> ucCore+-- Unsat core is: ["less than 5","more than 10"]+--+-- Demonstrating that the constraint @a .> b@ is /not/ needed for unsatisfiablity in this case.+ucCore :: IO ()+ucCore = do mbCore <- runSMT p+            case mbCore of+              Nothing   -> putStrLn "Problem is satisfiable."+              Just core -> putStrLn $ "Unsat core is: " ++ show core
Data/SBV/Examples/Uninterpreted/AUF.hs view
@@ -45,13 +45,12 @@ f :: SWord32 -> SWord64 f = uninterpret "f" --- | Correctness theorem. We state it for all values of @x@, @y@, and --- the array @a@. We also take an arbitrary initializer for the array.-thm1 :: SWord32 -> SWord32 -> A -> SWord32 -> SBool-thm1 x y a initVal = lhs ==> rhs-  where a'  = resetArray a initVal -- initialize array-        lhs = x + 2 .== y-        rhs =     f (readArray (writeArray a' x 3) (y - 2))+-- | Correctness theorem. We state it for all values of @x@, @y@, and+-- the given array @a@. +thm1 :: SWord32 -> SWord32 -> A -> SBool+thm1 x y a = lhs ==> rhs+  where lhs = x + 2 .== y+        rhs =     f (readArray (writeArray a x 3) (y - 2))               .== f (y - x + 1)  -- | Prints Q.E.D. when run, as expected@@ -62,9 +61,9 @@ proveThm1 = prove $ do                 x <- free "x"                 y <- free "y"-                a <- newArray "a" Nothing-                i <- free "initVal"-                return $ thm1 x y a i+                -- Take an "initialized" array, one that returns 0's for all initial reads+                let a = mkSFunArray (const 0)+                return $ thm1 x y a  -------------------------------------------------------------- -- * Model using SMT arrays@@ -89,5 +88,5 @@ proveThm2 = prove $ do                 x <- free "x"                 y <- free "y"-                a <- newArray "b" Nothing+                a <- newArray "b"                 return $ thm2 x y a
Data/SBV/Internals.hs view
@@ -13,7 +13,7 @@  module Data.SBV.Internals (   -- * Running symbolic programs /manually/-    Result(..), SBVRunMode(..)+    Result(..), SBVRunMode(..), IStage(..)    -- * Solver capabilities   , SolverCapabilities(..)@@ -22,10 +22,7 @@   , module Data.SBV.Core.Data    -- * Operations useful for instantiating SBV type classes-  , genLiteral, genFromCW, genMkSymVar, checkAndConvert, genParse, showModel, SMTModel(..), liftQRem, liftDMod--  -- * Getting SMT-Lib output (for offline analysis)-  , compileToSMTLib, generateSMTBenchmarks+  , genLiteral, genFromCW, CW(..), genMkSymVar, checkAndConvert, genParse, showModel, SMTModel(..), liftQRem, liftDMod    -- * Compilation to C, extras   , compileToC', compileToCLib'@@ -35,20 +32,62 @@    -- * Various math utilities around floats   , module Data.SBV.Utils.Numeric++  -- * Pretty number printing+  , module Data.SBV.Utils.PrettyNum++  -- * Timing computations+  , module Data.SBV.Utils.TDiff++  -- * Coordinating with the solver+  -- $coordinateSolverInfo+  , sendStringToSolver, sendRequestToSolver, retrieveResponseFromSolver+   ) where  import Data.SBV.Core.Data-import Data.SBV.Core.Model      (genLiteral, genFromCW, genMkSymVar)+import Data.SBV.Core.Model      (genLiteral, genFromCW, genMkSymVar, liftQRem, liftDMod)+import Data.SBV.Core.Symbolic   (IStage(..)) import Data.SBV.Core.Splittable (checkAndConvert)-import Data.SBV.Core.Model      (liftQRem, liftDMod)  import Data.SBV.Compilers.C       (compileToC', compileToCLib') import Data.SBV.Compilers.CodeGen -import Data.SBV.Provers.Prover (compileToSMTLib, generateSMTBenchmarks)- import Data.SBV.SMT.SMT (genParse, showModel)  import Data.SBV.Utils.Numeric++import Data.SBV.Utils.TDiff+import Data.SBV.Utils.PrettyNum++import qualified Data.SBV.Control.Utils as Query++-- | Send an arbitrary string to the solver in a query.+-- Note that this is inherently dangerous as it can put the solver in an arbitrary+-- state and confuse SBV. If you use this feature, you are on your own!+sendStringToSolver :: String -> Query ()+sendStringToSolver = Query.send False++-- | Retrieve multiple responses from the solver, until it responds with a user given+-- tag that we shall arrange for internally. The optional timeout is in milliseconds.+-- If the time-out is exceeded, then we will raise an error. Note that this is inherently+-- dangerous as it can put the solver in an arbitrary state and confuse SBV. If you use this+-- feature, you are on your own!+retrieveResponseFromSolver :: String -> Maybe Int -> Query [String]+retrieveResponseFromSolver = Query.retrieveResponse++-- | Send an arbitrary string to the solver in a query, and return a response.+-- Note that this is inherently dangerous as it can put the solver in an arbitrary+-- state and confuse SBV.+sendRequestToSolver :: String -> Query String+sendRequestToSolver = Query.ask++{- $coordinateSolverInfo+In rare cases it might be necessary to send an arbitrary string down to the solver. Needless to say, this+should be avoided if at all possible. Users should prefer the provided API. If you do find yourself+needing 'send' and 'ask' directly, please get in touch to see if SBV can support a typed API for your use case.+Similarly, the function 'retrieveResponseFromSolver' might occasionally be necessary to clean-up the communication+buffer. We would like to hear if you do need these functions regularly so we can provide better support.+-}  {-# ANN module ("HLint: ignore Use import/export shortcut" :: String) #-}
Data/SBV/Provers/ABC.hs view
@@ -23,22 +23,18 @@ abc = SMTSolver {            name         = ABC          , executable   = "abc"-         , options      = ["-S", "%blast; &sweep -C 5000; &syn4; &cec -s -m -C 2000"]-         , engine       = standardEngine "SBV_ABC" "SBV_ABC_OPTIONS" id addTimeOut standardModel+         , options      = const ["-S", "%blast; &sweep -C 5000; &syn4; &cec -s -m -C 2000"]+         , engine       = standardEngine "SBV_ABC" "SBV_ABC_OPTIONS"          , capabilities = SolverCapabilities {-                                capSolverName              = "ABC"-                              , mbDefaultLogic             = const Nothing-                              , supportsDefineFun          = True-                              , supportsProduceModels      = True-                              , supportsQuantifiers        = False+                                supportsQuantifiers        = False                               , supportsUninterpretedSorts = False                               , supportsUnboundedInts      = False                               , supportsReals              = False-                              , supportsFloats             = False-                              , supportsDoubles            = False+                              , supportsApproxReals        = False+                              , supportsIEEE754            = False                               , supportsOptimization       = False                               , supportsPseudoBooleans     = False-                              , supportsUnsatCores         = False+                              , supportsCustomQueries      = False+                              , supportsGlobalDecls        = False                               }          }-  where addTimeOut _ _ = error "ABC: Timeout values are not supported"
Data/SBV/Provers/Boolector.hs view
@@ -21,23 +21,18 @@ boolector = SMTSolver {            name         = Boolector          , executable   = "boolector"-         , options      = ["--smt2", "--smt2-model", "--no-exit-codes"]-         , engine       = standardEngine "SBV_BOOLECTOR" "SBV_BOOLECTOR_OPTIONS" id addTimeOut standardModel+         , options      = const ["--smt2", "--smt2-model", "--no-exit-codes", "--incremental"]+         , engine       = standardEngine "SBV_BOOLECTOR" "SBV_BOOLECTOR_OPTIONS"          , capabilities = SolverCapabilities {-                                capSolverName              = "Boolector"-                              , mbDefaultLogic             = const Nothing-                              , supportsDefineFun          = False-                              , supportsProduceModels      = True-                              , supportsQuantifiers        = False+                                supportsQuantifiers        = False                               , supportsUninterpretedSorts = False                               , supportsUnboundedInts      = False                               , supportsReals              = False-                              , supportsFloats             = False-                              , supportsDoubles            = False+                              , supportsApproxReals        = False+                              , supportsIEEE754            = False                               , supportsOptimization       = False                               , supportsPseudoBooleans     = False-                              , supportsUnsatCores         = False+                              , supportsCustomQueries      = True+                              , supportsGlobalDecls        = False                               }          }- where addTimeOut o i | i < 0 = error $ "Boolector: Timeout value must be non-negative, received: " ++ show i-                      | True  = o ++ ["-t=" ++ show i]
Data/SBV/Provers/CVC4.hs view
@@ -23,23 +23,18 @@ cvc4 = SMTSolver {            name         = CVC4          , executable   = "cvc4"-         , options      = ["--lang", "smt"]-         , engine       = standardEngine "SBV_CVC4" "SBV_CVC4_OPTIONS" id addTimeOut standardModel+         , options      = const ["--lang", "smt", "--incremental", "--interactive", "--no-interactive-prompt"]+         , engine       = standardEngine "SBV_CVC4" "SBV_CVC4_OPTIONS"          , capabilities = SolverCapabilities {-                                capSolverName              = "CVC4"-                              , mbDefaultLogic             = const (Just "ALL_SUPPORTED")  -- CVC4 is not happy if we don't set the logic, so fall-back to this if necessary-                              , supportsDefineFun          = True-                              , supportsProduceModels      = True-                              , supportsQuantifiers        = True+                                supportsQuantifiers        = True                               , supportsUninterpretedSorts = True                               , supportsUnboundedInts      = True                               , supportsReals              = True  -- Not quite the same capability as Z3; but works more or less..-                              , supportsFloats             = False-                              , supportsDoubles            = False+                              , supportsApproxReals        = False+                              , supportsIEEE754            = False                               , supportsOptimization       = False                               , supportsPseudoBooleans     = False-                              , supportsUnsatCores         = True+                              , supportsCustomQueries      = True+                              , supportsGlobalDecls        = True                               }          }- where addTimeOut o i | i < 0 = error $ "CVC4: Timeout value must be non-negative, received: " ++ show i-                      | True  = o ++ ["--tlimit=" ++ show i ++ "000"]  -- SBV takes seconds, CVC4 wants milli-seconds
Data/SBV/Provers/MathSAT.hs view
@@ -16,6 +16,8 @@ import Data.SBV.Core.Data import Data.SBV.SMT.SMT +import Data.SBV.Control.Types+ -- | The description of the MathSAT SMT solver -- The default executable is @\"mathsat\"@, which must be in your path. You can use the @SBV_MATHSAT@ environment variable to point to the executable on your system. -- The default options are @\"-input=smt2\"@. You can use the @SBV_MATHSAT_OPTIONS@ environment variable to override the options.@@ -23,29 +25,26 @@ mathSAT = SMTSolver {            name         = MathSAT          , executable   = "mathsat"-         , options      = ["-input=smt2", "-theory.fp.minmax_zero_mode=4"]-         , engine       = standardEngine "SBV_MATHSAT" "SBV_MATHSAT_OPTIONS" modConfig addTimeOut standardModel+         , options      = modConfig ["-input=smt2", "-theory.fp.minmax_zero_mode=4"]+         , engine       = standardEngine "SBV_MATHSAT" "SBV_MATHSAT_OPTIONS"          , capabilities = SolverCapabilities {-                                capSolverName              = "MathSAT"-                              , mbDefaultLogic             = const Nothing-                              , supportsDefineFun          = True-                              , supportsProduceModels      = True-                              , supportsQuantifiers        = True+                                supportsQuantifiers        = True                               , supportsUninterpretedSorts = True                               , supportsUnboundedInts      = True                               , supportsReals              = True-                              , supportsFloats             = True-                              , supportsDoubles            = True+                              , supportsApproxReals        = False+                              , supportsIEEE754            = True                               , supportsOptimization       = False                               , supportsPseudoBooleans     = False-                              , supportsUnsatCores         = True+                              , supportsCustomQueries      = True+                              , supportsGlobalDecls        = False                               }          }- where addTimeOut _ _ = error "MathSAT: Timeout values are not supported" -       -- If unsat cores are needed, MathSAT requires an explicit command-line argument-       modConfig :: SMTConfig -> SMTConfig-       modConfig cfg-        | not (getUnsatCore cfg) = cfg-        | True                   = cfg {solver = (solver cfg) {options = newOpts}}-        where newOpts = options (solver cfg) ++ ["-unsat_core_generation=3"]+ where -- If unsat cores are needed, MathSAT requires an explicit command-line argument+       modConfig :: [String] -> SMTConfig -> [String]+       modConfig opts cfg+        | or [b | ProduceUnsatCores b <- solverSetOptions cfg]+        = opts ++ ["-unsat_core_generation=3"]+        | True+        = opts
Data/SBV/Provers/Prover.hs view
@@ -1,1031 +1,622 @@- -------------------------------------------------------------------------------- |--- Module      :  Data.SBV.Provers.Prover--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Provable abstraction and the connection to SMT solvers--------------------------------------------------------------------------------{-# LANGUAGE CPP                  #-}-{-# LANGUAGE BangPatterns         #-}-{-# LANGUAGE FlexibleInstances    #-}-{-# LANGUAGE LambdaCase           #-}-{-# LANGUAGE NamedFieldPuns       #-}-{-# LANGUAGE ScopedTypeVariables  #-}-{-# LANGUAGE TypeSynonymInstances #-}--module Data.SBV.Provers.Prover (-         SMTSolver(..), SMTConfig(..), Predicate, Provable(..), Goal-       , ThmResult(..), SatResult(..), AllSatResult(..), SafeResult(..), OptimizeResult(..), SMTResult(..)-       , isSatisfiable, isSatisfiableWith, isTheorem, isTheoremWith-       , prove, proveWith-       , sat, satWith-       , allSat, allSatWith-       , safe, safeWith, isSafe-       , optimize, optimizeWith-       , isVacuous, isVacuousWith-       , SatModel(..), Modelable(..), displayModels, extractModels-       , getModelDictionaries, getModelValues, getModelUninterpretedValues-       , boolector, cvc4, yices, z3, mathSAT, abc, defaultSMTCfg-       , compileToSMTLib, generateSMTBenchmarks-       , internalSATCheck-       ) where--import Data.Char         (isSpace)-import Data.List         (intercalate, nub)--import Control.Monad     (when, unless)-import System.FilePath   (addExtension, splitExtension)-import System.Time       (getClockTime)-import System.IO         (hGetBuffering, hSetBuffering, stdout, hFlush, BufferMode(..))-import System.IO.Unsafe  (unsafeInterleaveIO)--import Control.Concurrent.Async (async, wait, cancel, waitAny, Async)--import GHC.Stack.Compat-#if !MIN_VERSION_base(4,9,0)-import GHC.SrcLoc.Compat-#endif--import qualified Data.Set as Set (toList)--import Data.SBV.Core.Data-import Data.SBV.Core.Symbolic-import Data.SBV.SMT.SMT-import Data.SBV.SMT.SMTLib-import Data.SBV.Utils.TDiff--import Control.DeepSeq (rnf)-import Control.Exception (bracket)--import qualified Data.SBV.Provers.Boolector  as Boolector-import qualified Data.SBV.Provers.CVC4       as CVC4-import qualified Data.SBV.Provers.Yices      as Yices-import qualified Data.SBV.Provers.Z3         as Z3-import qualified Data.SBV.Provers.MathSAT    as MathSAT-import qualified Data.SBV.Provers.ABC        as ABC--mkConfig :: SMTSolver -> SMTLibVersion -> [String] -> SMTConfig-mkConfig s smtVersion tweaks = SMTConfig { verbose        = False-                                         , timing         = NoTiming-                                         , sBranchTimeOut = Nothing-                                         , timeOut        = Nothing-                                         , printBase      = 10-                                         , printRealPrec  = 16-                                         , smtFile        = Nothing-                                         , solver         = s-                                         , solverTweaks   = tweaks-                                         , smtLibVersion  = smtVersion-                                         , optimizeArgs   = []-                                         , satCmd         = "(check-sat)"-                                         , isNonModelVar  = const False  -- i.e., everything is a model-variable by default-                                         , roundingMode   = RoundNearestTiesToEven-                                         , useLogic       = Nothing-                                         , getUnsatCore   = False-                                         }---- | Default configuration for the Boolector SMT solver-boolector :: SMTConfig-boolector = mkConfig Boolector.boolector SMTLib2 []---- | Default configuration for the CVC4 SMT Solver.-cvc4 :: SMTConfig-cvc4 = mkConfig CVC4.cvc4 SMTLib2 []---- | Default configuration for the Yices SMT Solver.-yices :: SMTConfig-yices = mkConfig Yices.yices SMTLib2 []---- | Default configuration for the Z3 SMT solver-z3 :: SMTConfig-z3 = mkConfig Z3.z3 SMTLib2 ["(set-option :smt.mbqi true) ; use model based quantifier instantiation"]---- | Default configuration for the MathSAT SMT solver-mathSAT :: SMTConfig-mathSAT = mkConfig MathSAT.mathSAT SMTLib2 []---- | Default configuration for the ABC synthesis and verification tool.-abc :: SMTConfig-abc = mkConfig ABC.abc SMTLib2 []---- | The default solver used by SBV. This is currently set to z3.-defaultSMTCfg :: SMTConfig-defaultSMTCfg = z3---- | A predicate is a symbolic program that returns a (symbolic) boolean value. For all intents and--- purposes, it can be treated as an n-ary function from symbolic-values to a boolean. The 'Symbolic'--- monad captures the underlying representation, and can/should be ignored by the users of the library,--- unless you are building further utilities on top of SBV itself. Instead, simply use the 'Predicate'--- type when necessary.-type Predicate = Symbolic SBool---- | A goal is a symbolic program that returns no values. The idea is that the constraints/min-max--- goals will serve as appropriate directives for sat/prove calls.-type Goal = Symbolic ()---- | A type @a@ is provable if we can turn it into a predicate.--- Note that a predicate can be made from a curried function of arbitrary arity, where--- each element is either a symbolic type or up-to a 7-tuple of symbolic-types. So--- predicates can be constructed from almost arbitrary Haskell functions that have arbitrary--- shapes. (See the instance declarations below.)-class Provable a where-  -- | Turns a value into a universally quantified predicate, internally naming the inputs.-  -- In this case the sbv library will use names of the form @s1, s2@, etc. to name these variables-  -- Example:-  ---  -- >  forAll_ $ \(x::SWord8) y -> x `shiftL` 2 .== y-  ---  -- is a predicate with two arguments, captured using an ordinary Haskell function. Internally,-  -- @x@ will be named @s0@ and @y@ will be named @s1@.-  forAll_ :: a -> Predicate-  -- | Turns a value into a predicate, allowing users to provide names for the inputs.-  -- If the user does not provide enough number of names for the variables, the remaining ones-  -- will be internally generated. Note that the names are only used for printing models and has no-  -- other significance; in particular, we do not check that they are unique. Example:-  ---  -- >  forAll ["x", "y"] $ \(x::SWord8) y -> x `shiftL` 2 .== y-  ---  -- This is the same as above, except the variables will be named @x@ and @y@ respectively,-  -- simplifying the counter-examples when they are printed.-  forAll  :: [String] -> a -> Predicate-  -- | Turns a value into an existentially quantified predicate. (Indeed, 'exists' would have been-  -- a better choice here for the name, but alas it's already taken.)-  forSome_ :: a -> Predicate-  -- | Version of 'forSome' that allows user defined names-  forSome :: [String] -> a -> Predicate--instance Provable Predicate where-  forAll_    = id-  forAll []  = id-  forAll xs  = error $ "SBV.forAll: Extra unmapped name(s) in predicate construction: " ++ intercalate ", " xs-  forSome_   = id-  forSome [] = id-  forSome xs = error $ "SBV.forSome: Extra unmapped name(s) in predicate construction: " ++ intercalate ", " xs--instance Provable SBool where-  forAll_   = return-  forAll _  = return-  forSome_  = return-  forSome _ = return--{---- The following works, but it lets us write properties that--- are not useful.. Such as: prove $ \x y -> (x::SInt8) == y--- Running that will throw an exception since Haskell's equality--- is not be supported by symbolic things. (Needs .==).-instance Provable Bool where-  forAll_  x  = forAll_   (if x then true else false :: SBool)-  forAll s x  = forAll s  (if x then true else false :: SBool)-  forSome_  x = forSome_  (if x then true else false :: SBool)-  forSome s x = forSome s (if x then true else false :: SBool)--}---- Functions-instance (SymWord a, Provable p) => Provable (SBV a -> p) where-  forAll_        k = forall_   >>= \a -> forAll_   $ k a-  forAll (s:ss)  k = forall s  >>= \a -> forAll ss $ k a-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ k a-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ k a-  forSome []     k = forSome_ k---- SFunArrays (memory, functional representation), only supported universally for the time being-instance (HasKind a, HasKind b, Provable p) => Provable (SArray a b -> p) where-  forAll_       k = declNewSArray (\t -> "array_" ++ show t) Nothing >>= \a -> forAll_   $ k a-  forAll (s:ss) k = declNewSArray (const s)                  Nothing >>= \a -> forAll ss $ k a-  forAll []     k = forAll_ k-  forSome_      _ = error "SBV.forSome: Existential arrays are not currently supported."-  forSome _     _ = error "SBV.forSome: Existential arrays are not currently supported."---- SArrays (memory, SMT-Lib notion of arrays), only supported universally for the time being-instance (HasKind a, HasKind b, Provable p) => Provable (SFunArray a b -> p) where-  forAll_       k = declNewSFunArray Nothing >>= \a -> forAll_   $ k a-  forAll (_:ss) k = declNewSFunArray Nothing >>= \a -> forAll ss $ k a-  forAll []     k = forAll_ k-  forSome_      _ = error "SBV.forSome: Existential arrays are not currently supported."-  forSome _     _ = error "SBV.forSome: Existential arrays are not currently supported."---- 2 Tuple-instance (SymWord a, SymWord b, Provable p) => Provable ((SBV a, SBV b) -> p) where-  forAll_        k = forall_  >>= \a -> forAll_   $ \b -> k (a, b)-  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b -> k (a, b)-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b -> k (a, b)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b -> k (a, b)-  forSome []     k = forSome_ k---- 3 Tuple-instance (SymWord a, SymWord b, SymWord c, Provable p) => Provable ((SBV a, SBV b, SBV c) -> p) where-  forAll_       k  = forall_  >>= \a -> forAll_   $ \b c -> k (a, b, c)-  forAll (s:ss) k  = forall s >>= \a -> forAll ss $ \b c -> k (a, b, c)-  forAll []     k  = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b c -> k (a, b, c)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c -> k (a, b, c)-  forSome []     k = forSome_ k---- 4 Tuple-instance (SymWord a, SymWord b, SymWord c, SymWord d, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d) -> p) where-  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d -> k (a, b, c, d)-  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d -> k (a, b, c, d)-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d -> k (a, b, c, d)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d -> k (a, b, c, d)-  forSome []     k = forSome_ k---- 5 Tuple-instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) where-  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d e -> k (a, b, c, d, e)-  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d e -> k (a, b, c, d, e)-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d e -> k (a, b, c, d, e)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e -> k (a, b, c, d, e)-  forSome []     k = forSome_ k---- 6 Tuple-instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) where-  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d e f -> k (a, b, c, d, e, f)-  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d e f -> k (a, b, c, d, e, f)-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d e f -> k (a, b, c, d, e, f)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e f -> k (a, b, c, d, e, f)-  forSome []     k = forSome_ k---- 7 Tuple-instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SymWord g, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) where-  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d e f g -> k (a, b, c, d, e, f, g)-  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d e f g -> k (a, b, c, d, e, f, g)-  forAll []      k = forAll_ k-  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d e f g -> k (a, b, c, d, e, f, g)-  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e f g -> k (a, b, c, d, e, f, g)-  forSome []     k = forSome_ k---- | Prove a predicate, equivalent to @'proveWith' 'defaultSMTCfg'@-prove :: Provable a => a -> IO ThmResult-prove = proveWith defaultSMTCfg---- | Find a satisfying assignment for a predicate, equivalent to @'satWith' 'defaultSMTCfg'@-sat :: Provable a => a -> IO SatResult-sat = satWith defaultSMTCfg---- | Return all satisfying assignments for a predicate, equivalent to @'allSatWith' 'defaultSMTCfg'@.--- Satisfying assignments are constructed lazily, so they will be available as returned by the solver--- and on demand.------ NB. Uninterpreted constant/function values and counter-examples for array values are ignored for--- the purposes of @'allSat'@. That is, only the satisfying assignments modulo uninterpreted functions and--- array inputs will be returned. This is due to the limitation of not having a robust means of getting a--- function counter-example back from the SMT solver.-allSat :: Provable a => a -> IO AllSatResult-allSat = allSatWith defaultSMTCfg---- | Optimize a given collection of `Objective`s-optimize :: Provable a => a -> IO OptimizeResult-optimize = optimizeWith defaultSMTCfg---- | Check that all the 'sAssert' calls are safe, equivalent to @'safeWith' 'defaultSMTCfg'@-safe :: SExecutable a => a -> IO [SafeResult]-safe = safeWith defaultSMTCfg---- | Check if the given constraints are satisfiable, equivalent to @'isVacuousWith' 'defaultSMTCfg'@.--- See the function 'constrain' for an example use of 'isVacuous'. Also see the 'CheckConstrVacuity'--- tactic.-isVacuous :: Provable a => a -> IO Bool-isVacuous = isVacuousWith defaultSMTCfg---- Decision procedures (with optional timeout)---- | Check whether a given property is a theorem, with an optional time out and the given solver.--- Returns @Nothing@ if times out, or the result wrapped in a @Just@ otherwise.-isTheoremWith :: Provable a => SMTConfig -> Maybe Int -> a -> IO (Maybe Bool)-isTheoremWith cfg mbTo p = do r <- proveWith cfg{timeOut = mbTo} p-                              case r of-                                ThmResult Unsatisfiable{} -> return $ Just True-                                ThmResult Satisfiable{}   -> return $ Just False-                                ThmResult TimeOut{}       -> return Nothing-                                _                         -> error $ "SBV.isTheorem: Received:\n" ++ show r---- | Check whether a given property is satisfiable, with an optional time out and the given solver.--- Returns @Nothing@ if times out, or the result wrapped in a @Just@ otherwise.-isSatisfiableWith :: Provable a => SMTConfig -> Maybe Int -> a -> IO (Maybe Bool)-isSatisfiableWith cfg mbTo p = do r <- satWith cfg{timeOut = mbTo} p-                                  case r of-                                    SatResult Satisfiable{}   -> return $ Just True-                                    SatResult Unsatisfiable{} -> return $ Just False-                                    SatResult TimeOut{}       -> return Nothing-                                    _                         -> error $ "SBV.isSatisfiable: Received: " ++ show r---- | Checks theoremhood within the given optional time limit of @i@ seconds.--- Returns @Nothing@ if times out, or the result wrapped in a @Just@ otherwise.-isTheorem :: Provable a => Maybe Int -> a -> IO (Maybe Bool)-isTheorem = isTheoremWith defaultSMTCfg---- | Checks satisfiability within the given optional time limit of @i@ seconds.--- Returns @Nothing@ if times out, or the result wrapped in a @Just@ otherwise.-isSatisfiable :: Provable a => Maybe Int -> a -> IO (Maybe Bool)-isSatisfiable = isSatisfiableWith defaultSMTCfg---- | Compiles to SMT-Lib and returns the resulting program as a string. Useful for saving--- the result to a file for off-line analysis, for instance if you have an SMT solver that's not natively--- supported out-of-the box by the SBV library. It takes two arguments:------    * version: The SMTLib-version to produce. Note that we currently only support SMTLib2.------    * isSat  : If 'True', will translate it as a SAT query, i.e., in the positive. If 'False', will---               translate as a PROVE query, i.e., it will negate the result. (In this case, the check-sat---               call to the SMT solver will produce UNSAT if the input is a theorem, as usual.)-compileToSMTLib :: Provable a => SMTLibVersion   -- ^ Version of SMTLib to compile to. (Only SMTLib2 supported currently.)-                              -> Bool            -- ^ If True, translate directly, otherwise negate the goal. (Use True for SAT queries, False for PROVE queries.)-                              -> a-                              -> IO String-compileToSMTLib version isSat a = do-        t <- getClockTime-        let comments = ["Created on " ++ show t]-            cvt = case version of-                    SMTLib2 -> toSMTLib2-        SMTProblem{smtLibPgm} <- simulate cvt defaultSMTCfg isSat comments a-        let out = show (smtLibPgm defaultSMTCfg NoCase)-        return $ out ++ "\n(check-sat)\n"---- | Create SMT-Lib benchmarks, for supported versions of SMTLib. The first argument is the basename of the file.--- 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. (See the second boolean argument to--- 'compileToSMTLib' for details.)-generateSMTBenchmarks :: Provable a => Bool -> FilePath -> a -> IO ()-generateSMTBenchmarks isSat f a = mapM_ gen [minBound .. maxBound]-  where gen v = do s <- compileToSMTLib v isSat a-                   let fn = f `addExtension` smtLibVersionExtension v-                   writeFile fn s-                   putStrLn $ "Generated " ++ show v ++ " benchmark " ++ show fn ++ "."---- | Make sure we're line-buffering if there's going to be parallel calls.-bufferSanity :: Bool -> IO a -> IO a-bufferSanity False a = a-bufferSanity True  a = bracket before after (const a)-  where before = do b <- hGetBuffering stdout-                    hSetBuffering stdout LineBuffering-                    return b-        after b = do hFlush stdout-                     hSetBuffering stdout b-                     hFlush stdout---- | Make sure sat/prove calls don't have objectives, and optimize does!-objectiveCheck :: Bool -> [Objective a] -> String -> IO ()-objectiveCheck False [] _ = return ()-objectiveCheck False os w = error $ unlines $ ("\n*** Unsupported call to " ++ show w ++ " in the presence of objective(s):")-                                            : [ "***\t" ++ intercalate ", " (map objectiveName os)-                                              , "*** Use \"optimize\" to optimize for these objectives instead of " ++ show w-                                              ]-objectiveCheck True []  w = error $ "*** Unsupported call to " ++ w ++ " when no objectives are present. Use \"sat\" for plain satisfaction"-objectiveCheck True _   _ = return ()---- | Pick the converter, based on the SMTLib version. Note that--- we no longer support SMTLib1, so the following is more or less a no-op,--- but it's good to use it since if we add some other target GHC's pattern-match--- warning will point us to here.-getConverter :: SMTConfig -> SMTLibConverter-getConverter SMTConfig{smtLibVersion} = case smtLibVersion of-                                          SMTLib2 -> toSMTLib2---- | Proves the predicate using the given SMT-solver-proveWith :: Provable a => SMTConfig -> a -> IO ThmResult-proveWith config a = do simRes@SMTProblem{tactics, objectives} <- simulate (getConverter config) config False [] a-                        objectiveCheck False objectives "prove"-                        let hasPar = any isParallelCaseAnywhere tactics-                        bufferSanity hasPar $ applyTactics config (False, hasPar) (wrap, unwrap) [] tactics objectives $ callSolver False "Checking Theoremhood.." [] mwrap simRes-  where wrap                 = ThmResult-        unwrap (ThmResult r) = r--        mwrap [r] = wrap r-        mwrap xs  = error $ "SBV.proveWith: Backend solver returned a non-singleton answer:\n" ++ show (map ThmResult xs)---- | Find a satisfying assignment using the given SMT-solver-satWith :: Provable a => SMTConfig -> a -> IO SatResult-satWith config a = do simRes@SMTProblem{tactics, objectives} <- simulate (getConverter config) config True [] a-                      objectiveCheck False objectives "sat"-                      let hasPar = any isParallelCaseAnywhere tactics-                      bufferSanity hasPar $ applyTactics config (True, hasPar) (wrap, unwrap) [] tactics objectives $ callSolver True "Checking Satisfiability.." [] mwrap simRes-  where wrap                 = SatResult-        unwrap (SatResult r) = r--        mwrap [r] = wrap r-        mwrap xs  = error $ "SBV.satWith: Backend solver returned a non-singleton answer:\n" ++ show (map SatResult xs)---- | Optimizes the objectives using the given SMT-solver-optimizeWith :: Provable a => SMTConfig -> a -> IO OptimizeResult-optimizeWith config a = do-        msg "Optimizing.."-        sbvPgm@SMTProblem{objectives, tactics} <- simulate (getConverter config) config True [] a--        objectiveCheck True objectives "optimize"--        let hasPar  = any isParallelCaseAnywhere tactics-            style = case nub [s | OptimizePriority s <- tactics] of-                      []  -> Lexicographic-                      [s] -> s-                      ss  -> error $ "SBV: Multiple optimization priorities found: " ++ intercalate ", " (map show ss) ++ ". Please use only one."---            optimizer = case style of-               Lexicographic -> optLexicographic-               Independent   -> optIndependent-               Pareto        -> optPareto--        optimizer hasPar config sbvPgm--  where msg = when (verbose config) . putStrLn . ("** " ++)---- | Construct a lexicographic optimization result-optLexicographic :: Bool -> SMTConfig -> SMTProblem -> IO OptimizeResult-optLexicographic hasPar config sbvPgm@SMTProblem{objectives, tactics} = do-        result <- bufferSanity hasPar $ applyTactics config (True, hasPar) (id, id) [] tactics objectives $ callSolver True "Lexicographically optimizing.." [] mwrap sbvPgm-        return $ LexicographicResult result--  where mwrap [r] = r-        mwrap xs  = error $ "SBV.optLexicographic: Backend solver returned a non-singleton answer:\n" ++ show (map SatResult xs)---- | Construct an independent optimization result-optIndependent :: Bool -> SMTConfig -> SMTProblem -> IO OptimizeResult-optIndependent hasPar config sbvPgm@SMTProblem{objectives, tactics} = do-        let ns = map objectiveName objectives-        result <- bufferSanity hasPar $ applyTactics config (True, hasPar) (wrap ns, unwrap) [] tactics objectives $ callSolver True "Independently optimizing.." [] mwrap sbvPgm-        return $ IndependentResult result--  where wrap :: [String] -> SMTResult -> [(String, SMTResult)]-        wrap ns r = zip ns (repeat r)--        -- the role of unwrap here is to take the result with more info in case a case-split is-        -- performed and we need to decide in a SAT context.-        unwrap :: [(String, SMTResult)] -> SMTResult-        unwrap xs = case [r | (_, r@Satisfiable{}) <- xs] ++ [r | (_, r@SatExtField{}) <- xs] ++ map snd xs of-                     (r:_) -> r-                     []    -> error "SBV.optIndependent: Impossible happened: Received no results!"--        mwrap xs-         | lobs == lxs = zip (map objectiveName objectives) xs-         | True        = error $ "SBV.optIndependent: Expected " ++ show lobs ++ " objective results, but received: " ++ show lxs ++ ":\n" ++ show (map SatResult xs)-         where lxs  = length xs-               lobs = length objectives---- | Construct a pareto-front optimization result-optPareto :: Bool -> SMTConfig -> SMTProblem -> IO OptimizeResult-optPareto hasPar config sbvPgm@SMTProblem{objectives, tactics} = do-        result <- bufferSanity hasPar $ applyTactics config (True, hasPar) (wrap, unwrap) [] tactics objectives $ callSolver True "Pareto optimizing.." [] id sbvPgm-        return $ ParetoResult result--  where wrap :: SMTResult -> [SMTResult]-        wrap r = [r]--        -- the role of unwrap here is to take the result with more info in case a case-split is-        -- performed and we need to decide in a SAT context.-        unwrap :: [SMTResult] -> SMTResult-        unwrap xs = case [r | r@Satisfiable{} <- xs] ++ [r | r@SatExtField{} <- xs] ++ xs of-                     (r:_) -> r-                     []    -> error "SBV.optPareto: Impossible happened: Received no results!"---- | Apply the given tactics to a problem-applyTactics :: SMTConfig                                                       -- ^ Solver configuration-             -> (Bool, Bool)                                                    -- ^ Are we a sat-problem? Do we have anything parallel going on? (Parallel-case split.)-             -> (SMTResult -> res, res -> SMTResult)                            -- ^ Wrapper/unwrapper pair from result to SMT answer-             -> [(String, (String, SW))]                                        -- ^ Level at which we are called. (In case of a nested case-split)-             -> [Tactic SW]                                                     -- ^ Tactics active at this level-             -> [Objective (SW, SW)]                                            -- ^ Optimization goals we have-             -> (SMTConfig -> Maybe (OptimizeStyle, Int) -> CaseCond -> IO res) -- ^ The actual continuation at this point-             -> IO res-applyTactics cfgIn (isSat, hasPar) (wrap, unwrap) levels tactics objectives cont-   = do ---        -- TODO: The management of tactics here is quite adhoc. We should have a better story-        -- Currently, we:-        ---        --      - Perform optimization (which requires sat and no case-splitting)-        --      - Check for vacuity if asked-        --      - Do case-splitting-        ---        -- If we have more interesting tactics, we'll have to come up with a better "proof manager." The current-        -- code is sufficient, however, for the use cases we have now.--        -- check that if we have objectives, then we must be sat and there must be no case-splits-        when (hasObjectives && not isSat)     $ error "SBV: Optimization is only available for sat calls."-        when (hasObjectives && hasCaseSplits) $ error "SBV: Optimization and case-splits are not supported together."--        let mbOptInfo-                | not hasObjectives = Nothing-                | True              = Just (optimizePriority, length objectives)--        if hasObjectives--           then cont (finalOptConfig objectives) mbOptInfo (Opt objectives)--           else do -- Check vacuity if asked. If result is Nothing, it means we're good to go.-                   mbRes <- if not shouldCheckConstrVacuity-                            then return Nothing-                            else constraintVacuityCheck isSat finalConfig mbOptInfo (wrap, unwrap) cont--                   -- Do case split, if vacuity said continue-                   case mbRes of-                     Just r  -> return r-                     Nothing -> if null caseSplits-                                then cont finalConfig mbOptInfo (CasePath (map (snd . snd) levels))-                                else caseSplit finalConfig mbOptInfo shouldCheckCaseVacuity (parallelCase, hasPar) isSat (wrap, unwrap) levels chatty cases cont--  where (caseSplits, checkCaseVacuity, parallelCases, checkConstrVacuity, timeOuts, checkUsing, useLogics, useSolvers, optimizePriorities)-                = foldr (flip classifyTactics) ([], [], [], [], [], [], [], [], []) tactics--        classifyTactics (a, b, c, d, e, f, g, h, i) = \case-                    t@CaseSplit{}           -> (t:a,   b,   c,   d,   e,   f,   g,   h,   i)-                    t@CheckCaseVacuity{}    -> (  a, t:b,   c,   d,   e,   f,   g,   h,   i)-                    t@ParallelCase{}        -> (  a,   b, t:c,   d,   e,   f,   g,   h,   i)-                    t@CheckConstrVacuity{}  -> (  a,   b,   c, t:d,   e,   f,   g,   h,   i)-                    t@StopAfter{}           -> (  a,   b,   c,   d, t:e,   f,   g,   h,   i)-                    t@CheckUsing{}          -> (  a,   b,   c,   d,   e, t:f,   g,   h,   i)-                    t@UseLogic{}            -> (  a,   b,   c,   d,   e,   f, t:g,   h,   i)-                    t@UseSolver{}           -> (  a,   b,   c,   d,   e,   f,   g, t:h,   i)-                    t@OptimizePriority{}    -> (  a,   b,   c,   d,   e,   f,   g,   h, t:i)--        hasObjectives = not $ null objectives--        hasCaseSplits = not $ null cases--        parallelCase = not $ null parallelCases--        optimizePriority = case [s | OptimizePriority s <- optimizePriorities] of-                             []  -> Lexicographic-                             [s] -> s-                             ss  -> error $ "SBV.OptimizePriority: Multiple optimization priorities found, at most one is allowed: " ++ intercalate "," (map show ss)--        shouldCheckCaseVacuity = case [b | CheckCaseVacuity b <- checkCaseVacuity] of-                                   [] -> True   -- default is to check-case-vacuity-                                   bs -> or bs  -- otherwise check vacuity if we're asked to do so--        -- for constraint vacuity, default is *not* to check; so a simple or suffices-        shouldCheckConstrVacuity = or [b | CheckConstrVacuity b <- checkConstrVacuity]--        (chatty, cases) = let (vs, css) = unzip [(v, cs) | CaseSplit v cs <- caseSplits] in (or (verbose cfgIn : vs), concat css)--        grabStops c = case [i | StopAfter i <- timeOuts] of-                        [] -> c-                        xs -> c {timeOut = Just (maximum xs)}--        grabCheckUsing c = case [s | CheckUsing s <- checkUsing] of-                             []  -> c-                             [s] -> c {satCmd = "(check-sat-using " ++ s ++ ")"}-                             ss  -> c {satCmd = "(check-sat-using (then " ++ unwords ss ++ "))"}--        grabUseLogic c = case [l | UseLogic l <- useLogics] of-                           [] -> c-                           ss -> c { useLogic = Just (last ss) }--        configToUse = case [s | UseSolver s <- useSolvers] of-                        []  -> cfgIn-                        [s] -> s-                        ss  -> error $ "SBV.UseSolver: Multiple UseSolver tactics found, at most one is allowed: " ++ intercalate "," (map show ss)--        finalConfig = grabUseLogic . grabCheckUsing . grabStops $ configToUse--        finalOptConfig goals = finalConfig { optimizeArgs  = optimizeArgs finalConfig ++ optimizerDirectives }-            where optimizerDirectives-                        | hasObjectives = map minmax goals ++ style optimizePriority-                        | True          = []--                  minmax (Minimize   _  (_, v))     = "(minimize "    ++ show v ++ ")"-                  minmax (Maximize   _  (_, v))     = "(maximize "    ++ show v ++ ")"-                  minmax (AssertSoft nm (_, v) mbp) = "(assert-soft " ++ show v ++ penalize mbp ++ ")"-                    where penalize DefaultPenalty    = ""-                          penalize (Penalty w mbGrp)-                             | w <= 0         = error $ unlines [ "SBV.AssertSoft: Goal " ++ show nm ++ " is assigned a non-positive penalty: " ++ shw-                                                                , "All soft goals must have > 0 penalties associated."-                                                                ]-                             | True           = " :weight " ++ shw ++ maybe "" group mbGrp-                             where shw = show (fromRational w :: Double)-                          group g = " :id " ++ g--                  style Lexicographic = [] -- default, no option needed-                  style Independent   = ["(set-option :opt.priority box)"]-                  style Pareto        = [ "(set-option :opt.priority pareto)"-                                        , "(set-option :opt.print_model true)"-                                        ]---- | Implements the "constraint vacuity check" tactic, making sure the calls to "constrain"--- describe a satisfiable condition. Returns:------    - Nothing if this is a SAT call, as that would be a weird thing to do (we only would care about constraint-vacuity in a proof context),---    - Nothing if satisfiable: The world is OK, just keep moving---    - ProofError if unsatisfiable. In this case we found that the constraints given are just bad!------ NB. We'll do a SAT call even if there are *no* constraints! This is OK, as the call will be cheap; and this is an opt-in call. (i.e.,--- the user asked us to do it explicitly.)-constraintVacuityCheck :: forall res.-                          Bool                                                            -- ^ isSAT?-                       -> SMTConfig                                                       -- ^ config-                       -> Maybe (OptimizeStyle, Int)                                      -- ^ optimization info-                       -> (SMTResult -> res, res -> SMTResult)                            -- ^ wrappers back and forth from final result-                       -> (SMTConfig -> Maybe (OptimizeStyle, Int) -> CaseCond -> IO res) -- ^ continuation-                       -> IO (Maybe res)                                                  -- ^ result, wrapped in Maybe if vacuity fails-constraintVacuityCheck True  _      _ _              _ = return Nothing -- for a SAT check, vacuity is meaningless (what would be the point)?-constraintVacuityCheck False config d (wrap, unwrap) f = do-               res <- f config d CstrVac-               case unwrap res of-                 Satisfiable{} -> return Nothing-                 _             -> return $ Just $ wrap vacuityFailResult-  where vacuityFailResult = ProofError config [ "Constraint vacuity check failed."-                                              , "User given constraints are not satisfiable."-                                              ]---- | Implements the case-split tactic. Works for both Sat and Proof, hence the quantification on @res@-caseSplit :: forall res.-             SMTConfig                                                       -- ^ Solver config-          -> Maybe (OptimizeStyle, Int)                                      -- ^ Are we optimizing?-          -> Bool                                                            -- ^ Should we check vacuity of cases?-          -> (Bool, Bool)                                                    -- ^ Should we run the cases in parallel? Second bool: Is anything parallel going on?-          -> Bool                                                            -- ^ True if we're sat solving-          -> (SMTResult -> res, res -> SMTResult)                            -- ^ wrapper, unwrapper from sat/proof to the actual result-          -> [(String, (String, SW))]                                        -- ^ Path condition as we reached here. (In a nested case split, First #, then actual name.)-          -> Bool                                                            -- ^ Should we be chatty on the case-splits?-          -> [(String, SW, [Tactic SW])]                                     -- ^ List of cases. Case name, condition, plus further tactics for nested case-splitting etc.-          -> (SMTConfig -> Maybe (OptimizeStyle, Int) -> CaseCond -> IO res) -- ^ The "solver" once we provide it with a problem and a case-          -> IO res-caseSplit config mbOptInfo checkVacuity (runParallel, hasPar) isSAT (wrap, unwrap) level chatty cases cont-     | runParallel = goParallel tasks-     | True        = goSerial   tasks--  where tasks = zip caseNos cases--        lids = map fst level--        noOfCases = length cases-        casePad   = length (show noOfCases)--        tagLength = maximum $ map length $ "Coverage" : [s | (s, _, _) <- cases]-        showTag t = take tagLength (t ++ repeat ' ')--        shCaseId i = let si = show i in replicate (casePad - length si) ' ' ++ si--        caseNos = map shCaseId [(1::Int) .. ]--        tag tagChar = replicate 2 tagChar ++ replicate (2 * length level) tagChar--        mkCaseNameBase s i = "Case "     ++ intercalate "." (lids ++ [i]) ++ ": " ++ showTag s-        mkCovNameBase      = "Coverage " ++ replicate (casePad - 1) ' ' ++ "X"--        mkCaseName tagChar s i = tag tagChar ++ ' ' : mkCaseNameBase s i-        mkCovName  tagChar     = tag tagChar ++ ' ' : mkCovNameBase--        startCase :: Bool -> Maybe (String, String) -> IO ()-        startCase multi mbis-           | not chatty          = return ()-           | Just (i, s) <- mbis = printer $ mkCaseName tagChar s i ++ start-           | True                = printer $ mkCovName  tagChar     ++ start-           where line = multi || hasPar--                 printer | line = putStrLn-                         | True = putStr-                 tagChar | line = '>'-                         | True = '*'-                 start          = " [Started]"--        vacuityMsg :: Maybe Bool -> Bool -> (String, String) -> IO ()-        vacuityMsg mbGood multi (i, s)-           | not chatty = return ()-           | line       = putStrLn $ mkCaseName '=' s i ++ msg-           | True       = printer                          msg-           where line = multi || hasPar-                 printer-                   | failed = putStrLn-                   | True   = putStr-                 (failed, msg) = case mbGood of-                                   Nothing    -> (False, " [Vacuity Skipped]")-                                   Just True  -> (False, " [Vacuity OK]")-                                   Just False -> (True,  " [Vacuity Failed]")--        endCase :: Bool -> Maybe (String, String) -> String -> IO ()-        endCase multi mbis msg-           | not chatty          = return ()-           | not line            = putStrLn $ ' ' : msg-           | Just (i, s) <- mbis = putStrLn $ mkCaseName '<' s i ++ ' ' : msg-           | True                = putStrLn $ mkCovName  '<'     ++ ' ' : msg-           where line = multi || hasPar--        ------------------------------------------------------------------------------------------------------------------        -- Serial case analysis-        ------------------------------------------------------------------------------------------------------------------        goSerial :: [(String, (String, SW, [Tactic SW]))] -> IO res-        goSerial []-           -- At the end, we do a coverage call-           = do let multi = runParallel-                startCase multi Nothing-                res <- cont config mbOptInfo (CaseCov (map (snd . snd) level) [c | (_, c, _) <- cases])-                decideSerial multi Nothing (unwrap res) (return res)-        goSerial ((i, (nm, cond, ts)):cs)-           -- Still going down, do a regular call-           = do let multi = not . null $ [() | CaseSplit{} <- ts]-                    mbis  = Just (i, nm)-                startCase multi mbis-                continue <- if isSAT   -- for a SAT check, vacuity is meaningless (what would be the point)?-                            then return True-                            else if checkVacuity-                                 then do res <- cont config mbOptInfo (CaseVac (map (snd . snd) level) cond)-                                         case unwrap res of-                                           Satisfiable{} -> vacuityMsg (Just True)  multi (i, nm) >> return True-                                           _             -> vacuityMsg (Just False) multi (i, nm) >> return False-                                 else vacuityMsg Nothing  multi (i, nm) >> return True-                if continue-                   then do res <- applyTactics config (isSAT, hasPar) (wrap, unwrap) (level ++ [(i, (nm, cond))]) ts [] cont-                           decideSerial multi mbis (unwrap res) (goSerial cs)-                   else return $ wrap $ vacuityFailResult (i, nm)--        vacuityFailResult cur = ProofError config $ [ "Vacuity check failed."-                                                    , "Case constraint not satisfiable. Leading path:"-                                                    ]-                                                 ++ map ("    " ++) (align ([(i, n) | (i, (n, _)) <- level] ++ [cur]))-                                                 ++ ["HINT: Try \"CheckCaseVacuity False\" tactic to ignore case vacuity checks."]-          where align :: [(String, String)] -> [String]-                align path = map join cpath-                  where len = maximum (0 : map (length . fst) cpath)-                        join (c, n) = reverse (take len (reverse c ++ repeat ' ')) ++ ": " ++ n--                        cpath = [(intercalate "." (reverse ls), j) | (ls, j) <- cascade [] path]--                        trim = reverse . dropWhile isSpace . reverse . dropWhile isSpace-                        cascade _     []              = []-                        cascade sofar ((i, j) : rest) = let new = trim i : sofar in (new, j) : cascade new rest--        decideSerial-         | isSAT = decideSerialSAT-         | True  = decideSerialProof--        -- short name-        diag Unsatisfiable{} = "[Unsatisfiable]"-        diag Satisfiable  {} = "[Satisfiable]"-        diag SatExtField  {} = "[Satisfiable in Field Extension]"-        diag Unknown      {} = "[Unknown]"-        diag ProofError   {} = "[ProofError]"-        diag TimeOut      {} = "[TimeOut]"--        -- If we're SAT, we stop at first satisfiable and report back. Otherwise continue.-        -- Note that we also stop if we get a ProofError, as that clearly is not OK-        decideSerialSAT :: Bool -> Maybe (String, String) -> SMTResult -> IO res -> IO res-        decideSerialSAT multi mbis r@Satisfiable{} _ = endCase multi mbis (diag r) >> return (wrap r)-        decideSerialSAT multi mbis r@ProofError{}  _ = endCase multi mbis (diag r) >> return (wrap r)-        decideSerialSAT multi mbis r               k = endCase multi mbis (diag r) >> k--        -- If we're Prove, we stop at first *not* unsatisfiable and report back. Otherwise continue.-        decideSerialProof :: Bool -> Maybe (String, String) -> SMTResult -> IO res -> IO res-        decideSerialProof multi mbis Unsatisfiable{} k = endCase multi mbis "[Proved]" >> k-        decideSerialProof multi mbis r               _ = endCase multi mbis "[Failed]" >> return (wrap r)--        ------------------------------------------------------------------------------------------------------------------        -- Parallel case analysis-        ------------------------------------------------------------------------------------------------------------------        goParallel :: [(String, (String, SW, [Tactic SW]))] -> IO res-        goParallel cs = do-             when chatty $ putStrLn $ topName '>' "[Starting]"--             -- Create the case claim:-             let mkTask (i, (nm, cond, ts)) =-                  let caseProof = do continue <- if isSAT   -- for a SAT check, vacuity is meaningless (what would be the point)?-                                                 then return True-                                                 else if checkVacuity-                                                      then do res <- cont config mbOptInfo (CaseVac (map (snd . snd) level) cond)-                                                              case unwrap res of-                                                                Satisfiable{} -> return True-                                                                _             -> return False-                                                      else return True-                                     if continue-                                        then unwrap `fmap` applyTactics config (isSAT, hasPar) (wrap, unwrap) (level ++ [(i, (nm, cond))]) ts [] cont-                                        else return $ vacuityFailResult (i, nm)-                  in (mkCaseNameBase nm i, caseProof)--             -- Create the coverage claim-             let cov = unwrap `fmap` cont config mbOptInfo (CaseCov (map (snd . snd) level) [c | (_, c, _) <- cases])--             (decidingTag, res) <- decideParallel $ map mkTask cs ++ [(mkCovNameBase, cov)]--             let trim = reverse . dropWhile isSpace . reverse . dropWhile isSpace--             let caseMsg-                  | isSAT = satMsg-                  | True  = proofMsg-                  where addTag x = x ++ " (at " ++ trim decidingTag ++ ")"-                        (satMsg, proofMsg) =  case res of-                                                Unsatisfiable{} -> ("[Unsatisfiable]", "[Proved]")-                                                Satisfiable{}   -> (addTag "[Satisfiable]",   addTag "[Failed]")-                                                _               -> let d = diag res in (addTag d, addTag d)--             when chatty $ putStrLn $ topName '<' caseMsg--             return $ wrap res--            where topName c w  = tag c ++ topTag ++ " Parallel case split: " ++ range ++ ": " ++ w--                  topTag = " Case" ++ s ++ intercalate "." lids ++ dot ++ "[1-" ++ show (length cs + 1) ++ "]:"-                    where dot | null lids = ""-                              | True      = "."-                          s   | null cs   = " "-                              | True      = "s "--                  range   = case cs of-                              []  -> "Coverage"-                              [_] -> "One case and coverage"-                              xs  -> show (length xs) ++ " cases and coverage"--        -- Parallel decision:-        --      - If SAT:   Run all cases in parallel and return a SAT result from any. If none-of-them is SAT, then we return the last finishing-        --      - If Prove: Run all cases in parallel and return the last one if all return UNSAT. Otherwise return the first SAT one.-        decideParallel :: [(String, IO SMTResult)] -> IO (String, SMTResult)-        decideParallel caseTasks = mapM try caseTasks >>= pick-          where try (nm, task) = async $ task >>= \r -> return (nm, r)--                pick :: [Async (String, SMTResult)] -> IO (String, SMTResult)-                pick []  = error "SBV.caseSplit.decideParallel: Impossible happened, ran out of proofs!"-                pick [a] = wait a-                pick as  = do (d, r) <- waitAny as-                              let others   = filter (/= d) as-                                  continue = pick others-                                  stop     = mapM_ cancel others >> return r-                              case snd r of-                                Unsatisfiable{} -> continue-                                Satisfiable{}   -> stop-                                SatExtField{}   -> stop-                                ProofError{}    -> stop-                                Unknown{}       -> if isSAT then continue else stop-                                TimeOut{}       -> if isSAT then continue else stop---- | Check if any of the assertions can be violated-safeWith :: SExecutable a => SMTConfig -> a -> IO [SafeResult]-safeWith cfg a = do-        res@Result{resAssertions=asserts} <- runSymbolic (True, cfg) $ sName_ a >>= output-        mapM (verify res) asserts-  where locInfo (Just ps) = Just $ let loc (f, sl) = concat [srcLocFile sl, ":", show (srcLocStartLine sl), ":", show (srcLocStartCol sl), ":", f]-                                   in intercalate ",\n " (map loc ps)-        locInfo _         = Nothing-        verify res (msg, cs, cond) = do result <- runProofOn (getConverter cfg) cfg True [] pgm >>= \p -> callSolver True msg [] mwrap p cfg Nothing NoCase-                                        return $ SafeResult (locInfo (getCallStack `fmap` cs), msg, result)-           where pgm = res { resInputs  = [(EX, n) | (_, n) <- resInputs res]   -- make everything existential-                           , resOutputs = [cond]-                           }-                 mwrap [r] = r-                 mwrap xs  = error $ "SBV.safeWith: Backend solver returned a non-singleton answer:\n" ++ show (map SatResult xs)---- | Check if a safe-call was safe or not, turning a 'SafeResult' to a Bool.-isSafe :: SafeResult -> Bool-isSafe (SafeResult (_, _, result)) = case result of-                                       Unsatisfiable{} -> True-                                       Satisfiable{}   -> False-                                       SatExtField{}   -> False   -- conservative-                                       Unknown{}       -> False   -- conservative-                                       ProofError{}    -> False   -- conservative-                                       TimeOut{}       -> False   -- conservative---- | Determine if the constraints are vacuous using the given SMT-solver. Also see--- the 'CheckConstrVacuity' tactic.-isVacuousWith :: Provable a => SMTConfig -> a -> IO Bool-isVacuousWith config a = do-        Result ki tr uic is cs ts as uis ax asgn cstr tactics goals asserts _out <- runSymbolic (True, config) $ forAll_ a >>= output-        case cstr of-           [] -> return False -- no constraints, no need to check-           _  -> do let is'  = [(EX, i) | (_, i) <- is] -- map all quantifiers to "exists" for the constraint check-                        res' = Result ki tr uic is' cs ts as uis ax asgn cstr tactics goals asserts [trueSW]-                    result <- runProofOn (getConverter config) config True [] res' >>= \p -> callSolver True "Checking Vacuity.." [] mwrap p config Nothing NoCase-                    case result of-                      Unsatisfiable{} -> return True  -- constraints are unsatisfiable!-                      Satisfiable{}   -> return False -- constraints are satisfiable!-                      SatExtField{}   -> error "SBV: isVacuous: Solver returned a model in the extension field!"-                      Unknown{}       -> error "SBV: isVacuous: Solver returned unknown!"-                      ProofError _ ls -> error $ "SBV: isVacuous: error encountered:\n" ++ unlines ls-                      TimeOut _       -> error "SBV: isVacuous: time-out."-        where mwrap [r] = r-              mwrap xs  = error $ "SBV.isVacuousWith: Backend solver returned a non-singleton answer:\n" ++ show (map SatResult xs)---- | Find all satisfying assignments using the given SMT-solver-allSatWith :: Provable a => SMTConfig -> a -> IO AllSatResult-allSatWith config p = do-        msg "Checking Satisfiability, all solutions.."-        sbvPgm@SMTProblem{smtInputs=qinps, kindsUsed=ki} <- simulate (getConverter config) config True [] p-        let usorts = [s | us@(KUserSort s _) <- Set.toList ki, isFree us]-                where isFree (KUserSort _ (Left _)) = True-                      isFree _                      = False-        unless (null usorts) $ msg $  "SBV.allSat: Uninterpreted sorts present: " ++ unwords usorts-                                   ++ "\n               SBV will use equivalence classes to generate all-satisfying instances."-        results <- unsafeInterleaveIO $ go sbvPgm (1::Int) []-        -- See if there are any existentials below any universals-        -- If such is the case, then the solutions are unique upto prefix existentials-        let w = ALL `elem` map fst qinps-        return $ AllSatResult (w,  results)-  where msg = when (verbose config) . putStrLn . ("** " ++)-        go sbvPgm = loop-          where hasPar = any isParallelCaseAnywhere (tactics sbvPgm)-                loop !n nonEqConsts = do-                  curResult <- invoke nonEqConsts hasPar n sbvPgm-                  case curResult of-                    Nothing            -> return []-                    Just (SatResult r) -> let cont model = do let modelOnlyAssocs = [v | v@(x, _) <- modelAssocs model, not (isNonModelVar config x)]-                                                              rest <- unsafeInterleaveIO $ loop (n+1) (modelOnlyAssocs : nonEqConsts)-                                                              return (r : rest)-                                          in case r of-                                               -- We are done! This is really how we should always stop.-                                               Unsatisfiable{} -> return []--                                               -- We have a model. If there are bindings, continue; otherwise stop-                                               Satisfiable   _ (SMTModel _ []) -> return [r]-                                               Satisfiable   _ model           -> cont model--                                               -- Satisfied in an extension field. Stop if no new bindings, otherwise continue if all regular.-                                               -- If the model is in the extension, we also stop-                                               SatExtField   _ (SMTModel _ [])       -> return [r]-                                               SatExtField   _ model@(SMTModel [] _) -> cont model-                                               SatExtField{}                         -> return []--                                               -- Something bad happened, we stop here. Note that we treat Unknown as bad too in this context.-                                               Unknown{}    -> return [r]-                                               ProofError{} -> return [r]-                                               TimeOut{}    -> return [r]--        invoke nonEqConsts hasPar n simRes@SMTProblem{smtInputs, tactics, objectives} = do-               objectiveCheck False objectives "allSat"-               msg $ "Looking for solution " ++ show n-               case addNonEqConstraints (smtLibVersion config) (roundingMode config) smtInputs nonEqConsts of-                 Nothing -> -- no new constraints refuted models, stop-                            return Nothing-                 Just refutedModels -> do--                    let wrap                 = SatResult-                        unwrap (SatResult r) = r--                        mwrap  [r]           = wrap r-                        mwrap xs             = error $ "SBV.allSatWith: Backend solver returned a non-singleton answer:\n" ++ show (map SatResult xs)--                    res <- bufferSanity hasPar $ applyTactics (updateName (n-1) config) (True, hasPar) (wrap, unwrap) [] tactics objectives-                                               $ callSolver True "Checking Satisfiability.." refutedModels mwrap simRes-                    return $ Just res--        updateName i cfg = cfg{smtFile = upd `fmap` smtFile cfg}-               where upd nm = let (b, e) = splitExtension nm in b ++ "_allSat_" ++ show i ++ e--callSolver :: Bool -> String -> [String] -> ([SMTResult] -> b) -> SMTProblem -> SMTConfig -> Maybe (OptimizeStyle, Int) -> CaseCond -> IO b-callSolver isSat checkMsg refutedModels wrap SMTProblem{smtInputs, smtSkolemMap, smtLibPgm} config mbOptInfo caseCond = do-       let msg = when (verbose config) . putStrLn . ("** " ++)-           finalPgm = intercalate "\n" (pgm ++ refutedModels) where SMTLibPgm _ pgm = smtLibPgm config caseCond--       msg checkMsg-       msg $ "Generated SMTLib program:\n" ++ (finalPgm ++ intercalate "\n" ("" : optimizeArgs config ++ [satCmd config]))--       smtAnswer <- engine (solver config) config isSat mbOptInfo smtInputs smtSkolemMap finalPgm--       msg "Done.."--       return $ wrap smtAnswer--simulate :: Provable a => SMTLibConverter -> SMTConfig -> Bool -> [String] -> a -> IO SMTProblem-simulate converter config isSat comments predicate = do-        let msg = when (verbose config) . putStrLn . ("** " ++)-            isTiming = timing config-        msg "Starting symbolic simulation.."-        res <- timeIf isTiming ProblemConstruction $ runSymbolic (isSat, config) $ (if isSat then forSome_ else forAll_) predicate >>= output-        msg $ "Generated symbolic trace:\n" ++ show res-        msg "Translating to SMT-Lib.."-        runProofOn converter config isSat comments res--runProofOn :: SMTLibConverter -> SMTConfig -> Bool -> [String] -> Result -> IO SMTProblem-runProofOn converter config isSat comments res =-        let isTiming = timing config-        in case res of-             Result ki _qcInfo _codeSegs is consts tbls arrs uis axs pgm cstrs tacs goals assertions [o@(SW KBool _)] ->-               timeIf isTiming Translation-                $ let skolemMap = skolemize (if isSat then is else map flipQ is)-                           where flipQ (ALL, x) = (EX, x)-                                 flipQ (EX, x)  = (ALL, x)-                                 skolemize :: [(Quantifier, NamedSymVar)] -> [Either SW (SW, [SW])]-                                 skolemize qinps = go qinps ([], [])-                                   where go []                   (_,  sofar) = reverse sofar-                                         go ((ALL, (v, _)):rest) (us, sofar) = go rest (v:us, Left v : sofar)-                                         go ((EX,  (v, _)):rest) (us, sofar) = go rest (us,   Right (v, reverse us) : sofar)-                      smtScript = converter ki isSat comments is skolemMap consts tbls arrs uis axs pgm cstrs o-                      result = SMTProblem {smtInputs=is, smtSkolemMap=skolemMap, kindsUsed=ki, smtAsserts=assertions, tactics=tacs, objectives=goals, smtLibPgm=smtScript}-                  in rnf smtScript `seq` return result-             Result{resOutputs = os} -> case length os of-                           0  -> error $ "Impossible happened, unexpected non-outputting result\n" ++ show res-                           1  -> error $ "Impossible happened, non-boolean output in " ++ show os-                                       ++ "\nDetected while generating the trace:\n" ++ show res-                           _  -> error $ "User error: Multiple output values detected: " ++ show os-                                       ++ "\nDetected while generating the trace:\n" ++ show res-                                       ++ "\n*** Check calls to \"output\", they are typically not needed!"---- | Run an external proof on the given condition to see if it is satisfiable.-internalSATCheck :: SMTConfig -> SBool -> State -> String -> IO SatResult-internalSATCheck cfg condInPath st msg = do-   sw <- sbvToSW st condInPath-   () <- forceSWArg sw-   Result ki tr uic is cs ts as uis ax asgn cstr tactics goals assertions _ <- extractSymbolicSimulationState st--   let -- Construct the corresponding sat-checker for the branch. Note that we need to-       -- forget about the quantifiers and just use an "exist", as we're looking for a-       -- point-satisfiability check here; whatever the original program was.-       pgm = Result ki tr uic [(EX, n) | (_, n) <- is] cs ts as uis ax asgn cstr tactics goals assertions [sw]--       mwrap [r] = SatResult r-       mwrap xs  = error $ "SBV.internalSATCheck: Backend solver returned a non-singleton answer:\n" ++ show (map SatResult xs)--   runProofOn (getConverter cfg) cfg True [] pgm >>= \p -> callSolver True msg [] mwrap p cfg Nothing NoCase+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Provers.Prover+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Provable abstraction and the connection to SMT solvers+-----------------------------------------------------------------------------++{-# LANGUAGE CPP                  #-}+{-# LANGUAGE FlexibleInstances    #-}+{-# LANGUAGE NamedFieldPuns       #-}+{-# LANGUAGE ScopedTypeVariables  #-}+{-# LANGUAGE TypeSynonymInstances #-}++module Data.SBV.Provers.Prover (+         SMTSolver(..), SMTConfig(..), Predicate, Provable(..), Goal+       , ThmResult(..), SatResult(..), AllSatResult(..), SafeResult(..), OptimizeResult(..), SMTResult(..)+       , SExecutable(..), isSafe+       , runSMT, runSMTWith+       , SatModel(..), Modelable(..), displayModels, extractModels+       , getModelDictionaries, getModelValues, getModelUninterpretedValues+       , boolector, cvc4, yices, z3, mathSAT, abc, defaultSMTCfg+       ) where+++import Control.Monad   (when, unless)+import Control.DeepSeq (rnf, NFData(..))++import Control.Concurrent.Async (async, waitAny, asyncThreadId, Async)+import Control.Exception (finally, throwTo, AsyncException(ThreadKilled))++import System.IO.Unsafe (unsafeInterleaveIO)             -- only used safely!++import System.Directory  (getCurrentDirectory)++import Data.Time (getZonedTime, NominalDiffTime, UTCTime, getCurrentTime, diffUTCTime)+import Data.List (intercalate, isPrefixOf)++import Data.SBV.Core.Data+import Data.SBV.Core.Symbolic+import Data.SBV.SMT.SMT+import Data.SBV.Utils.TDiff++import qualified Data.SBV.Control       as Control+import qualified Data.SBV.Control.Query as Control+import qualified Data.SBV.Control.Utils as Control++import GHC.Stack++import qualified Data.SBV.Provers.Boolector  as Boolector+import qualified Data.SBV.Provers.CVC4       as CVC4+import qualified Data.SBV.Provers.Yices      as Yices+import qualified Data.SBV.Provers.Z3         as Z3+import qualified Data.SBV.Provers.MathSAT    as MathSAT+import qualified Data.SBV.Provers.ABC        as ABC++mkConfig :: SMTSolver -> SMTLibVersion -> [Control.SMTOption] -> SMTConfig+mkConfig s smtVersion startOpts = SMTConfig { verbose             = False+                                            , timing              = NoTiming+                                            , printBase           = 10+                                            , printRealPrec       = 16+                                            , transcript          = Nothing+                                            , solver              = s+                                            , smtLibVersion       = smtVersion+                                            , satCmd              = "(check-sat)"+                                            , allSatMaxModelCount = Nothing                -- i.e., return all satisfying models+                                            , isNonModelVar       = const False            -- i.e., everything is a model-variable by default+                                            , roundingMode        = RoundNearestTiesToEven+                                            , solverSetOptions    = startOpts+                                            , ignoreExitCode      = False+                                            , redirectVerbose     = Nothing+                                            }++-- | If supported, this makes all output go to stdout, which works better with SBV+-- Alas, not all solvers support it..+allOnStdOut :: Control.SMTOption+allOnStdOut = Control.OptionKeyword ":diagnostic-output-channel" [show "stdout"]++-- | Default configuration for the Boolector SMT solver+boolector :: SMTConfig+boolector = mkConfig Boolector.boolector SMTLib2 []++-- | Default configuration for the CVC4 SMT Solver.+cvc4 :: SMTConfig+cvc4 = mkConfig CVC4.cvc4 SMTLib2 [allOnStdOut]++-- | Default configuration for the Yices SMT Solver.+yices :: SMTConfig+yices = mkConfig Yices.yices SMTLib2 []++-- | Default configuration for the Z3 SMT solver+z3 :: SMTConfig+z3 = mkConfig Z3.z3 SMTLib2 [ Control.OptionKeyword ":smtlib2_compliant" ["true"]+                            , allOnStdOut+                            ]++-- | Default configuration for the MathSAT SMT solver+mathSAT :: SMTConfig+mathSAT = mkConfig MathSAT.mathSAT SMTLib2 [allOnStdOut]++-- | Default configuration for the ABC synthesis and verification tool.+abc :: SMTConfig+abc = mkConfig ABC.abc SMTLib2 [allOnStdOut]++-- | The default solver used by SBV. This is currently set to z3.+defaultSMTCfg :: SMTConfig+defaultSMTCfg = z3++-- | A predicate is a symbolic program that returns a (symbolic) boolean value. For all intents and+-- purposes, it can be treated as an n-ary function from symbolic-values to a boolean. The 'Symbolic'+-- monad captures the underlying representation, and can/should be ignored by the users of the library,+-- unless you are building further utilities on top of SBV itself. Instead, simply use the 'Predicate'+-- type when necessary.+type Predicate = Symbolic SBool++-- | A goal is a symbolic program that returns no values. The idea is that the constraints/min-max+-- goals will serve as appropriate directives for sat/prove calls.+type Goal = Symbolic ()++-- | A type @a@ is provable if we can turn it into a predicate.+-- Note that a predicate can be made from a curried function of arbitrary arity, where+-- each element is either a symbolic type or up-to a 7-tuple of symbolic-types. So+-- predicates can be constructed from almost arbitrary Haskell functions that have arbitrary+-- shapes. (See the instance declarations below.)+class Provable a where+  -- | Turns a value into a universally quantified predicate, internally naming the inputs.+  -- In this case the sbv library will use names of the form @s1, s2@, etc. to name these variables+  -- Example:+  --+  -- >  forAll_ $ \(x::SWord8) y -> x `shiftL` 2 .== y+  --+  -- is a predicate with two arguments, captured using an ordinary Haskell function. Internally,+  -- @x@ will be named @s0@ and @y@ will be named @s1@.+  forAll_ :: a -> Predicate++  -- | Turns a value into a predicate, allowing users to provide names for the inputs.+  -- If the user does not provide enough number of names for the variables, the remaining ones+  -- will be internally generated. Note that the names are only used for printing models and has no+  -- other significance; in particular, we do not check that they are unique. Example:+  --+  -- >  forAll ["x", "y"] $ \(x::SWord8) y -> x `shiftL` 2 .== y+  --+  -- This is the same as above, except the variables will be named @x@ and @y@ respectively,+  -- simplifying the counter-examples when they are printed.+  forAll  :: [String] -> a -> Predicate++  -- | Turns a value into an existentially quantified predicate. (Indeed, 'exists' would have been+  -- a better choice here for the name, but alas it's already taken.)+  forSome_ :: a -> Predicate++  -- | Version of 'forSome' that allows user defined names.+  forSome :: [String] -> a -> Predicate++  -- | Prove a predicate, using the default solver.+  prove :: a -> IO ThmResult+  prove = proveWith defaultSMTCfg++  -- | Prove the predicate using the given SMT-solver.+  proveWith :: SMTConfig -> a -> IO ThmResult+  proveWith = runWithQuery False $ ThmResult <$> Control.getSMTResult++  -- | Find a satisfying assignment for a predicate, using the default solver.+  sat :: a -> IO SatResult+  sat = satWith defaultSMTCfg++  -- | Find a satisfying assignment using the given SMT-solver.+  satWith :: SMTConfig -> a -> IO SatResult+  satWith = runWithQuery True $ SatResult <$> Control.getSMTResult++  -- | Find all satisfying assignments, using the default solver. See 'allSatWith' for details.+  allSat :: a -> IO AllSatResult+  allSat = allSatWith defaultSMTCfg++  -- | Return all satisfying assignments for a predicate, equivalent to @'allSatWith' 'defaultSMTCfg'@.+  -- Note that this call will block until all satisfying assignments are found. If you have a problem+  -- with infinitely many satisfying models (consider 'SInteger') or a very large number of them, you+  -- might have to wait for a long time. To avoid such cases, use the 'allSatMaxModelCount' parameter+  -- in the configuration.+  --+  -- NB. Uninterpreted constant/function values and counter-examples for array values are ignored for+  -- the purposes of @'allSat'@. That is, only the satisfying assignments modulo uninterpreted functions and+  -- array inputs will be returned. This is due to the limitation of not having a robust means of getting a+  -- function counter-example back from the SMT solver.+  --  Find all satisfying assignments using the given SMT-solver+  allSatWith :: SMTConfig -> a -> IO AllSatResult+  allSatWith = runWithQuery True $ AllSatResult <$> Control.getAllSatResult++  -- | Optimize a given collection of `Objective`s+  optimize :: OptimizeStyle -> a -> IO OptimizeResult+  optimize = optimizeWith defaultSMTCfg++  -- | Optimizes the objectives using the given SMT-solver.+  optimizeWith :: SMTConfig -> OptimizeStyle -> a -> IO OptimizeResult+  optimizeWith config style = runWithQuery True opt config+    where opt = do objectives <- Control.getObjectives+                   qinps      <- Control.getQuantifiedInputs++                   when (null objectives) $+                          error $ unlines [ ""+                                          , "*** Data.SBV: Unsupported call to optimize when no objectives are present."+                                          , "*** Use \"sat\" for plain satisfaction"+                                          ]++                   unless (supportsOptimization (capabilities (solver config))) $+                          error $ unlines [ ""+                                          , "*** Data.SBV: The backend solver " ++ show (name (solver config)) ++ "does not support optimization goals."+                                          , "*** Please use a solver that has support, such as z3"+                                          ]++                   let needsUniversalOpt = let universals = [s | (ALL, (s, _)) <- qinps]+                                               check (x, y) nm = [nm | any (`elem` universals) [x, y]]+                                               isUniversal (Maximize   nm xy)   = check xy nm+                                               isUniversal (Minimize   nm xy)   = check xy nm+                                               isUniversal (AssertSoft nm xy _) = check xy nm+                                           in  concatMap isUniversal objectives++                   unless (null needsUniversalOpt) $+                          error $ unlines [ ""+                                          , "*** Data.SBV: Problem needs optimization of universally quantified metric(s):"+                                          , "***"+                                          , "***          " ++  unwords needsUniversalOpt+                                          , "***"+                                          , "*** Optimization is only meaningful existentially quantified values."+                                          ]++                   let optimizerDirectives = concatMap minmax objectives ++ priority style+                         where mkEq (x, y) = "(assert (= " ++ show x ++ " " ++ show y ++ "))"+                               minmax (Minimize   _  xy@(_, v))     = [mkEq xy, "(minimize "    ++ show v ++ ")"]+                               minmax (Maximize   _  xy@(_, v))     = [mkEq xy, "(maximize "    ++ show v ++ ")"]+                               minmax (AssertSoft nm xy@(_, v) mbp) = [mkEq xy, "(assert-soft " ++ show v ++ penalize mbp ++ ")"]+                                 where penalize DefaultPenalty    = ""+                                       penalize (Penalty w mbGrp)+                                          | w <= 0         = error $ unlines [ "SBV.AssertSoft: Goal " ++ show nm ++ " is assigned a non-positive penalty: " ++ shw+                                                                             , "All soft goals must have > 0 penalties associated."+                                                                             ]+                                          | True           = " :weight " ++ shw ++ maybe "" group mbGrp+                                          where shw = show (fromRational w :: Double)++                                       group g = " :id " ++ g++                               priority Lexicographic = [] -- default, no option needed+                               priority Independent   = ["(set-option :opt.priority box)"]+                               priority (Pareto _)    = ["(set-option :opt.priority pareto)"]++                   mapM_ (Control.send True) optimizerDirectives++                   case style of+                      Lexicographic -> LexicographicResult <$> Control.getLexicographicOptResults+                      Independent   -> IndependentResult   <$> Control.getIndependentOptResults (map objectiveName objectives)+                      Pareto mbN    -> ParetoResult        <$> Control.getParetoOptResults mbN++  -- | Check if the constraints given are consistent, using the default solver.+  isVacuous :: a -> IO Bool+  isVacuous = isVacuousWith defaultSMTCfg++  -- | Determine if the constraints are vacuous using the given SMT-solver.+  isVacuousWith :: SMTConfig -> a -> IO Bool+  isVacuousWith cfg a = -- NB. Can't call runWithQuery since last constraint would become the implication!+                        fst <$> runSymbolic (SMTMode ISetup True cfg) (forSome_ a >> Control.query check)+     where check = do cs <- Control.checkSat+                      case cs of+                        Control.Unsat -> return True+                        Control.Sat   -> return False+                        Control.Unk   -> error "SBV: isVacuous: Solver returned unknown!"++  -- | Checks theoremhood using the default solver.+  isTheorem :: a -> IO Bool+  isTheorem = isTheoremWith defaultSMTCfg++  -- | Check whether a given property is a theorem.+  isTheoremWith :: SMTConfig -> a -> IO Bool+  isTheoremWith cfg p = do r <- proveWith cfg p+                           case r of+                             ThmResult Unsatisfiable{} -> return True+                             ThmResult Satisfiable{}   -> return False+                             _                         -> error $ "SBV.isTheorem: Received:\n" ++ show r+++  -- | Checks satisfiability using the default solver.+  isSatisfiable :: a -> IO Bool+  isSatisfiable = isSatisfiableWith defaultSMTCfg++  -- | Check whether a given property is satisfiable.+  isSatisfiableWith :: SMTConfig -> a -> IO Bool+  isSatisfiableWith cfg p = do r <- satWith cfg p+                               case r of+                                 SatResult Satisfiable{}   -> return True+                                 SatResult Unsatisfiable{} -> return False+                                 _                         -> error $ "SBV.isSatisfiable: Received: " ++ show r++  -- | Prove a property with multiple solvers, running them in separate threads. The+  -- results will be returned in the order produced.+  proveWithAll :: [SMTConfig] -> a -> IO [(Solver, NominalDiffTime, ThmResult)]+  proveWithAll  = (`sbvWithAll` proveWith)++  -- | 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+  -- 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 :: [SMTConfig] -> a -> IO (Solver, NominalDiffTime, ThmResult)+  proveWithAny  = (`sbvWithAny` proveWith)++  -- | Find a satisfying assignment to a property with multiple solvers, running them in separate threads. The+  -- results will be returned in the order produced.+  satWithAll :: [SMTConfig] -> a -> IO [(Solver, NominalDiffTime, SatResult)]+  satWithAll = (`sbvWithAll` satWith)++  -- | 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+  -- 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 :: [SMTConfig] -> a -> IO (Solver, NominalDiffTime, SatResult)+  satWithAny    = (`sbvWithAny` satWith)++  -- | 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 :: Bool -> a -> IO String+  generateSMTBenchmark isSat a = do+        t <- getZonedTime++        let comments = ["Automatically created by SBV on " ++ show t]+            cfg      = defaultSMTCfg { smtLibVersion = SMTLib2 }++        (_, res) <- runSymbolic (SMTMode ISetup isSat cfg) $ (if isSat then forSome_ else forAll_) a >>= output++        let SMTProblem{smtLibPgm} = Control.runProofOn cfg isSat comments res+            out                   = show (smtLibPgm cfg)++        return $ out ++ "\n(check-sat)\n"++instance Provable Predicate where+  forAll_    = id+  forAll []  = id+  forAll xs  = error $ "SBV.forAll: Extra unmapped name(s) in predicate construction: " ++ intercalate ", " xs+  forSome_   = id+  forSome [] = id+  forSome xs = error $ "SBV.forSome: Extra unmapped name(s) in predicate construction: " ++ intercalate ", " xs++instance Provable SBool where+  forAll_   = return+  forAll _  = return+  forSome_  = return+  forSome _ = return++{-+-- The following works, but it lets us write properties that+-- are not useful.. Such as: prove $ \x y -> (x::SInt8) == y+-- Running that will throw an exception since Haskell's equality+-- is not be supported by symbolic things. (Needs .==).+instance Provable Bool where+  forAll_  x  = forAll_   (if x then true else false :: SBool)+  forAll s x  = forAll s  (if x then true else false :: SBool)+  forSome_  x = forSome_  (if x then true else false :: SBool)+  forSome s x = forSome s (if x then true else false :: SBool)+-}++-- Functions+instance (SymWord a, Provable p) => Provable (SBV a -> p) where+  forAll_        k = forall_   >>= \a -> forAll_   $ k a+  forAll (s:ss)  k = forall s  >>= \a -> forAll ss $ k a+  forAll []      k = forAll_ k+  forSome_       k = exists_  >>= \a -> forSome_   $ k a+  forSome (s:ss) k = exists s >>= \a -> forSome ss $ k a+  forSome []     k = forSome_ k++-- SFunArrays (memory, functional representation), only supported universally for the time being+instance (HasKind a, HasKind b, Provable p) => Provable (SArray a b -> p) where+  forAll_       k = declNewSArray (\t -> "array_" ++ show t) >>= \a -> forAll_   $ k a+  forAll (s:ss) k = declNewSArray (const s)                  >>= \a -> forAll ss $ k a+  forAll []     k = forAll_ k+  forSome_      _ = error "SBV.forSome: Existential arrays are not currently supported."+  forSome _     _ = error "SBV.forSome: Existential arrays are not currently supported."++-- SArrays (memory, SMT-Lib notion of arrays), only supported universally for the time being+instance (HasKind a, HasKind b, Provable p) => Provable (SFunArray a b -> p) where+  forAll_       k = declNewSFunArray Nothing >>= \a -> forAll_   $ k a+  forAll (_:ss) k = declNewSFunArray Nothing >>= \a -> forAll ss $ k a+  forAll []     k = forAll_ k+  forSome_      _ = error "SBV.forSome: Existential arrays are not currently supported."+  forSome _     _ = error "SBV.forSome: Existential arrays are not currently supported."++-- 2 Tuple+instance (SymWord a, SymWord b, Provable p) => Provable ((SBV a, SBV b) -> p) where+  forAll_        k = forall_  >>= \a -> forAll_   $ \b -> k (a, b)+  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b -> k (a, b)+  forAll []      k = forAll_ k+  forSome_       k = exists_  >>= \a -> forSome_   $ \b -> k (a, b)+  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b -> k (a, b)+  forSome []     k = forSome_ k++-- 3 Tuple+instance (SymWord a, SymWord b, SymWord c, Provable p) => Provable ((SBV a, SBV b, SBV c) -> p) where+  forAll_       k  = forall_  >>= \a -> forAll_   $ \b c -> k (a, b, c)+  forAll (s:ss) k  = forall s >>= \a -> forAll ss $ \b c -> k (a, b, c)+  forAll []     k  = forAll_ k+  forSome_       k = exists_  >>= \a -> forSome_   $ \b c -> k (a, b, c)+  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c -> k (a, b, c)+  forSome []     k = forSome_ k++-- 4 Tuple+instance (SymWord a, SymWord b, SymWord c, SymWord d, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d) -> p) where+  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d -> k (a, b, c, d)+  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d -> k (a, b, c, d)+  forAll []      k = forAll_ k+  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d -> k (a, b, c, d)+  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d -> k (a, b, c, d)+  forSome []     k = forSome_ k++-- 5 Tuple+instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) where+  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d e -> k (a, b, c, d, e)+  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d e -> k (a, b, c, d, e)+  forAll []      k = forAll_ k+  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d e -> k (a, b, c, d, e)+  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e -> k (a, b, c, d, e)+  forSome []     k = forSome_ k++-- 6 Tuple+instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) where+  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d e f -> k (a, b, c, d, e, f)+  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d e f -> k (a, b, c, d, e, f)+  forAll []      k = forAll_ k+  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d e f -> k (a, b, c, d, e, f)+  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e f -> k (a, b, c, d, e, f)+  forSome []     k = forSome_ k++-- 7 Tuple+instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SymWord g, Provable p) => Provable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) where+  forAll_        k = forall_  >>= \a -> forAll_   $ \b c d e f g -> k (a, b, c, d, e, f, g)+  forAll (s:ss)  k = forall s >>= \a -> forAll ss $ \b c d e f g -> k (a, b, c, d, e, f, g)+  forAll []      k = forAll_ k+  forSome_       k = exists_  >>= \a -> forSome_   $ \b c d e f g -> k (a, b, c, d, e, f, g)+  forSome (s:ss) k = exists s >>= \a -> forSome ss $ \b c d e f g -> k (a, b, c, d, e, f, g)+  forSome []     k = forSome_ k++-- | Run an arbitrary symbolic computation, equivalent to @'runSMTWith' 'defaultSMTCfg'@+runSMT :: Symbolic a -> IO a+runSMT = runSMTWith defaultSMTCfg++-- | Runs an arbitrary symbolic computation, exposed to the user in SAT mode+runSMTWith :: SMTConfig -> Symbolic a -> IO a+runSMTWith cfg a = fst <$> runSymbolic (SMTMode ISetup True cfg) a++-- | Runs with a query.+runWithQuery :: Provable a => Bool -> Query b -> SMTConfig -> a -> IO b+runWithQuery isSAT q cfg a = fst <$> runSymbolic (SMTMode ISetup isSAT cfg) comp+  where comp =  do _ <- (if isSAT then forSome_ else forAll_) a >>= output+                   Control.query q++-- | Check if a safe-call was safe or not, turning a 'SafeResult' to a Bool.+isSafe :: SafeResult -> Bool+isSafe (SafeResult (_, _, result)) = case result of+                                       Unsatisfiable{} -> True+                                       Satisfiable{}   -> False+                                       SatExtField{}   -> False   -- conservative+                                       Unknown{}       -> False   -- conservative+                                       ProofError{}    -> False   -- conservative++-- | Perform an action asynchronously, returning results together with diff-time.+runInThread :: NFData b => UTCTime -> (SMTConfig -> IO b) -> SMTConfig -> IO (Async (Solver, NominalDiffTime, b))+runInThread beginTime action config = async $ do+                result  <- action config+                endTime <- rnf result `seq` getCurrentTime+                return (name (solver config), endTime `diffUTCTime` beginTime, result)++-- | Perform action for all given configs, return the first one that wins. Note that we do+-- not wait for the other asyncs to terminate; hopefully they'll do so quickly.+sbvWithAny :: NFData b => [SMTConfig] -> (SMTConfig -> a -> IO b) -> a -> IO (Solver, NominalDiffTime, b)+sbvWithAny []      _    _ = error "SBV.withAny: No solvers given!"+sbvWithAny solvers what a = do beginTime <- getCurrentTime+                               snd `fmap` (mapM (runInThread beginTime (`what` a)) solvers >>= 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) ThreadKilled++-- | Perform action for all given configs, return all the results.+sbvWithAll :: NFData b => [SMTConfig] -> (SMTConfig -> a -> IO b) -> a -> IO [(Solver, NominalDiffTime, b)]+sbvWithAll solvers what a = do beginTime <- getCurrentTime+                               mapM (runInThread beginTime (`what` a)) solvers >>= (unsafeInterleaveIO . go)+   where 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)++-- | Symbolically executable program fragments. This class is mainly used for 'safe' calls, and is sufficently populated internally to cover most use+-- cases. Users can extend it as they wish to allow 'safe' checks for SBV programs that return/take types that are user-defined.+class SExecutable a where+   sName_ :: a -> Symbolic ()+   sName  :: [String] -> a -> Symbolic ()++   -- | Check safety using the default solver.+   safe :: a -> IO [SafeResult]+   safe = safeWith defaultSMTCfg++   -- | Check if any of the 'sAssert' calls can be violated.+   safeWith :: SMTConfig -> a -> IO [SafeResult]+   safeWith cfg a = do cwd <- (++ "/") <$> getCurrentDirectory+                       let mkRelative path+                              | cwd `isPrefixOf` path = drop (length cwd) path+                              | True                  = path+                       fst <$> runSymbolic (SMTMode ISetup True cfg) (sName_ a >> check mkRelative)+     where check mkRelative = Control.query $ Control.getSBVAssertions >>= mapM (verify mkRelative)++           -- check that the cond is unsatisfiable. If satisfiable, that would+           -- indicate the assignment under which the 'sAssert' would fail+           verify :: (FilePath -> FilePath) -> (String, Maybe CallStack, SW) -> Query SafeResult+           verify mkRelative (msg, cs, cond) = do+                   let locInfo ps = let loc (f, sl) = concat [mkRelative (srcLocFile sl), ":", show (srcLocStartLine sl), ":", show (srcLocStartCol sl), ":", f]+                                    in intercalate ",\n " (map loc ps)+                       location   = (locInfo . getCallStack) `fmap` cs++                   result <- do Control.push 1+                                Control.send True $ "(assert " ++ show cond ++ ")"+                                r <- Control.getSMTResult+                                Control.pop 1+                                return r++                   return $ SafeResult (location, msg, result)++instance NFData a => SExecutable (Symbolic a) where+   sName_   a = a >>= \r -> rnf r `seq` return ()+   sName []   = sName_+   sName xs   = error $ "SBV.SExecutable.sName: Extra unmapped name(s): " ++ intercalate ", " xs++instance SExecutable (SBV a) where+   sName_   v = sName_ (output v)+   sName xs v = sName xs (output v)++-- Unit output+instance SExecutable () where+   sName_   () = sName_   (output ())+   sName xs () = sName xs (output ())++-- List output+instance SExecutable [SBV a] where+   sName_   vs = sName_   (output vs)+   sName xs vs = sName xs (output vs)++-- 2 Tuple output+instance (NFData a, SymWord a, NFData b, SymWord b) => SExecutable (SBV a, SBV b) where+  sName_ (a, b) = sName_ (output a >> output b)+  sName _       = sName_++-- 3 Tuple output+instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c) => SExecutable (SBV a, SBV b, SBV c) where+  sName_ (a, b, c) = sName_ (output a >> output b >> output c)+  sName _          = sName_++-- 4 Tuple output+instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d) => SExecutable (SBV a, SBV b, SBV c, SBV d) where+  sName_ (a, b, c, d) = sName_ (output a >> output b >> output c >> output c >> output d)+  sName _             = sName_++-- 5 Tuple output+instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d, NFData e, SymWord e) => SExecutable (SBV a, SBV b, SBV c, SBV d, SBV e) where+  sName_ (a, b, c, d, e) = sName_ (output a >> output b >> output c >> output d >> output e)+  sName _                = sName_++-- 6 Tuple output+instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d, NFData e, SymWord e, NFData f, SymWord f) => SExecutable (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) where+  sName_ (a, b, c, d, e, f) = sName_ (output a >> output b >> output c >> output d >> output e >> output f)+  sName _                   = sName_++-- 7 Tuple output+instance (NFData a, SymWord a, NFData b, SymWord b, NFData c, SymWord c, NFData d, SymWord d, NFData e, SymWord e, NFData f, SymWord f, NFData g, SymWord g) => SExecutable (SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) where+  sName_ (a, b, c, d, e, f, g) = sName_ (output a >> output b >> output c >> output d >> output e >> output f >> output g)+  sName _                      = sName_++-- Functions+instance (SymWord a, SExecutable p) => SExecutable (SBV a -> p) where+   sName_        k = exists_   >>= \a -> sName_   $ k a+   sName (s:ss)  k = exists s  >>= \a -> sName ss $ k a+   sName []      k = sName_ k++-- 2 Tuple input+instance (SymWord a, SymWord b, SExecutable p) => SExecutable ((SBV a, SBV b) -> p) where+  sName_        k = exists_  >>= \a -> sName_   $ \b -> k (a, b)+  sName (s:ss)  k = exists s >>= \a -> sName ss $ \b -> k (a, b)+  sName []      k = sName_ k++-- 3 Tuple input+instance (SymWord a, SymWord b, SymWord c, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c) -> p) where+  sName_       k  = exists_  >>= \a -> sName_   $ \b c -> k (a, b, c)+  sName (s:ss) k  = exists s >>= \a -> sName ss $ \b c -> k (a, b, c)+  sName []     k  = sName_ k++-- 4 Tuple input+instance (SymWord a, SymWord b, SymWord c, SymWord d, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d) -> p) where+  sName_        k = exists_  >>= \a -> sName_   $ \b c d -> k (a, b, c, d)+  sName (s:ss)  k = exists s >>= \a -> sName ss $ \b c d -> k (a, b, c, d)+  sName []      k = sName_ k++-- 5 Tuple input+instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d, SBV e) -> p) where+  sName_        k = exists_  >>= \a -> sName_   $ \b c d e -> k (a, b, c, d, e)+  sName (s:ss)  k = exists s >>= \a -> sName ss $ \b c d e -> k (a, b, c, d, e)+  sName []      k = sName_ k++-- 6 Tuple input+instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> p) where+  sName_        k = exists_  >>= \a -> sName_   $ \b c d e f -> k (a, b, c, d, e, f)+  sName (s:ss)  k = exists s >>= \a -> sName ss $ \b c d e f -> k (a, b, c, d, e, f)+  sName []      k = sName_ k++-- 7 Tuple input+instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, SymWord g, SExecutable p) => SExecutable ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f, SBV g) -> p) where+  sName_        k = exists_  >>= \a -> sName_   $ \b c d e f g -> k (a, b, c, d, e, f, g)+  sName (s:ss)  k = exists s >>= \a -> sName ss $ \b c d e f g -> k (a, b, c, d, e, f, g)+  sName []      k = sName_ k+ {-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
− Data/SBV/Provers/SExpr.hs 
@@ -1,209 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Data.SBV.Provers.SExpr--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Parsing of S-expressions (mainly used for parsing SMT-Lib get-value output)--------------------------------------------------------------------------------module Data.SBV.Provers.SExpr (SExpr(..), parseSExpr) where--import Data.Bits           (setBit, testBit)-import Data.Word           (Word32, Word64)-import Data.Char           (isDigit, ord, isSpace)-import Data.List           (isPrefixOf)-import Data.Maybe          (fromMaybe, listToMaybe)-import Numeric             (readInt, readDec, readHex, fromRat)-import Data.Binary.IEEE754 (wordToFloat, wordToDouble)--import Data.SBV.Core.AlgReals-import Data.SBV.Core.Data (nan, infinity, RoundingMode(..))---- | ADT S-Expression format, suitable for representing get-model output of SMT-Lib-data SExpr = ECon    String-           | ENum    (Integer, Maybe Int)  -- Second argument is how wide the field was in bits, if known. Useful in FP parsing.-           | EReal   AlgReal-           | EFloat  Float-           | EDouble Double-           | EApp    [SExpr]-           deriving Show---- | Extremely simple minded tokenizer, good for our use model.-tokenize :: String -> [String]-tokenize inp = go inp []- where go "" sofar = reverse sofar--       go (c:cs) sofar-          | isSpace c = go (dropWhile isSpace cs) sofar--       go ('(':cs) sofar = go cs ("(" : sofar)-       go (')':cs) sofar = go cs (")" : sofar)--       go (':':':':cs) sofar = go cs ("::" : sofar)--       go ('|':r) sofar = case span (/= '|') r of-                            (pre, '|':rest) -> go rest (pre : sofar)-                            (pre, rest)     -> go rest (pre : sofar)--       go cs sofar = case span (`notElem` stopper) cs of-                       (pre, post) -> go post (pre : sofar)--       -- characters that can stop the current token-       -- it is *crucial* that this list contains every character-       -- we can match in one of the previous cases!-       stopper = " ():|"---- | Parse a string into an SExpr, potentially failing with an error message-parseSExpr :: String -> Either String SExpr-parseSExpr inp = do (sexp, extras) <- parse inpToks-                    if null extras-                       then return sexp-                       else die "Extra tokens after valid input"-  where inpToks = tokenize inp--        die w = fail $  "SBV.Provers.SExpr: Failed to parse S-Expr: " ++ w-                     ++ "\n*** Input : <" ++ inp ++ ">"--        parse []         = die "ran out of tokens"-        parse ("(":toks) = do (f, r) <- parseApp toks []-                              f' <- cvt (EApp f)-                              return (f', r)-        parse (")":_)    = die "extra tokens after close paren"-        parse [tok]      = do t <- pTok tok-                              return (t, [])-        parse _          = die "ill-formed s-expr"--        parseApp []         _     = die "failed to grab s-expr application"-        parseApp (")":toks) sofar = return (reverse sofar, toks)-        parseApp ("(":toks) sofar = do (f, r) <- parse ("(":toks)-                                       parseApp r (f : sofar)-        parseApp (tok:toks) sofar = do t <- pTok tok-                                       parseApp toks (t : sofar)--        pTok "false"              = return $ ENum (0, Nothing)-        pTok "true"               = return $ ENum (1, Nothing)-        pTok ('0':'b':r)          = mkNum (Just (length r))     $ readInt 2 (`elem` "01") (\c -> ord c - ord '0') r-        pTok ('b':'v':r)          = mkNum Nothing               $ readDec (takeWhile (/= '[') r)-        pTok ('#':'b':r)          = mkNum (Just (length r))     $ readInt 2 (`elem` "01") (\c -> ord c - ord '0') r-        pTok ('#':'x':r)          = mkNum (Just (4 * length r)) $ readHex r-        pTok n-          | not (null n) && isDigit (head n)-          = if '.' `elem` n then getReal n-            else mkNum Nothing $ readDec n-        pTok n                 = return $ ECon (constantMap n)--        mkNum l [(n, "")] = return $ ENum (n, l)-        mkNum _ _         = die "cannot read number"--        getReal n = return $ EReal $ mkPolyReal (Left (exact, n'))-          where exact = not ("?" `isPrefixOf` reverse n)-                n' | exact = n-                   | True  = init n--        -- simplify numbers and root-obj values-        cvt (EApp [ECon "to_int",  EReal a])                       = return $ EReal a   -- ignore the "casting"-        cvt (EApp [ECon "to_real", EReal a])                       = return $ EReal a   -- ignore the "casting"-        cvt (EApp [ECon "/", EReal a, EReal b])                    = return $ EReal (a / b)-        cvt (EApp [ECon "/", EReal a, ENum  b])                    = return $ EReal (a                   / fromInteger (fst b))-        cvt (EApp [ECon "/", ENum  a, EReal b])                    = return $ EReal (fromInteger (fst a) /             b      )-        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-                                                                        return $ EReal $ mkPolyReal (Right (fst k, ts))-        cvt (EApp [ECon "as", n, EApp [ECon "_", ECon "FloatingPoint", ENum (11, _), ENum (53, _)]]) = getDouble n-        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-        -- 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-        cvt (EApp [ECon "_",     ECon "NaN",       ENum ( 8, _),       ENum (24,      _)])           = return $ EFloat  nan-        cvt (EApp [ECon "_",     ECon "NaN",       ENum (11, _),       ENum (53,      _)])           = return $ EDouble nan-        cvt (EApp [ECon "_",     ECon "+oo",       ENum ( 8, _),       ENum (24,      _)])           = return $ EFloat  infinity-        cvt (EApp [ECon "_",     ECon "+oo",       ENum (11, _),       ENum (53,      _)])           = return $ EDouble infinity-        cvt (EApp [ECon "_",     ECon "-oo",       ENum ( 8, _),       ENum (24,      _)])           = return $ EFloat  (-infinity)-        cvt (EApp [ECon "_",     ECon "-oo",       ENum (11, _),       ENum (53,      _)])           = return $ EDouble (-infinity)-        cvt (EApp [ECon "_",     ECon "+zero",     ENum ( 8, _),       ENum (24,      _)])           = return $ EFloat  0-        cvt (EApp [ECon "_",     ECon "+zero",     ENum (11, _),       ENum (53,      _)])           = return $ EDouble 0-        cvt (EApp [ECon "_",     ECon "-zero",     ENum ( 8, _),       ENum (24,      _)])           = return $ EFloat  (-0)-        cvt (EApp [ECon "_",     ECon "-zero",     ENum (11, _),       ENum (53,      _)])           = return $ EDouble (-0)-        cvt x                                                                                        = return x--        getCoeff (EApp [ECon "*", ENum k, EApp [ECon "^", ECon "x", ENum p]]) = return (fst k, fst p)  -- kx^p-        getCoeff (EApp [ECon "*", ENum k,                 ECon "x"        ] ) = return (fst k,     1)  -- kx-        getCoeff (                        EApp [ECon "^", ECon "x", ENum p] ) = return (    1, fst p)  --  x^p-        getCoeff (                                        ECon "x"          ) = return (    1,     1)  --  x-        getCoeff (                ENum k                                    ) = return (fst k,     0)  -- k-        getCoeff x = die $ "Cannot parse a root-obj,\nProcessing term: " ++ show x-        getDouble (ECon s)  = case (s, rdFP (dropWhile (== '+') s)) of-                                ("plusInfinity",  _     ) -> return $ EDouble infinity-                                ("minusInfinity", _     ) -> return $ EDouble (-infinity)-                                ("oo",            _     ) -> return $ EDouble infinity-                                ("-oo",           _     ) -> return $ EDouble (-infinity)-                                ("zero",          _     ) -> return $ EDouble 0-                                ("-zero",         _     ) -> return $ EDouble (-0)-                                ("NaN",           _     ) -> return $ EDouble nan-                                (_,               Just v) -> return $ EDouble v-                                _               -> die $ "Cannot parse a double value from: " ++ s-        getDouble (EApp [_, s, _, _]) = getDouble s-        getDouble (EReal r) = return $ EDouble $ fromRat $ toRational r-        getDouble x         = die $ "Cannot parse a double value from: " ++ show x-        getFloat (ECon s)   = case (s, rdFP (dropWhile (== '+') s)) of-                                ("plusInfinity",  _     ) -> return $ EFloat infinity-                                ("minusInfinity", _     ) -> return $ EFloat (-infinity)-                                ("oo",            _     ) -> return $ EFloat infinity-                                ("-oo",           _     ) -> return $ EFloat (-infinity)-                                ("zero",          _     ) -> return $ EFloat 0-                                ("-zero",         _     ) -> return $ EFloat (-0)-                                ("NaN",           _     ) -> return $ EFloat nan-                                (_,               Just v) -> return $ EFloat v-                                _               -> die $ "Cannot parse a float value from: " ++ s-        getFloat (EReal r)  = return $ EFloat $ fromRat $ toRational r-        getFloat (EApp [_, s, _, _]) = getFloat s-        getFloat x          = die $ "Cannot parse a float value from: " ++ show x---- | Parses the Z3 floating point formatted numbers like so: 1.321p5/1.2123e9 etc.-rdFP :: (Read a, RealFloat a) => String -> Maybe a-rdFP s = case break (`elem` "pe") s of-           (m, 'p':e) -> rd m >>= \m' -> rd e >>= \e' -> return $ m' * ( 2 ** e')-           (m, 'e':e) -> rd m >>= \m' -> rd e >>= \e' -> return $ m' * (10 ** e')-           (m, "")    -> rd m-           _          -> Nothing- where rd v = case reads v of-                [(n, "")] -> Just n-                _         -> Nothing---- | Convert an (s, e, m) triple to a float value-getTripleFloat :: Integer -> Integer -> Integer -> Float-getTripleFloat s e m = wordToFloat w32-  where sign      = [s == 1]-        expt      = [e `testBit` i | i <- [ 7,  6 .. 0]]-        mantissa  = [m `testBit` i | i <- [22, 21 .. 0]]-        positions = [i | (i, b) <- zip [31, 30 .. 0] (sign ++ expt ++ mantissa), b]-        w32       = foldr (flip setBit) (0::Word32) positions---- | Convert an (s, e, m) triple to a float value-getTripleDouble :: Integer -> Integer -> Integer -> Double-getTripleDouble s e m = wordToDouble w64-  where sign      = [s == 1]-        expt      = [e `testBit` i | i <- [10,  9 .. 0]]-        mantissa  = [m `testBit` i | i <- [51, 50 .. 0]]-        positions = [i | (i, b) <- zip [63, 62 .. 0] (sign ++ expt ++ mantissa), b]-        w64       = foldr (flip setBit) (0::Word64) positions---- | Special constants of SMTLib2 and their internal translation. Mainly--- rounding modes for now.-constantMap :: String -> String-constantMap n = fromMaybe n (listToMaybe [to | (from, to) <- special, n `elem` from])- where special = [ (["RNE", "roundNearestTiesToEven"], show RoundNearestTiesToEven)-                 , (["RNA", "roundNearestTiesToAway"], show RoundNearestTiesToAway)-                 , (["RTP", "roundTowardPositive"],    show RoundTowardPositive)-                 , (["RTN", "roundTowardNegative"],    show RoundTowardNegative)-                 , (["RTZ", "roundTowardZero"],        show RoundTowardZero)-                 ]
Data/SBV/Provers/Yices.hs view
@@ -23,26 +23,18 @@ yices = SMTSolver {            name         = Yices          , executable   = "yices-smt2"-         , options      = []-         , engine       = standardEngine "SBV_YICES" "SBV_YICES_OPTIONS" id addTimeOut standardModel+         , options      = const ["--incremental"]+         , engine       = standardEngine "SBV_YICES" "SBV_YICES_OPTIONS"          , capabilities = SolverCapabilities {-                                capSolverName              = "Yices"-                              , mbDefaultLogic             = logic-                              , supportsDefineFun          = True-                              , supportsProduceModels      = True-                              , supportsQuantifiers        = False+                                supportsQuantifiers        = False                               , supportsUninterpretedSorts = True                               , supportsUnboundedInts      = True                               , supportsReals              = True-                              , supportsFloats             = False-                              , supportsDoubles            = False+                              , supportsApproxReals        = False+                              , supportsIEEE754            = False                               , supportsOptimization       = False                               , supportsPseudoBooleans     = False-                              , supportsUnsatCores         = False+                              , supportsCustomQueries      = True+                              , supportsGlobalDecls        = False                               }          }-  where addTimeOut _ _ = error "Yices: Timeout values are not supported by Yices"-        -- Yices doesn't like it if we don't set the logic; so pick one and hope for the best-        logic hasReals-          | hasReals   = Just "QF_UFLRA"-          | True       = Just "QF_AUFLIA"
Data/SBV/Provers/Z3.hs view
@@ -1,34 +1,24 @@ ----------------------------------------------------------------------------- -- |--- Module      :  Data.SBV.Provers.Z3+-- Module      :  Data.SBV.Provers.MathSAT -- Copyright   :  (c) Levent Erkok -- License     :  BSD3 -- Maintainer  :  erkokl@gmail.com -- Stability   :  experimental ----- The connection to the Z3 SMT solver+-- The connection to the MathSAT SMT solver -----------------------------------------------------------------------------  {-# LANGUAGE ScopedTypeVariables #-}  module Data.SBV.Provers.Z3(z3) where -import qualified Control.Exception as C--import Data.Char          (toLower)-import Data.Function      (on)-import Data.List          (sortBy, intercalate, groupBy)-import System.Environment (getEnv)-import qualified System.Info as S(os)+import Data.Char (toLower) -import Data.SBV.Core.AlgReals import Data.SBV.Core.Data- import Data.SBV.SMT.SMT-import Data.SBV.SMT.SMTLib -import Data.SBV.Utils.Lib (splitArgs)-import Data.SBV.Utils.PrettyNum+import qualified System.Info as S(os)  -- Choose the correct prefix character for passing options -- TBD: Is there a more foolproof way of determining this?@@ -37,113 +27,28 @@   | map toLower S.os `elem` ["linux", "darwin"] = '-'   | True                                        = '/'   -- windows --- | The description of the Z3 SMT solver+-- | The description of the Z3 SMT solver. -- The default executable is @\"z3\"@, which must be in your path. You can use the @SBV_Z3@ environment variable to point to the executable on your system.--- The default options are @\"-in -smt2\"@, which is valid for Z3 4.1. You can use the @SBV_Z3_OPTIONS@ environment variable to override the options.+-- The default options are @\"-nw -in -smt2\"@, which is valid for Z3 4.1. You can use the @SBV_Z3_OPTIONS@ environment variable to override the options. z3 :: SMTSolver z3 = SMTSolver {-           name           = Z3-         , executable     = "z3"-         , options        = map (optionPrefix:) ["nw", "in", "smt2"]--         , engine         = \cfg isSat mbOptInfo qinps skolemMap pgm -> do--                                    execName <-                   getEnv "SBV_Z3"          `C.catch` (\(_ :: C.SomeException) -> return (executable (solver cfg)))-                                    execOpts <- (splitArgs `fmap` getEnv "SBV_Z3_OPTIONS") `C.catch` (\(_ :: C.SomeException) -> return (options (solver cfg)))--                                    let cfg'   = cfg { solver = (solver cfg) {executable = execName, options = addTimeOut (timeOut cfg) execOpts} }-                                        tweaks = case solverTweaks cfg' of-                                                   [] -> ""-                                                   ts -> unlines $ "; --- user given solver tweaks ---" : ts ++ ["; --- end of user given tweaks ---"]--                                        dlim     = printRealPrec cfg'-                                        ppDecLim = "(set-option :pp.decimal_precision " ++ show dlim ++ ")\n"--                                        mkCont     = cont (roundingMode cfg) skolemMap--                                        (nModels, isPareto, mbContScript) =-                                                case mbOptInfo of-                                                  Just (Pareto, _)              -> (1, True,  Nothing)-                                                  Just (Independent, n) | n > 1 -> (n, False, Just (intercalate "\n" (map (mkCont . Just) [0 .. n-1])))-                                                  _                             -> (1, False, Just (mkCont Nothing))--                                        script   = SMTScript {scriptBody = tweaks ++ ppDecLim ++ pgm, scriptModel = mbContScript}--                                        mkResult c em-                                         | isPareto     =               interpretSolverParetoOutput         c em-                                         | nModels == 1 = replicate 1 . interpretSolverOutput               c em-                                         | True         =               interpretSolverOutputMulti  nModels c em--                                    standardSolver cfg' script id (replicate nModels . ProofError cfg') (mkResult cfg' (extractMap isSat qinps))--         , capabilities   = SolverCapabilities {-                                  capSolverName              = "Z3"-                                , mbDefaultLogic             = const Nothing-                                , supportsDefineFun          = True-                                , supportsProduceModels      = True-                                , supportsQuantifiers        = True-                                , supportsUninterpretedSorts = True-                                , supportsUnboundedInts      = True-                                , supportsReals              = True-                                , supportsFloats             = True-                                , supportsDoubles            = True-                                , supportsOptimization       = True-                                , supportsPseudoBooleans     = True-                                , supportsUnsatCores         = True-                                }+           name         = Z3+         , executable   = "z3"+         , options      = map (optionPrefix:) . modConfig ["nw", "in", "smt2"]+         , engine       = standardEngine "SBV_Z3" "SBV_Z3_OPTIONS"+         , capabilities = SolverCapabilities {+                                supportsQuantifiers        = True+                              , supportsUninterpretedSorts = True+                              , supportsUnboundedInts      = True+                              , supportsReals              = True+                              , supportsApproxReals        = True+                              , supportsIEEE754            = True+                              , supportsOptimization       = True+                              , supportsPseudoBooleans     = True+                              , supportsCustomQueries      = True+                              , supportsGlobalDecls        = True+                              }          }- where cont rm skolemMap mbModelIndex = intercalate "\n" $ wrapModel grabValues-        where grabValues = concatMap extract skolemMap -              modelIndex = case mbModelIndex of-                             Nothing -> ""-                             Just i  -> " :model_index " ++ show i--              wrapModel xs = case mbModelIndex of-                               Just _ -> "(echo \"(sbv_objective_model_marker)\")" : xs-                               _      -> xs--              -- In the skolemMap:-              --    * Left's are universals: i.e., the model should be true for-              --      any of these. So, we simply "echo 0" for these values.-              --    * Right's are existentials. If there are no dependencies (empty list), then we can-              --      simply use get-value to extract it's value. Otherwise, we have to apply it to-              --      an appropriate number of 0's to get the final value.-              extract (Left s)        = ["(echo \"((" ++ show s ++ " " ++ mkSkolemZero rm (kindOf s) ++ "))\")"]-              extract (Right (s, [])) = let g = "(get-value (" ++ show s ++ ")" ++ modelIndex ++ ")" in getVal (kindOf s) g-              extract (Right (s, ss)) = let g = "(get-value ((" ++ show s ++ concat [' ' : mkSkolemZero rm (kindOf a) | a <- ss] ++ "))" ++ modelIndex ++ ")" in getVal (kindOf s) g--              getVal KReal g = ["(set-option :pp.decimal false) " ++ g, "(set-option :pp.decimal true)  " ++ g]-              getVal _     g = [g]--       addTimeOut Nothing  o   = o-       addTimeOut (Just i) o-         | i < 0               = error $ "Z3: Timeout value must be non-negative, received: " ++ show i-         | True                = o ++ [optionPrefix : "T:" ++ show i]--extractMap :: Bool -> [(Quantifier, NamedSymVar)] -> [String] -> SMTModel-extractMap isSat qinps solverLines =-   SMTModel { modelObjectives = map snd $               sortByNodeId $ concatMap (interpretSolverObjectiveLine inps) solverLines-            , modelAssocs     = map snd $ squashReals $ sortByNodeId $ concatMap (interpretSolverModelLine     inps) solverLines-            }-  where sortByNodeId :: [(Int, a)] -> [(Int, a)]-        sortByNodeId = sortBy (compare `on` fst)--        inps -- for "sat", display the prefix existentials. For completeness, we will drop-             -- only the trailing foralls. Exception: Don't drop anything if it's all a sequence of foralls-             | isSat = map snd $ if all (== ALL) (map fst qinps)-                                 then qinps-                                 else reverse $ dropWhile ((== ALL) . fst) $ reverse qinps-             -- for "proof", just display the prefix universals-             | True  = map snd $ takeWhile ((== ALL) . fst) qinps--        squashReals :: [(Int, (String, CW))] -> [(Int, (String, CW))]-        squashReals = concatMap squash . groupBy ((==) `on` fst)-          where squash [(i, (n, cw1)), (_, (_, cw2))] = [(i, (n, mergeReals n cw1 cw2))]-                squash xs = xs--                mergeReals :: String -> CW -> CW -> CW-                mergeReals n (CW KReal (CWAlgReal a)) (CW KReal (CWAlgReal b)) = CW KReal (CWAlgReal (mergeAlgReals (bad n a b) a b))-                mergeReals n a b = bad n a b--                bad n a b = error $ "SBV.Z3: Cannot merge reals for variable: " ++ n ++ " received: " ++ show (a, b)+ where modConfig :: [String] -> SMTConfig -> [String]+       modConfig opts _cfg = opts
Data/SBV/SMT/SMT.hs view
@@ -9,102 +9,136 @@ -- Abstraction of SMT solvers ----------------------------------------------------------------------------- -{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE DefaultSignatures   #-}+{-# LANGUAGE ScopedTypeVariables        #-}+{-# LANGUAGE DefaultSignatures          #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE Rank2Types                 #-}+{-# LANGUAGE NamedFieldPuns             #-} -module Data.SBV.SMT.SMT where+module Data.SBV.SMT.SMT (+       -- * Model extraction+         Modelable(..)+       , SatModel(..), genParse+       , extractModels, getModelValues+       , getModelDictionaries, getModelUninterpretedValues+       , displayModels, showModel +       -- * Standard prover engine+       , standardEngine++       -- * Results of various tasks+       , ThmResult(..)+       , SatResult(..)+       , AllSatResult(..)+       , SafeResult(..)+       , OptimizeResult(..)+       )+       where+ import qualified Control.Exception as C  import Control.Concurrent (newEmptyMVar, takeMVar, putMVar, forkIO) import Control.DeepSeq    (NFData(..))-import Control.Monad      (when, zipWithM)+import Control.Monad      (zipWithM) import Data.Char          (isSpace)+import Data.Maybe         (fromMaybe) import Data.Int           (Int8, Int16, Int32, Int64)-import Data.Function      (on)-import Data.List          (intercalate, isPrefixOf, isInfixOf, sortBy)+import Data.List          (intercalate, isPrefixOf) import Data.Word          (Word8, Word16, Word32, Word64)++import Data.IORef (readIORef, writeIORef)++import Data.Time          (getZonedTime, defaultTimeLocale, formatTime, diffUTCTime, getCurrentTime)+ import System.Directory   (findExecutable) import System.Environment (getEnv) import System.Exit        (ExitCode(..))-import System.IO          (hClose, hFlush, hPutStr, hGetContents, hGetLine)+import System.IO          (hClose, hFlush, hPutStrLn, hGetContents, hGetLine) import System.Process     (runInteractiveProcess, waitForProcess, terminateProcess)  import qualified Data.Map as M  import Data.SBV.Core.AlgReals import Data.SBV.Core.Data-import Data.SBV.Core.Symbolic (SMTEngine)+import Data.SBV.Core.Symbolic (SMTEngine, State(..)) -import Data.SBV.SMT.SMTLib    (interpretSolverOutput, interpretSolverModelLine, interpretSolverObjectiveLine)+import Data.SBV.SMT.Utils     (showTimeoutValue, alignPlain, alignDiagnostic, debug, mergeSExpr)  import Data.SBV.Utils.PrettyNum-import Data.SBV.Utils.Lib             (joinArgs, splitArgs)-import Data.SBV.Utils.TDiff+import Data.SBV.Utils.Lib       (joinArgs, splitArgs)+import Data.SBV.Utils.SExpr     (parenDeficit)+import Data.SBV.Utils.TDiff     (Timing(..), showTDiff) +import qualified System.Timeout as Timeout (timeout)+ -- | Extract the final configuration from a result resultConfig :: SMTResult -> SMTConfig-resultConfig (Unsatisfiable c _) = c+resultConfig (Unsatisfiable c)   = c resultConfig (Satisfiable   c _) = c resultConfig (SatExtField   c _) = c resultConfig (Unknown       c _) = c resultConfig (ProofError    c _) = c-resultConfig (TimeOut       c  ) = c  -- | A 'prove' call results in a 'ThmResult'-newtype ThmResult    = ThmResult    SMTResult+newtype ThmResult = ThmResult SMTResult+                  deriving NFData  -- | A 'sat' call results in a 'SatResult' -- The reason for having a separate 'SatResult' is to have a more meaningful 'Show' instance.-newtype SatResult    = SatResult    SMTResult+newtype SatResult = SatResult SMTResult+                  deriving NFData --- | An 'allSat' call results in a 'AllSatResult'. The boolean says whether--- we should warn the user about prefix-existentials.-newtype AllSatResult = AllSatResult (Bool, [SMTResult])+-- | An 'allSat' call results in a 'AllSatResult'. The first boolean says whether we+-- hit the max-model limit as we searched. The second boolean says whether+-- there were prefix-existentials.+newtype AllSatResult = AllSatResult (Bool, Bool, [SMTResult])  -- | A 'safe' call results in a 'SafeResult' newtype SafeResult   = SafeResult   (Maybe String, String, SMTResult) --- | An 'optimize' call results in a 'OptimizeResult'+-- | An 'optimize' call results in a 'OptimizeResult'. In the 'ParetoResult' case, the boolean is 'True'+-- if we reached pareto-query limit and so there might be more unqueried results remaining. If 'False',+-- it means that we have all the pareto fronts returned. See the 'Pareto' 'OptimizeStyle' for details. data OptimizeResult = LexicographicResult SMTResult-                    | ParetoResult        [SMTResult]+                    | ParetoResult        (Bool, [SMTResult])                     | IndependentResult   [(String, SMTResult)] --- | User friendly way of printing theorem results+-- User friendly way of printing theorem results instance Show ThmResult where   show (ThmResult r) = showSMTResult "Q.E.D."-                                     "Unknown"     "Unknown. Potential counter-example:\n"+                                     "Unknown"                                      "Falsifiable" "Falsifiable. Counter-example:\n" "Falsifiable in an extension field:\n" r --- | User friendly way of printing satisfiablity results+-- User friendly way of printing satisfiablity results instance Show SatResult where   show (SatResult r) = showSMTResult "Unsatisfiable"-                                     "Unknown"     "Unknown. Potential model:\n"+                                     "Unknown"                                      "Satisfiable" "Satisfiable. Model:\n" "Satisfiable in an extension field. Model:\n" r --- | User friendly way of printing safety results+-- User friendly way of printing safety results instance Show SafeResult where    show (SafeResult (mbLoc, msg, r)) = showSMTResult (tag "No violations detected")-                                                     (tag "Unknown")  (tag "Unknown. Potential violating model:\n")+                                                     (tag "Unknown")                                                      (tag "Violated") (tag "Violated. Model:\n") (tag "Violated in an extension field:\n") r         where loc   = maybe "" (++ ": ") mbLoc               tag s = loc ++ msg ++ ": " ++ s --- | The Show instance of AllSatResults. Note that we have to be careful in being lazy enough+-- The Show instance of AllSatResults. Note that we have to be careful in being lazy enough -- as the typical use case is to pull results out as they become available. instance Show AllSatResult where-  show (AllSatResult (e, xs)) = go (0::Int) xs+  show (AllSatResult (l, e, xs)) = go (0::Int) xs     where uniqueWarn | e    = " (Unique up to prefix existentials.)"                      | True = ""           go c (s:ss) = let c'      = c+1                             (ok, o) = sh c' s                         in c' `seq` if ok then o ++ "\n" ++ go c' ss else o-          go c []     = case c of-                          0 -> "No solutions found."-                          1 -> "This is the only solution." ++ uniqueWarn-                          _ -> "Found " ++ show c ++ " different solutions." ++ uniqueWarn+          go c []     = case (l, c) of+                          (True,  _) -> "Search stopped since model count request was reached." ++ uniqueWarn+                          (False, 0) -> "No solutions found."+                          (False, 1) -> "This is the only solution." ++ uniqueWarn+                          (False, _) -> "Found " ++ show c ++ " different solutions." ++ uniqueWarn           sh i c = (ok, showSMTResult "Unsatisfiable"-                                      "Unknown" "Unknown. Potential model:\n"+                                      "Unknown"                                       ("Solution #" ++ show i ++ ":\nSatisfiable") ("Solution #" ++ show i ++ ":\n")                                       ("Solution $" ++ show i ++ " in an extension field:\n")                                       c)@@ -112,15 +146,18 @@                            Satisfiable{} -> True                            _             -> False --- | Show instance for optimization results+-- Show instance for optimization results instance Show OptimizeResult where   show res = case res of                LexicographicResult r   -> sh id r                 IndependentResult   rs  -> multi "objectives" (map (uncurry shI) rs) -               ParetoResult        [r] -> sh (\s -> "Unique pareto front: " ++ s) r-               ParetoResult        rs  -> multi "pareto optimal values" (zipWith shP [(1::Int)..] rs)+               ParetoResult (False, [r]) -> sh (\s -> "Unique pareto front: " ++ s) r+               ParetoResult (False, rs)  -> multi "pareto optimal values" (zipWith shP [(1::Int)..] rs)+               ParetoResult (True,  rs)  ->    multi "pareto optimal values" (zipWith shP [(1::Int)..] rs)+                                           ++ "\n*** Note: Pareto-front extraction was terminated before stream was ended as requested by the user."+                                           ++ "\n***       There might be other (potentially infinitely more) results."         where multi w [] = "There are no " ++ w ++ " to display models for."              multi _ xs = intercalate "\n" xs@@ -130,7 +167,6 @@               sh tag = showSMTResult (tag "Unsatisfiable.")                                     (tag "Unknown.")-                                    (tag "Unknown. Potential model:" ++ "\n")                                     (tag "Optimal with no assignments.")                                     (tag "Optimal model:" ++ "\n")                                     (tag "Optimal in an extension field:" ++ "\n")@@ -280,9 +316,9 @@   -- | Is there a model?   modelExists :: a -> Bool -  -- | Extract a model, the result is a tuple where the first argument (if True)+  -- | Extract assignments of 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.)-  getModel :: SatModel b => a -> Either String (Bool, b)+  getModelAssignment :: SatModel b => a -> Either String (Bool, b)    -- | Extract a model dictionary. Extract a dictionary mapping the variables to   -- their respective values as returned by the SMT solver. Also see `getModelDictionaries`.@@ -300,9 +336,9 @@                                      Just (CW _ (CWUserSort (_, s))) -> Just s                                      _                               -> Nothing -  -- | A simpler variant of 'getModel' to get a model out without the fuss.+  -- | A simpler variant of 'getModelAssignment' to get a model out without the fuss.   extractModel :: SatModel b => a -> Maybe b-  extractModel a = case getModel a of+  extractModel a = case getModelAssignment a of                      Right (_, b) -> Just b                      _            -> Nothing @@ -313,50 +349,44 @@   getModelObjectiveValue :: String -> a -> Maybe GeneralizedCW   getModelObjectiveValue v r = v `M.lookup` getModelObjectives r -  -- | Extract unsat core-  extractUnsatCore :: a -> Maybe [String]- -- | Return all the models from an 'allSat' call, similar to 'extractModel' but -- is suitable for the case of multiple results. extractModels :: SatModel a => AllSatResult -> [a]-extractModels (AllSatResult (_, xs)) = [ms | Right (_, ms) <- map getModel xs]+extractModels (AllSatResult (_, _, xs)) = [ms | Right (_, ms) <- map getModelAssignment xs]  -- | Get dictionaries from an all-sat call. Similar to `getModelDictionary`. getModelDictionaries :: AllSatResult -> [M.Map String CW]-getModelDictionaries (AllSatResult (_, xs)) = map getModelDictionary xs+getModelDictionaries (AllSatResult (_, _, xs)) = map getModelDictionary xs  -- | Extract value of a variable from an all-sat call. Similar to `getModelValue`. getModelValues :: SymWord b => String -> AllSatResult -> [Maybe b]-getModelValues s (AllSatResult (_, xs)) =  map (s `getModelValue`) xs+getModelValues s (AllSatResult (_, _, xs)) =  map (s `getModelValue`) xs  -- | Extract value of an uninterpreted variable from an all-sat call. Similar to `getModelUninterpretedValue`. getModelUninterpretedValues :: String -> AllSatResult -> [Maybe String]-getModelUninterpretedValues s (AllSatResult (_, xs)) =  map (s `getModelUninterpretedValue`) xs+getModelUninterpretedValues s (AllSatResult (_, _, xs)) =  map (s `getModelUninterpretedValue`) xs  -- | 'ThmResult' as a generic model provider instance Modelable ThmResult where-  getModel           (ThmResult r) = getModel r+  getModelAssignment (ThmResult r) = getModelAssignment r   modelExists        (ThmResult r) = modelExists r   getModelDictionary (ThmResult r) = getModelDictionary r   getModelObjectives (ThmResult r) = getModelObjectives r-  extractUnsatCore   (ThmResult r) = extractUnsatCore   r  -- | 'SatResult' as a generic model provider instance Modelable SatResult where-  getModel           (SatResult r) = getModel r+  getModelAssignment (SatResult r) = getModelAssignment r   modelExists        (SatResult r) = modelExists r   getModelDictionary (SatResult r) = getModelDictionary r   getModelObjectives (SatResult r) = getModelObjectives r-  extractUnsatCore   (SatResult r) = extractUnsatCore   r  -- | 'SMTResult' as a generic model provider instance Modelable SMTResult where-  getModel (Unsatisfiable _ _) = Left "SBV.getModel: Unsatisfiable result"-  getModel (Satisfiable _ m)   = Right (False, parseModelOut m)-  getModel (SatExtField _ _)   = Left "SBV.getModel: The model is in an extension field"-  getModel (Unknown _ m)       = Right (True, parseModelOut m)-  getModel (ProofError _ s)    = error $ unlines $ "Backend solver complains: " : s-  getModel (TimeOut _)         = Left "Timeout"+  getModelAssignment (Unsatisfiable _) = Left "SBV.getModelAssignment: Unsatisfiable result"+  getModelAssignment (Satisfiable _ m) = Right (False, parseModelOut m)+  getModelAssignment (SatExtField _ _) = Left "SBV.getModelAssignment: The model is in an extension field"+  getModelAssignment (Unknown _ m)     = Left $ "SBV.getModelAssignment: Solver state is unknown: " ++ m+  getModelAssignment (ProofError _ s)  = error $ unlines $ "Backend solver complains: " : s    modelExists Satisfiable{}   = True   modelExists Unknown{}       = False -- don't risk it@@ -365,63 +395,44 @@   getModelDictionary Unsatisfiable{}   = M.empty   getModelDictionary (Satisfiable _ m) = M.fromList (modelAssocs m)   getModelDictionary SatExtField{}     = M.empty-  getModelDictionary (Unknown _ m)     = M.fromList (modelAssocs m)+  getModelDictionary Unknown{}         = M.empty   getModelDictionary ProofError{}      = M.empty-  getModelDictionary TimeOut{}         = M.empty    getModelObjectives Unsatisfiable{}   = M.empty   getModelObjectives (Satisfiable _ m) = M.fromList (modelObjectives m)   getModelObjectives (SatExtField _ m) = M.fromList (modelObjectives m)-  getModelObjectives (Unknown _ m)     = M.fromList (modelObjectives m)+  getModelObjectives Unknown{}         = M.empty   getModelObjectives ProofError{}      = M.empty-  getModelObjectives TimeOut{}         = M.empty -  extractUnsatCore (Unsatisfiable _ uc) = uc-  extractUnsatCore Satisfiable{}        = Nothing-  extractUnsatCore SatExtField{}        = Nothing-  extractUnsatCore Unknown{}            = Nothing-  extractUnsatCore ProofError{}         = Nothing-  extractUnsatCore TimeOut{}            = Nothing- -- | Extract a model out, will throw error if parsing is unsuccessful parseModelOut :: SatModel a => SMTModel -> a parseModelOut m = case parseCWs [c | (_, c) <- modelAssocs m] of                    Just (x, []) -> x-                   Just (_, ys) -> error $ "SBV.getModel: Partially constructed model; remaining elements: " ++ show ys-                   Nothing      -> error $ "SBV.getModel: Cannot construct a model from: " ++ show m+                   Just (_, ys) -> error $ "SBV.parseModelOut: Partially constructed model; remaining elements: " ++ show ys+                   Nothing      -> error $ "SBV.parseModelOut: Cannot construct a model from: " ++ show m  -- | Given an 'allSat' call, we typically want to iterate over it and print the results in sequence. The -- 'displayModels' function automates this task by calling 'disp' on each result, consecutively. The first -- 'Int' argument to 'disp' 'is the current model number. The second argument is a tuple, where the first -- element indicates whether the model is alleged (i.e., if the solver is not sure, returing Unknown) displayModels :: SatModel a => (Int -> (Bool, a) -> IO ()) -> AllSatResult -> IO Int-displayModels disp (AllSatResult (_, ms)) = do-    inds <- zipWithM display [a | Right a <- map (getModel . SatResult) ms] [(1::Int)..]+displayModels disp (AllSatResult (_, _, ms)) = do+    inds <- zipWithM display [a | Right a <- map (getModelAssignment . SatResult) ms] [(1::Int)..]     return $ last (0:inds)   where display r i = disp i r >> return i  -- | Show an SMTResult; generic version-showSMTResult :: String -> String -> String -> String -> String -> String -> SMTResult -> String-showSMTResult unsatMsg unkMsg unkMsgModel satMsg satMsgModel satExtMsg result = case result of-  Unsatisfiable _ mbUC          -> unsatMsg ++ showUC mbUC+showSMTResult :: String -> String -> String -> String -> String -> SMTResult -> String+showSMTResult unsatMsg unkMsg satMsg satMsgModel satExtMsg result = case result of+  Unsatisfiable _               -> unsatMsg   Satisfiable _ (SMTModel _ []) -> satMsg   Satisfiable _ m               -> satMsgModel ++ showModel cfg m   SatExtField _ (SMTModel b _)  -> satExtMsg   ++ showModelDictionary cfg b-  Unknown     _ (SMTModel _ []) -> unkMsg-  Unknown     _ m               -> unkMsgModel ++ showModel cfg m+  Unknown     _ r               -> unkMsg ++ ".\n" ++ "  Reason: " `alignPlain` r   ProofError  _ []              -> "*** An error occurred. No additional information available. Try running in verbose mode"   ProofError  _ ls              -> "*** An error occurred.\n" ++ intercalate "\n" (map ("***  " ++) ls)-  TimeOut     _                 -> "*** Timeout"  where cfg = resultConfig result -       showUC Nothing   = ""-       showUC (Just []) = dot ++ "[No unsat core received. Have you labeled relevant assertions?]"-       showUC (Just xs) = intercalate "\n" $ (dot ++ "Unsat core:") : map ("  " ++) xs--       dot = case reverse unsatMsg of-               ('.':_) -> " "-               _       -> ". "- -- | Show a model in human readable form. Ignore bindings to those variables that start -- with "__internal_sbv_" and also those marked as "nonModelVar" in the config; as these are only for internal purposes showModel :: SMTConfig -> SMTModel -> String@@ -467,210 +478,391 @@         sh 16 = hexS         sh n  = \w -> show w ++ " -- Ignoring unsupported printBase " ++ show n ++ ", use 2, 10, or 16." --- | Print uninterpreted function values from models. Very, very crude..-shUI :: (String, [String]) -> [String]-shUI (flong, cases) = ("  -- uninterpreted: " ++ f) : map shC cases-  where tf = dropWhile (/= '_') flong-        f  =  if null tf then flong else tail tf-        shC s = "       " ++ s---- | Print uninterpreted array values from models. Very, very crude..-shUA :: (String, [String]) -> [String]-shUA (f, cases) = ("  -- array: " ++ f) : map shC cases-  where shC s = "       " ++ s- -- | Helper function to spin off to an SMT solver.-pipeProcess :: SMTConfig -> String -> [String] -> SMTScript -> (String -> String) -> IO (Either String [String])-pipeProcess cfg execName opts script cleanErrs = do-        let nm = show (name (solver cfg))-        mbExecPath <- findExecutable execName-        case mbExecPath of-          Nothing       -> return $ Left $ "Unable to locate executable for " ++ nm-                                        ++ "\nExecutable specified: " ++ show execName-          Just execPath ->-                   do solverResult <- dispatchSolver cfg execPath opts script-                      case solverResult of-                        Left s                          -> return $ Left s-                        Right (ec, contents, allErrors) ->-                          let errors = dropWhile isSpace (cleanErrs allErrors)-                          in case (null errors, ec) of-                                (True, ExitSuccess)  -> return $ Right $ map clean (filter (not . null) (lines contents))-                                (_, ec')             -> let errors' = if null errors-                                                                      then (if null (dropWhile isSpace contents)-                                                                            then "(No error message printed on stderr by the executable.)"-                                                                            else contents)-                                                                      else errors-                                                            finalEC = case (ec', ec) of-                                                                        (ExitFailure n, _) -> n-                                                                        (_, ExitFailure n) -> n-                                                                        _                  -> 0 -- can happen if ExitSuccess but there is output on stderr-                                                        in return $ Left $  "Failed to complete the call to " ++ nm-                                                                         ++ "\nExecutable   : " ++ show execPath-                                                                         ++ "\nOptions      : " ++ joinArgs opts-                                                                         ++ "\nExit code    : " ++ show finalEC-                                                                         ++ "\nSolver output: "-                                                                         ++ "\n" ++ line ++ "\n"-                                                                         ++ intercalate "\n" (filter (not . null) (lines errors'))-                                                                         ++ "\n" ++ line-                                                                         ++ "\nGiving up.."-  where clean = reverse . dropWhile isSpace . reverse . dropWhile isSpace-        line  = replicate 78 '='---- | The standard-model that most SMT solvers should happily work with-standardModel :: (Bool -> [(Quantifier, NamedSymVar)] -> [String] -> SMTModel, SW -> String -> [String])-standardModel = (standardModelExtractor, standardValueExtractor)---- | Some solvers (Z3) require multiple calls for certain value extractions; as in multi-precision reals. Deal with that here-standardValueExtractor :: SW -> String -> [String]-standardValueExtractor _ l = [l]+pipeProcess :: SMTConfig -> State -> String -> [String] -> String -> (State -> IO a) -> IO a+pipeProcess cfg ctx execName opts pgm continuation = do+    mbExecPath <- findExecutable execName+    case mbExecPath of+      Nothing      -> error $ unlines [ "Unable to locate executable for " ++ show (name (solver cfg))+                                      , "Executable specified: " ++ show execName+                                      ] --- | A standard post-processor: Reading the lines of solver output and turning it into a model:-standardModelExtractor :: Bool -> [(Quantifier, NamedSymVar)] -> [String] -> SMTModel-standardModelExtractor isSat qinps solverLines = SMTModel { modelObjectives = map snd $ sortByNodeId $ concatMap (interpretSolverObjectiveLine inps) solverLines-                                                          , modelAssocs     = map snd $ sortByNodeId $ concatMap (interpretSolverModelLine     inps) solverLines-                                                          }-         where sortByNodeId :: [(Int, a)] -> [(Int, a)]-               sortByNodeId = sortBy (compare `on` fst)-               inps -- for "sat", display the prefix existentials. For completeness, we will drop-                    -- only the trailing foralls. Exception: Don't drop anything if it's all a sequence of foralls-                    | isSat = map snd $ if all (== ALL) (map fst qinps)-                                        then qinps-                                        else reverse $ dropWhile ((== ALL) . fst) $ reverse qinps-                    -- for "proof", just display the prefix universals-                    | True  = map snd $ takeWhile ((== ALL) . fst) qinps+      Just execPath -> runSolver cfg ctx execPath opts pgm continuation+                       `C.catches`+                        [ C.Handler (\(e :: C.ErrorCall)     -> C.throw e)+                        , C.Handler (\(e :: C.SomeException) -> error $ unlines [ "Failed to start the external solver:\n" ++ show e+                                                                                , "Make sure you can start " ++ show execPath+                                                                                , "from the command line without issues."+                                                                                ])+                        ]  -- | A standard engine interface. Most solvers follow-suit here in how we "chat" to them.. standardEngine :: String                -> String-               -> (SMTConfig -> SMTConfig)-               -> ([String] -> Int -> [String])-               -> (Bool -> [(Quantifier, NamedSymVar)] -> [String] -> SMTModel, SW -> String -> [String])                -> SMTEngine-standardEngine envName envOptName modConfig addTimeOut (extractMap, extractValue) cfgIn isSat mbOptInfo qinps skolemMap pgm = do--    let cfg = modConfig cfgIn--    -- If there's an optimization goal, it better be handled by a custom engine!-    () <- case mbOptInfo of-            Nothing -> return ()-            Just _  -> error $ "SBV.standardEngine: Solver: " ++ show (name (solver cfg)) ++ " doesn't support optimization!"+standardEngine envName envOptName cfg ctx pgm continuation = do      execName <-                    getEnv envName     `C.catch` (\(_ :: C.SomeException) -> return (executable (solver cfg)))-    execOpts <- (splitArgs `fmap`  getEnv envOptName) `C.catch` (\(_ :: C.SomeException) -> return (options (solver cfg)))--    let cfg'    = cfg {solver = (solver cfg) {executable = execName, options = maybe execOpts (addTimeOut execOpts) (timeOut cfg)}}-        tweaks  = case solverTweaks cfg' of-                    [] -> ""-                    ts -> unlines $ "; --- user given solver tweaks ---" : ts ++ ["; --- end of user given tweaks ---"]--        cont rm = intercalate "\n" $ concatMap extract skolemMap-           where extract (Left s)        = extractValue s $ "(echo \"((" ++ show s ++ " " ++ mkSkolemZero rm (kindOf s) ++ "))\")"-                 extract (Right (s, [])) = extractValue s $ "(get-value (" ++ show s ++ "))"-                 extract (Right (s, ss)) = extractValue s $ "(get-value (" ++ show s ++ concat [' ' : mkSkolemZero rm (kindOf a) | a <- ss] ++ "))"--        script = SMTScript {scriptBody = tweaks ++ pgm, scriptModel = Just (cont (roundingMode cfg))}+    execOpts <- (splitArgs `fmap`  getEnv envOptName) `C.catch` (\(_ :: C.SomeException) -> return (options (solver cfg) cfg)) -        -- standard engines only return one result ever-        wrap x = [x]+    let cfg' = cfg {solver = (solver cfg) {executable = execName, options = const execOpts}} -    standardSolver cfg' script id (wrap . ProofError cfg') (wrap . interpretSolverOutput cfg' (extractMap isSat qinps))+    standardSolver cfg' ctx pgm continuation  -- | A standard solver interface. If the solver is SMT-Lib compliant, then this function should suffice in -- communicating with it.-standardSolver :: SMTConfig -> SMTScript -> (String -> String) -> ([String] -> a) -> ([String] -> a) -> IO a-standardSolver config script cleanErrs failure success = do-    let msg      = when (verbose config) . putStrLn . ("** " ++)+standardSolver :: SMTConfig       -- ^ The currrent configuration+               -> State           -- ^ Context in which we are running+               -> String          -- ^ The program+               -> (State -> IO a) -- ^ The continuation+               -> IO a+standardSolver config ctx pgm continuation = do+    let msg s    = debug config ["** " ++ s]         smtSolver= solver config         exec     = executable smtSolver-        opts     = options smtSolver-        isTiming = timing config-        nmSolver = show (name smtSolver)-    msg $ "Calling: " ++ show (exec ++ (if null opts then "" else " ") ++ joinArgs opts)-    case smtFile config of-      Nothing -> return ()-      Just f  -> do msg $ "Saving the generated script in file: " ++ show f-                    writeFile f (scriptBody script ++ intercalate "\n" ("" : optimizeArgs config ++ [satCmd config]))-    contents <- timeIf isTiming (WorkByProver nmSolver) $ pipeProcess config exec opts script cleanErrs-    msg $ nmSolver ++ " output:\n" ++ either id (intercalate "\n") contents-    case contents of-      Left e   -> return $ failure (lines e)-      Right xs -> return $ success (mergeSExpr xs)+        opts     = options smtSolver config+    msg $ "Calling: "  ++ (exec ++ (if null opts then "" else " ") ++ joinArgs opts)+    rnf pgm `seq` pipeProcess config ctx exec opts pgm continuation --- | Wrap the solver call to protect against any exceptions-dispatchSolver :: SMTConfig -> FilePath -> [String] -> SMTScript -> IO (Either String (ExitCode, String, String))-dispatchSolver cfg execPath opts script = rnf script `seq` (Right `fmap` runSolver cfg execPath opts script) `C.catch` (\(e::C.SomeException) -> bad (show e))-  where bad s = return $ Left $ unlines [ "Failed to start the external solver: " ++ s-                                        , "Make sure you can start " ++ show execPath-                                        , "from the command line without issues."-                                        ]+-- | An internal type to track of solver interactions+data SolverLine = SolverRegular   String  -- ^ All is well+                | SolverTimeout   String  -- ^ Timeout expired+                | SolverException String  -- ^ Something else went wrong --- | A variant of 'readProcessWithExitCode'; except it knows about continuation strings--- and can speak SMT-Lib2 (just a little).-runSolver :: SMTConfig -> FilePath -> [String] -> SMTScript -> IO (ExitCode, String, String)-runSolver cfg execPath opts script- = do (send, ask, cleanUp, pid) <- do+-- | A variant of 'readProcessWithExitCode'; except it deals with SBV continuations+runSolver :: SMTConfig -> State -> FilePath -> [String] -> String -> (State -> IO a) -> IO a+runSolver cfg ctx execPath opts pgm continuation+ = do let nm  = show (name (solver cfg))+          msg = debug cfg . map ("*** " ++)++      (send, ask, getResponseFromSolver, terminateSolver, cleanUp, pid) <- do                 (inh, outh, errh, pid) <- runInteractiveProcess execPath opts Nothing Nothing-                let send l    = hPutStr inh (l ++ "\n") >> hFlush inh-                    recv      = hGetLine outh-                    ask l     = send l >> recv-                    cleanUp response-                        = do hClose inh-                             outMVar <- newEmptyMVar-                             out <- hGetContents outh-                             _ <- forkIO $ C.evaluate (length out) >> putMVar outMVar ()-                             err <- hGetContents errh-                             _ <- forkIO $ C.evaluate (length err) >> putMVar outMVar ()-                             takeMVar outMVar-                             takeMVar outMVar-                             hClose outh-                             hClose errh-                             ex <- waitForProcess pid-                             return $ case response of-                                        Nothing        -> (ex, out, err)-                                        Just (r, vals) -> -- if the status is unknown, prepare for the possibility of not having a model-                                                          -- TBD: This is rather crude and potentially Z3 specific-                                                          let finalOut = intercalate "\n" (r : vals)-                                                              notAvail = "model is not available" `isInfixOf` (finalOut ++ out ++ err)-                                                          in if "unknown" `isPrefixOf` r && notAvail-                                                             then (ExitSuccess, "unknown"              , "")-                                                             else (ex,          finalOut ++ "\n" ++ out, err)-                return (send, ask, cleanUp, pid)-      let executeSolver = do mapM_ send (lines (scriptBody script))-                             mapM_ send (optimizeArgs cfg)-                             response <- case scriptModel script of-                                           Nothing -> do send $ satCmd cfg-                                                         return Nothing-                                           Just ls -> do r    <- ask $ satCmd cfg-                                                         vals <- case () of-                                                                    () | any (`isPrefixOf` r) ["sat", "unknown"]-                                                                       -> do let mls = lines ls-                                                                             when (verbose cfg) $ do putStrLn "** Sending the following model extraction commands:"-                                                                                                     mapM_ putStrLn mls-                                                                             mapM ask mls-                                                                    () | getUnsatCore cfg && "unsat" `isPrefixOf` r-                                                                       -> do when (verbose cfg) $ putStrLn "** Querying for unsat cores"-                                                                             mapM ask ["(get-unsat-core)"]-                                                                    () -> return []-                                                         return $ Just (r, vals)-                             cleanUp response-      executeSolver `C.onException`  (terminateProcess pid >> waitForProcess pid) --- | In case the SMT-Lib solver returns a response over multiple lines, compress them so we have--- each S-Expression spanning only a single line. We'll ignore things like parentheses inside quotes--- etc., as it should not be an issue-mergeSExpr :: [String] -> [String]-mergeSExpr []       = []-mergeSExpr (x:xs)- | d == 0 = x : mergeSExpr xs- | True   = let (f, r) = grab d xs in unwords (x:f) : mergeSExpr r- where d = parenDiff x-       parenDiff :: String -> Int-       parenDiff = go 0-         where go i ""       = i-               go i ('(':cs) = let i'= i+1 in i' `seq` go i' cs-               go i (')':cs) = let i'= i-1 in i' `seq` go i' cs-               go i (_  :cs) = go i cs-       grab i ls-         | i <= 0    = ([], ls)-       grab _ []     = ([], [])-       grab i (l:ls) = let (a, b) = grab (i+parenDiff l) ls in (l:a, b)+                let -- send a command down, but check that we're balanced in parens. If we aren't+                    -- this is most likely an SBV bug.+                    send :: Maybe Int -> String -> IO ()+                    send mbTimeOut command+                      | parenDeficit command /= 0+                      = error $ unlines [ ""+                                        , "*** Data.SBV: Unbalanced input detected."+                                        , "***"+                                        , "***   Sending: " ++ command+                                        , "***"+                                        , "*** This is most likely an SBV bug. Please report!"+                                        ]+                      | True+                      = do hPutStrLn inh command+                           hFlush inh+                           recordTranscript (transcript cfg) $ Left (command, mbTimeOut)++                    -- Send a line, get a whole s-expr. We ignore the pathetic case that there might be a string with an unbalanced parentheses in it in a response.+                    ask :: Maybe Int -> String -> IO String+                    ask mbTimeOut command =+                                  -- solvers don't respond to empty lines or comments; we just pass back+                                  -- success in these cases to keep the illusion of everything has a response+                                  let cmd = dropWhile isSpace command+                                  in if null cmd || ";" `isPrefixOf` cmd+                                     then return "success"+                                     else do send mbTimeOut command+                                             getResponseFromSolver (Just command) mbTimeOut++                    -- Get a response from the solver, with an optional time-out on how long+                    -- to wait. Note that there's *always* a time-out of 5 seconds once we get the+                    -- first line of response, as while the solver might take it's time to respond,+                    -- once it starts responding successive lines should come quickly.+                    getResponseFromSolver :: Maybe String -> Maybe Int -> IO String+                    getResponseFromSolver mbCommand mbTimeOut = do+                                response <- go True 0 []+                                let collated = intercalate "\n" $ reverse response+                                recordTranscript (transcript cfg) $ Right collated+                                return collated++                      where safeGetLine isFirst h =+                                         let timeOutToUse | isFirst = mbTimeOut+                                                          | True    = Just 5000000+                                             timeOutMsg t | isFirst = "User specified timeout of " ++ showTimeoutValue t ++ " exceeded."+                                                          | True    = "A multiline complete response wasn't received before " ++ showTimeoutValue t ++ " exceeded."+                                         in case timeOutToUse of+                                              Nothing -> SolverRegular <$> hGetLine h+                                              Just t  -> do r <- Timeout.timeout t (hGetLine h)+                                                            case r of+                                                              Just l  -> return $ SolverRegular l+                                                              Nothing -> return $ SolverTimeout $ timeOutMsg t++                            go isFirst i sofar = do+                                            errln <- safeGetLine isFirst outh `C.catch` (\(e :: C.SomeException) -> return (SolverException (show e)))+                                            case errln of+                                              SolverRegular ln -> let need  = i + parenDeficit ln+                                                                      -- make sure we get *something*+                                                                      empty = case dropWhile isSpace ln of+                                                                                []      -> True+                                                                                (';':_) -> True   -- yes this does happen! I've seen z3 print out comments on stderr.+                                                                                _       -> False+                                                                  in case (empty, need <= 0) of+                                                                        (True, _)      -> do debug cfg ["[SKIP] " `alignPlain` ln]+                                                                                             go isFirst need sofar+                                                                        (False, False) -> go False   need (ln:sofar)+                                                                        (False, True)  -> return (ln:sofar)++                                              SolverException e -> error $ unlines $ [""+                                                                                     , "*** Error     : " ++ e+                                                                                     , "*** Executable: " ++ execPath+                                                                                     , "*** Options   : " ++ joinArgs opts+                                                                                     ]+                                                                                  ++ [ "*** Request   : " `alignDiagnostic` command                 | Just command <- [mbCommand]]+                                                                                  ++ [ "*** Response  : " `alignDiagnostic` unlines (reverse sofar) | not $ null sofar           ]+                                                                                  ++ [ "***"+                                                                                     , "*** Giving up!"+                                                                                     ]++                                              SolverTimeout e -> do terminateProcess pid -- NB. Do not *wait* for the process, just quit.+                                                                    error $ unlines $ [ ""+                                                                                      , "*** Data.SBV: Timeout."+                                                                                      , "***"+                                                                                      , "***   " ++ e+                                                                                      ]+                                                                                   ++ [ "***   Response so far: " `alignDiagnostic` unlines (reverse sofar) | not $ null sofar]+                                                                                   ++ [ "***   Last command sent was: " `alignDiagnostic` command | Just command <- [mbCommand]]+                                                                                   ++ [ "***   Run with 'verbose=True' for further information" | not (verbose cfg)]+                                                                                   ++ [ "***"+                                                                                      , "*** Giving up!"+                                                                                      ]++                    terminateSolver = do hClose inh+                                         outMVar <- newEmptyMVar+                                         out <- hGetContents outh `C.catch`  (\(e :: C.SomeException) -> return (show e))+                                         _ <- forkIO $ C.evaluate (length out) >> putMVar outMVar ()+                                         err <- hGetContents errh `C.catch`  (\(e :: C.SomeException) -> return (show e))+                                         _ <- forkIO $ C.evaluate (length err) >> putMVar outMVar ()+                                         takeMVar outMVar+                                         takeMVar outMVar+                                         hClose outh `C.catch`  (\(_ :: C.SomeException) -> return ())+                                         hClose errh `C.catch`  (\(_ :: C.SomeException) -> return ())+                                         ex <- waitForProcess pid `C.catch` (\(_ :: C.SomeException) -> return (ExitFailure (-999)))+                                         return (out, err, ex)++                    cleanUp+                      = do (out, err, ex) <- terminateSolver++                           msg $   [ "Solver   : " ++ nm+                                   , "Exit code: " ++ show ex+                                   ]+                                ++ [ "Std-out  : " ++ intercalate "\n           " (lines out) | not (null out)]+                                ++ [ "Std-err  : " ++ intercalate "\n           " (lines err) | not (null err)]++                           case ex of+                             ExitSuccess -> return ()+                             _           -> if ignoreExitCode cfg+                                               then msg ["Ignoring non-zero exit code of " ++ show ex ++ " per user request!"]+                                               else error $ unlines $  [ ""+                                                                       , "*** Failed to complete the call to " ++ nm ++ ":"+                                                                       , "*** Executable   : " ++ execPath+                                                                       , "*** Options      : " ++ joinArgs opts+                                                                       , "*** Exit code    : " ++ show ex+                                                                       ]+                                                                    ++ [ "*** Std-out      : " ++ intercalate "\n                   " (lines out)]+                                                                    ++ [ "*** Std-err      : " ++ intercalate "\n                   " (lines err)]+                                                                    ++ ["Giving up.."]+                return (send, ask, getResponseFromSolver, terminateSolver, cleanUp, pid)++      let executeSolver = do let sendAndGetSuccess :: Maybe Int -> String -> IO ()+                                 sendAndGetSuccess mbTimeOut l+                                   -- The pathetic case when the solver doesn't support queries, so we pretend it responded "success"+                                   -- Currently ABC is the only such solver. Filed a request for ABC at: https://bitbucket.org/alanmi/abc/issues/70/+                                   | not (supportsCustomQueries (capabilities (solver cfg)))+                                   = do send mbTimeOut l+                                        debug cfg ["[ISSUE] " `alignPlain` l]+                                   | True+                                   = do r <- ask mbTimeOut l+                                        case words r of+                                          ["success"] -> debug cfg ["[GOOD] " `alignPlain` l]+                                          _           -> do debug cfg ["[FAIL] " `alignPlain` l]++                                                            let isOption = "(set-option" `isPrefixOf` dropWhile isSpace l++                                                                reason | isOption = [ "*** Backend solver reports it does not support this option."+                                                                                    , "*** Please report this as a bug/feature request with the solver!"+                                                                                    ]+                                                                       | True     = [ "*** Failed to establish solver context. Running in debug mode might provide"+                                                                                    , "*** more information. Please report this as an issue!"+                                                                                    ]++                                                            -- put a sync point here before we die so we consume everything+                                                            mbExtras <- (Right <$> getResponseFromSolver Nothing (Just 5000000)) `C.catch` (\(e :: C.SomeException) -> return (Left (show e)))++                                                            -- Ignore any exceptions from last sync, pointless.+                                                            let extras = case mbExtras of+                                                                           Left _   -> []+                                                                           Right xs -> xs++                                                            (outOrig, errOrig, ex) <- terminateSolver+                                                            let out = intercalate "\n" . lines $ outOrig+                                                                err = intercalate "\n" . lines $ errOrig++                                                            error $ unlines $  [""+                                                                               , "*** Data.SBV: Unexpected non-success response from " ++ nm ++ ":"+                                                                               , "***"+                                                                               , "***    Sent      : " `alignDiagnostic` l+                                                                               , "***    Expected  : success"+                                                                               , "***    Received  : " `alignDiagnostic` (r ++ "\n" ++ extras)+                                                                               ]+                                                                            ++ [ "***    Stdout    : " `alignDiagnostic` out | not $ null out]+                                                                            ++ [ "***    Stderr    : " `alignDiagnostic` err | not $ null err]+                                                                            ++ [ "***    Exit code : " ++ show ex+                                                                               , "***"+                                                                               , "***    Executable: " ++ execPath+                                                                               , "***    Options   : " ++ joinArgs opts+                                                                               , "***"+                                                                               ]+                                                                              ++ reason++                             -- Mark in the log, mostly.+                             sendAndGetSuccess Nothing "; Automatically generated by SBV. Do not edit."++                             -- First check that the solver supports :print-success+                             let backend = name $ solver cfg+                             if not (supportsCustomQueries (capabilities (solver cfg)))+                                then debug cfg ["** Skipping heart-beat for the solver " ++ show backend]+                                else do let heartbeat = "(set-option :print-success true)"+                                        r <- ask (Just 5000000) heartbeat  -- Give the solver 5s to respond, this should be plenty enough!+                                        case words r of+                                          ["success"]     -> debug cfg ["[GOOD] " ++ heartbeat]+                                          ["unsupported"] -> error $ unlines [ ""+                                                                             , "*** Backend solver (" ++  show backend ++ ") does not support the command:"+                                                                             , "***"+                                                                             , "***     (set-option :print-success true)"+                                                                             , "***"+                                                                             , "*** SBV relies on this feature to coordinate communication!"+                                                                             , "*** Please request this as a feature!"+                                                                             ]+                                          _               -> error $ unlines [ ""+                                                                             , "*** Data.SBV: Failed to initiate contact with the solver!"+                                                                             , "***"+                                                                             , "***   Sent    : " ++ heartbeat+                                                                             , "***   Expected: success"+                                                                             , "***   Received: " ++ r+                                                                             , "***"+                                                                             , "*** Try running in debug mode for further information."+                                                                             ]++                             -- For push/pop support, we require :global-declarations to be true. But not all solvers+                             -- support this. Issue it if supported. (If not, we'll reject pop calls.)+                             if not (supportsGlobalDecls (capabilities (solver cfg)))+                                then debug cfg [ "** Backend solver " ++ show backend ++ " does not support global decls."+                                               , "** Some incremental calls, such as pop, will be limited."+                                               ]+                                else sendAndGetSuccess Nothing "(set-option :global-declarations true)"++                             -- Now dump the program!+                             mapM_ (sendAndGetSuccess Nothing) (mergeSExpr (lines pgm))++                             -- Prepare the query context and ship it off+                             let qs = QueryState { queryAsk                 = ask+                                                 , querySend                = send+                                                 , queryRetrieveResponse    = getResponseFromSolver Nothing+                                                 , queryConfig              = cfg+                                                 , queryTerminate           = cleanUp+                                                 , queryTimeOutValue        = Nothing+                                                 , queryAssertionStackDepth = 0+                                                 }+                                 qsp = queryState ctx++                             mbQS <- readIORef qsp++                             case mbQS of+                               Nothing -> writeIORef qsp (Just qs)+                               Just _  -> error $ unlines [ ""+                                                          , "Data.SBV: Impossible happened, query-state was already set."+                                                          , "Please report this as a bug!"+                                                          ]++                             -- off we go!+                             continuation ctx++      -- NB. Don't use 'bracket' here, as it wouldn't have access to the exception.+      let launchSolver = do startTranscript    (transcript cfg) cfg+                            r <- executeSolver+                            finalizeTranscript (transcript cfg) Nothing+                            recordEndTime      cfg ctx+                            return r++      launchSolver `C.catch` (\(e :: C.SomeException) -> do terminateProcess pid+                                                            ec <- waitForProcess pid+                                                            recordException    (transcript cfg) (show e)+                                                            finalizeTranscript (transcript cfg) (Just ec)+                                                            recordEndTime      cfg ctx+                                                            C.throwIO e)++-- | Compute and report the end time+recordEndTime :: SMTConfig -> State -> IO ()+recordEndTime SMTConfig{timing} state = case timing of+                                           NoTiming        -> return ()+                                           PrintTiming     -> do e <- elapsed+                                                                 putStrLn $ "*** SBV: Elapsed time: " ++ showTDiff e+                                           SaveTiming here -> writeIORef here =<< elapsed+  where elapsed = getCurrentTime >>= \end -> return $ diffUTCTime end (startTime state)++-- | Start a transcript file, if requested.+startTranscript :: Maybe FilePath -> SMTConfig -> IO ()+startTranscript Nothing  _   = return ()+startTranscript (Just f) cfg = do ts <- show <$> getZonedTime+                                  mbExecPath <- findExecutable (executable (solver cfg))+                                  writeFile f $ start ts mbExecPath+  where SMTSolver{name, options} = solver cfg+        start ts mbPath = unlines [ ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"+                                  , ";;; SBV: Starting at " ++ ts+                                  , ";;;"+                                  , ";;;           Solver    : " ++ show name+                                  , ";;;           Executable: " ++ fromMaybe "Unable to locate the executable" mbPath+                                  , ";;;           Options   : " ++ unwords (options cfg)+                                  , ";;;"+                                  , ";;; This file is an auto-generated loadable SMT-Lib file."+                                  , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"+                                  , ""+                                  ]++-- | Finish up the transcript file.+finalizeTranscript :: Maybe FilePath -> Maybe ExitCode -> IO ()+finalizeTranscript Nothing  _    = return ()+finalizeTranscript (Just f) mbEC = do ts <- show <$> getZonedTime+                                      appendFile f $ end ts+  where end ts = unlines $ [ ""+                           , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"+                           , ";;;"+                           , ";;; SBV: Finished at " ++ ts+                           ]+                       ++  [ ";;;\n;;; Exit code: " ++ show ec | Just ec <- [mbEC] ]+                       ++  [ ";;;"+                           , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"+                           ]++-- If requested, record in the transcript file+recordTranscript :: Maybe FilePath -> Either (String, Maybe Int) String -> IO ()+recordTranscript Nothing  _ = return ()+recordTranscript (Just f) m = do tsPre <- formatTime defaultTimeLocale "; [%T%Q" <$> getZonedTime+                                 let ts = take 15 $ tsPre ++ repeat '0'+                                 case m of+                                   Left  (sent, mbTimeOut) -> appendFile f $ unlines $ (ts ++ "] " ++ to mbTimeOut ++ "Sending:") : lines sent+                                   Right recv              -> appendFile f $ unlines $ case lines (dropWhile isSpace recv) of+                                                                                        []  -> [ts ++ "] Received: <NO RESPONSE>"]  -- can't really happen.+                                                                                        [x] -> [ts ++ "] Received: " ++ x]+                                                                                        xs  -> (ts ++ "] Received: ") : map (";   " ++) xs+        where to Nothing  = ""+              to (Just i) = "[Timeout: " ++ showTimeoutValue i ++ "] "+{-# INLINE recordTranscript #-}++-- Record the exception+recordException :: Maybe FilePath -> String -> IO ()+recordException Nothing  _ = return ()+recordException (Just f) m = do ts <- show <$> getZonedTime+                                appendFile f $ exc ts+  where exc ts = unlines $ [ ""+                           , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"+                           , ";;;"+                           , ";;; SBV: Caught an exception at " ++ ts+                           , ";;;"+                           ]+                        ++ [ ";;;   " ++ l | l <- dropWhile null (lines m) ]+                        ++ [ ";;;"+                           , ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"+                           ]
Data/SBV/SMT/SMTLib.hs view
@@ -9,316 +9,64 @@ -- Conversion of symbolic programs to SMTLib format ----------------------------------------------------------------------------- -module Data.SBV.SMT.SMTLib(+{-# LANGUAGE NamedFieldPuns #-}++module Data.SBV.SMT.SMTLib (           SMTLibPgm-        , SMTLibConverter-        , toSMTLib2-        , addNonEqConstraints-        , interpretSolverOutput-        , interpretSolverOutputMulti-        , interpretSolverParetoOutput-        , interpretSolverModelLine-        , interpretSolverObjectiveLine+        , toSMTLib+        , toIncSMTLib         ) where -import Data.Char  (isDigit, isSpace)-import Data.List  (isPrefixOf)-import Data.Maybe (isJust, fromJust)+import qualified Data.Set as Set (member, toList)  import Data.SBV.Core.Data-import Data.SBV.Provers.SExpr++import Data.SBV.SMT.Utils import qualified Data.SBV.SMT.SMTLib2 as SMT2-import qualified Data.Set as Set (Set, member, toList) --- | An instance of SMT-Lib converter; instantiated for SMT-Lib v1 and v2. (And potentially for newer versions in the future.)-type SMTLibConverter =  Set.Set Kind                 -- ^ Kinds used in the problem-                     -> Bool                         -- ^ is this a sat problem?-                     -> [String]                     -- ^ extra comments to place on top-                     -> [(Quantifier, NamedSymVar)]  -- ^ inputs and aliasing names-                     -> [Either SW (SW, [SW])]       -- ^ skolemized inputs-                     -> [(SW, CW)]                   -- ^ constants-                     -> [((Int, Kind, Kind), [SW])]  -- ^ auto-generated tables-                     -> [(Int, ArrayInfo)]           -- ^ user specified arrays-                     -> [(String, SBVType)]          -- ^ uninterpreted functions/constants-                     -> [(String, [String])]         -- ^ user given axioms-                     -> SBVPgm                       -- ^ assignments-                     -> [(Maybe String, SW)]         -- ^ extra constraints-                     -> SW                           -- ^ output variable-                     -> SMTConfig                    -- ^ configuration-                     -> CaseCond                     -- ^ case analysis-                     -> SMTLibPgm+-- | Convert to SMT-Lib, in a full program context.+toSMTLib :: SMTConfig -> SMTLibConverter SMTLibPgm+toSMTLib SMTConfig{smtLibVersion} = case smtLibVersion of+                                      SMTLib2 -> toSMTLib2 +-- | Convert to SMT-Lib, in an incremental query context.+toIncSMTLib :: SMTConfig -> SMTLibIncConverter [String]+toIncSMTLib SMTConfig{smtLibVersion} = case smtLibVersion of+                                         SMTLib2 -> toIncSMTLib2+ -- | Convert to SMTLib-2 format-toSMTLib2 :: SMTLibConverter+toSMTLib2 :: SMTLibConverter SMTLibPgm toSMTLib2 = cvt SMTLib2-  where cvt v kindInfo isSat comments qinps skolemMap consts tbls arrs uis axs asgnsSeq cstrs out config caseSelectors+  where cvt v kindInfo isSat comments qinps skolemMap consts tbls arrs uis axs asgnsSeq cstrs out config          | KUnbounded `Set.member` kindInfo && not (supportsUnboundedInts solverCaps)          = unsupported "unbounded integers"          | KReal `Set.member` kindInfo  && not (supportsReals solverCaps)          = unsupported "algebraic reals"-         | needsFloats && not (supportsFloats solverCaps)-         = unsupported "single-precision floating-point numbers"-         | needsDoubles && not (supportsDoubles solverCaps)-         = unsupported "double-precision floating-point numbers"+         | (needsFloats || needsDoubles) && not (supportsIEEE754 solverCaps)+         = unsupported "floating-point numbers"          | needsQuantifiers && not (supportsQuantifiers solverCaps)          = unsupported "quantifiers"          | not (null sorts) && not (supportsUninterpretedSorts solverCaps)          = unsupported "uninterpreted sorts"-         | needsOptimization && not (supportsOptimization solverCaps)-         = unsupported "optimization routines"-         | not $ null needsUniversalOpt-         = unsupportedAll $ "optimization of universally quantified metric(s): " ++ unwords needsUniversalOpt          | True          = SMTLibPgm v pgm          where sorts = [s | KUserSort s _ <- Set.toList kindInfo]                solverCaps = capabilities (solver config)                unsupported w = error $ unlines [ "SBV: Given problem needs " ++ w-                                               , "*** Which is not supported by SBV for the chosen solver: " ++ capSolverName solverCaps+                                               , "*** Which is not supported by SBV for the chosen solver: " ++ show (name (solver config))                                                ]-               unsupportedAll w = error $ unlines [ "SBV: Given problem needs " ++ w-                                                  , "*** Which is not supported by SBV."-                                                  ]-               converter    = case v of-                                SMTLib2 -> SMT2.cvt-               pgm = converter kindInfo isSat comments qinps skolemMap consts tbls arrs uis axs asgnsSeq cstrs out config caseSelectors+               converter = case v of+                             SMTLib2 -> SMT2.cvt+               pgm = converter kindInfo isSat comments qinps skolemMap consts tbls arrs uis axs asgnsSeq cstrs out config                 needsFloats  = KFloat  `Set.member` kindInfo                needsDoubles = KDouble `Set.member` kindInfo-               (needsOptimization, needsUniversalOpt) = case caseSelectors of-                                                          Opt ss -> let universals   = [s | (ALL, (s, _)) <- qinps]-                                                                        check (x, y) = any (`elem` universals) [x, y]-                                                                        isUniversal (Maximize nm xy) | check xy = [nm]-                                                                        isUniversal (Minimize nm xy) | check xy = [nm]-                                                                        isUniversal _                           = []-                                                                    in  (True,  concatMap isUniversal ss)-                                                          _      -> (False, [])                needsQuantifiers                  | isSat = ALL `elem` quantifiers                  | True  = EX  `elem` quantifiers                  where quantifiers = map fst qinps --- | Add constraints generated from older models, used for querying new models-addNonEqConstraints :: SMTLibVersion -> RoundingMode -> [(Quantifier, NamedSymVar)] -> [[(String, CW)]] -> Maybe [String]-addNonEqConstraints SMTLib2 = SMT2.addNonEqConstraints---- | Interpret solver output based on SMT-Lib standard output responses-interpretSolverOutput :: SMTConfig -> ([String] -> SMTModel) -> [String] -> SMTResult-interpretSolverOutput cfg _          ("unsat":ucCore) = Unsatisfiable cfg $ parseUnsatCore (getUnsatCore cfg) ucCore-interpretSolverOutput cfg extractMap ("unknown":rest) = Unknown       cfg $ extractMap rest-interpretSolverOutput cfg extractMap ("sat":rest)     = classifyModel cfg $ extractMap rest-interpretSolverOutput cfg _          ("timeout":_)    = TimeOut       cfg-interpretSolverOutput cfg _          ls               = ProofError    cfg ls---- | Parse unsat-core if requested-parseUnsatCore :: Bool -> [String] -> Maybe [String]-parseUnsatCore False _  = Nothing-parseUnsatCore True  ls = Just $ concatMap getLabels ls-   where getLabels s = case parseSExpr s of-                         Left  e         -> bad e-                         Right (EApp xs) -> let result = map grab xs-                                            in if all isJust result-                                               then map fromJust result-                                               else bad "Unexpected non-label construct"-                         Right _         -> bad "Unexpected response from the solver"--          where grab (ECon l) = Just $ noBar l-                grab _        = Nothing--                noBar = reverse . dropWhile bar . reverse . dropWhile bar-                bar   = (== '|')--                bad e = error $ unlines [ "SBV: Cannot extract an unsat core:"-                                        , "  Received:  " ++ show s-                                        , "  Reason  : " ++ e-                                        ]---- | Do we have a regular sat-model, or something in the extension field?-classifyModel :: SMTConfig -> SMTModel -> SMTResult-classifyModel cfg m = case filter (not . isRegularCW . snd) (modelObjectives m) of-                        [] -> Satisfiable cfg m-                        _  -> SatExtField cfg m---- | Interpret solver output based on SMT-Lib standard output responses, in the case we're expecting multiple objective model values-interpretSolverOutputMulti :: Int -> SMTConfig -> ([String] -> SMTModel) -> [String] -> [SMTResult]-interpretSolverOutputMulti n cfg extractMap outLines-   | degenerate-   = replicate n $ interpretSolverOutput cfg extractMap preModels-   | n /= lms-   = error $ "SBV: Expected " ++ show n ++ " models, received: " ++ show lms ++ ":\n" ++ unlines outLines-   | True-   = map (interpretSolverOutput cfg extractMap) multiModels-  where degenerate = case outLines of-                      ("sat"    :_) -> False-                      ("unknown":_) -> False-                      _             -> True--        (preModels, postModels) = case break (== "(sbv_objective_model_marker)") outLines of-                                    (pre, _:post) -> (pre, post)-                                    r             -> r--        walk [] sofar = reverse sofar-        walk xs sofar = case break (== "(sbv_objective_model_marker)") xs of-                          (g, [])     -> walk []   (g:sofar)-                          (g, _:rest) -> walk rest (g:sofar)--        multiModels = map (preModels ++) (walk postModels [])-        lms         = length multiModels---- | Interpret solver output based on SMT-Lib pareto-output mode. Unfortunately this is likely to be very Z3 specific, and quite dissimilar--- to other modes. (A "request" has been filed so we don't have to do this: <https://github.com/Z3Prover/z3/issues/1008>.) In the mean--- time we try to interpret the Z3 output as well as we can.-interpretSolverParetoOutput :: SMTConfig -> ([String] -> SMTModel) -> [String] -> [SMTResult]-interpretSolverParetoOutput cfg extractMap outLines-  | null outLines-  = cont []-  | not isSAT-  = cont [finalLine : initLines]-  | True-  = groupModels-  where finalLine = last outLines-        initLines = init outLines-        isSAT     = case words finalLine of-                      "sat":_ -> True-                      _       -> False--        cont = map (interpretSolverOutput cfg extractMap)--        -- convert what z3 prints as Pareto output to what we can parse-        -- this is necessarily flaky, but hopefully good enough!-        -- The output is expected to be alternating lines of objectives and models-        groupModels = map grok $ cluster $ filter (not . irrelevant) initLines-        irrelevant  = null . dropWhile isSpace-        cluster (x:y:rest) = (x, y) : cluster rest-        cluster []         = []-        cluster _          = error $ "SBV.pareto: Unable to parse pareto fronts from solver output. Uneven length:\n"-                                   ++ unlines outLines--        grok :: (String, String) -> SMTResult-        grok (obj, ms)-          | "(objectives" `isPrefixOf` dropWhile isSpace obj-          , "(model"      `isPrefixOf` dropWhile isSpace ms-          = classifyModel cfg $ extractMap [obj, ms]-          | True-          = error $  "SBV.pareto: Unable to parse pareto front from solver output:\n"-                  ++ unlines [obj, ms]-                  ++ "SBV.pareto: The bigger context is:"-                  ++ unlines outLines---- | Get a counter-example from an SMT-Lib2 like model output line--- This routing is necessarily fragile as SMT solvers tend to print output--- in whatever form they deem convenient for them.. Currently, it's tuned to--- work with Z3 and CVC4; if new solvers are added, we might need to rework--- the logic here.-interpretSolverModelLine :: [NamedSymVar] -> String -> [(Int, (String, CW))]-interpretSolverModelLine inps line = either err (modelValues True inps line) (parseSExpr line)-  where err r =  error $  "*** Failed to parse SMT-Lib2 model output from: "-                       ++ "*** " ++ show line ++ "\n"-                       ++ "*** Reason: " ++ r ++ "\n"--identifyInput :: [NamedSymVar] -> SExpr -> Maybe (Int, SW, String)-identifyInput inps = classify-  where classify (ECon v)            = isInput v-        classify (EApp (ECon v : _)) = isInput v-        classify _                   = Nothing--        isInput ('s':v)-          | all isDigit v = let inpId :: Int-                                inpId = read v-                            in case [(s, nm) | (s@(SW _ (NodeId n)), nm) <-  inps, n == inpId] of-                                 []        -> Nothing-                                 [(s, nm)] -> Just (inpId, s, nm)-                                 matches -> error $  "SBV.SMTLib: Cannot uniquely identify value for "-                                                  ++ 's':v ++ " in "  ++ show matches-        isInput _       = Nothing---- | Turn an sexpr to a binding in our model-modelValues :: Bool -> [NamedSymVar] -> String -> SExpr -> [(Int, (String, CW))]-modelValues errOnUnrecognized inps line = extractModel-  where getInput = identifyInput inps--        getUIIndex (KUserSort  _ (Right xs)) i = i `lookup` zip xs [0..]-        getUIIndex _                         _ = Nothing--        -- Lines of the form (model (define-fun s0 () Int 0) ...)-        extractModel (EApp (ECon "model" : rest)) = concatMap extractDefine rest-        extractModel e                            = extract e--        -- Lines of the form (define-fun s0 () Int 0)-        extractDefine (EApp (ECon "define-fun" : nm : EApp [] : ECon _ : rest)) = extract $ EApp [EApp (nm : rest)]-        extractDefine r = error $   "SBV.SMTLib: Cannot extract value from model level define-fun:"-                                ++ "\n\tInput: " ++ show line-                                ++ "\n\tParse: " ++ show r--        -- Lines of the form ((s0 0))-        extract (EApp [EApp [v, ENum    i]]) | Just (n, s, nm) <- getInput v                    = [(n, (nm, mkConstCW (kindOf s) (fst i)))]-        extract (EApp [EApp [v, EReal   i]]) | Just (n, s, nm) <- getInput v, isReal s          = [(n, (nm, CW KReal (CWAlgReal i)))]--        -- the following is when z3 returns a cast to an int. Inherently dangerous! (but useful)-        extract (EApp [EApp [v, EReal   i]]) | Just (n, _, nm) <- getInput v                    = [(n, (nm, CW KReal (CWAlgReal i)))]--        extract (EApp [EApp [v, ECon    i]]) | Just (n, s, nm) <- getInput v, isUninterpreted s = let k = kindOf s in [(n, (nm, CW k (CWUserSort (getUIIndex k i, i))))]-        extract (EApp [EApp [v, EDouble i]]) | Just (n, s, nm) <- getInput v, isDouble s        = [(n, (nm, CW KDouble (CWDouble i)))]-        extract (EApp [EApp [v, EFloat  i]]) | Just (n, s, nm) <- getInput v, isFloat s         = [(n, (nm, CW KFloat (CWFloat i)))]--        -- weird lambda app that CVC4 seems to throw out.. logic below derived from what I saw CVC4 print, hopefully sufficient-        extract (EApp (EApp (v : EApp (ECon "LAMBDA" : xs) : _) : _)) | Just{} <- getInput v, not (null xs) = extract (EApp [EApp [v, last xs]])--        extract (EApp [EApp (v : r)])-          | Just (_, _, nm) <- getInput v-          , errOnUnrecognized-          = error $   "SBV.SMTLib: Cannot extract value for " ++ show nm-                   ++ "\n\tInput: " ++ show line-                   ++ "\n\tParse: " ++ show r--        extract _ = []---- | Similar to reading model-lines but designed for reading objectives.-interpretSolverObjectiveLine :: [NamedSymVar] -> String -> [(Int, (String, GeneralizedCW))]-interpretSolverObjectiveLine inps line = either err extract (parseSExpr line)-  where err r =  error $  "*** Failed to parse SMT-Lib2 model output from: "-                       ++ "*** " ++ show line ++ "\n"-                       ++ "*** Reason: " ++ r ++ "\n"--        getInput = identifyInput inps--        extract :: SExpr -> [(Int, (String, GeneralizedCW))]-        extract (EApp (ECon "objectives" : es)) = concatMap getObjValue es-        extract _                               = []--        getObjValue :: SExpr -> [(Int, (String, GeneralizedCW))]-        getObjValue e = case modelValues False inps line (EApp [e]) of-                          [] -> getUnboundedValues e-                          xs -> [(i, (s, RegularCW v)) | (i, (s, v)) <- xs]--        getUnboundedValues :: SExpr -> [(Int, (String, GeneralizedCW))]-        getUnboundedValues item = go item-          where go (EApp [v, rest]) | Just (n, s, nm) <- getInput v = [(n, (nm, ExtendedCW (toGenCW (kindOf s) (simplify rest))))]-                go _                                                = []--                die r = error $   "SBV.SMTLib: Cannot convert objective value from solver output!"-                             ++ "\n\tInput     : " ++ show line-                             ++ "\n\tParse     : " ++ show r-                             ++ "\n\tItem Parse: " ++ show item--                -- Convert to an extended expression. Hopefully complete!-                toGenCW :: Kind -> SExpr -> ExtCW-                toGenCW k = cvt-                   where cvt (ECon "oo")                    = Infinite  k-                         cvt (ECon "epsilon")               = Epsilon   k-                         cvt (EApp [ECon "interval", x, y]) = Interval  (cvt x) (cvt y)-                         cvt (ENum    (i, _))               = BoundedCW $ mkConstCW k i-                         cvt (EReal   r)                    = BoundedCW $ CW k $ CWAlgReal r-                         cvt (EFloat  f)                    = BoundedCW $ CW k $ CWFloat   f-                         cvt (EDouble d)                    = BoundedCW $ CW k $ CWDouble  d-                         cvt (EApp [ECon "+", x, y])        = AddExtCW (cvt x) (cvt y)-                         cvt (EApp [ECon "*", x, y])        = MulExtCW (cvt x) (cvt y)-                         -- Nothing else should show up, hopefully!-                         cvt e = die e--                -- drop the pesky to_real's that Z3 produces.. Cool but useless.-                simplify :: SExpr -> SExpr-                simplify (EApp [ECon "to_real", n]) = n-                simplify (EApp xs)                  = EApp (map simplify xs)-                simplify e                          = e--{-# ANN modelValues  ("HLint: ignore Use elemIndex" :: String) #-}+-- | Convert to SMTLib-2 format+toIncSMTLib2 :: SMTLibIncConverter [String]+toIncSMTLib2 = cvt SMTLib2+  where cvt SMTLib2 = SMT2.cvtInc
Data/SBV/SMT/SMTLib2.hs view
@@ -1,4 +1,4 @@-----------------------------------------------------------------------------+----------------------------------------------------------------------------- -- | -- Module      :  Data.SBV.SMT.SMTLib2 -- Copyright   :  (c) Levent Erkok@@ -9,15 +9,11 @@ -- Conversion of symbolic programs to SMTLib format, Using v2 of the standard ----------------------------------------------------------------------------- {-# LANGUAGE PatternGuards #-}-{-# LANGUAGE TupleSections #-} -module Data.SBV.SMT.SMTLib2(cvt, addNonEqConstraints) where+module Data.SBV.SMT.SMTLib2(cvt, cvtInc) where -import Data.Bits     (bit)-import Data.Function (on)-import Data.Ord      (comparing)-import Data.List     (intercalate, partition, groupBy, sortBy)-import Data.Maybe    (mapMaybe)+import Data.Bits  (bit)+import Data.List  (intercalate, partition)  import qualified Data.Foldable as F (toList) import qualified Data.Map      as M@@ -25,77 +21,17 @@ import qualified Data.Set      as Set  import Data.SBV.Core.Data+import Data.SBV.SMT.Utils+import Data.SBV.Control.Types  import Data.SBV.Utils.PrettyNum (smtRoundingMode, cwToSMTLib) --- | Add constraints to generate /new/ models. This function is used to query the SMT-solver, while--- disallowing a previous model.-addNonEqConstraints :: RoundingMode -> [(Quantifier, NamedSymVar)] -> [[(String, CW)]] -> Maybe [String]-addNonEqConstraints rm qinps allNonEqConstraints-  | null allNonEqConstraints-  = Just []-  | null refutedModel-  = Nothing-  | True-  = Just $ "; --- refuted-models ---" : refutedModel- where refutedModel = concatMap (nonEqs rm . map intName) nonEqConstraints-       aliasTable   = map (\(_, (x, y)) -> (y, x)) qinps-       intName (s, c)-          | Just sw <- s `lookup` aliasTable = (show sw, c)-          | True                             = (s, c)-       -- with existentials, we only add top-level existentials to the refuted-models list-       nonEqConstraints = filter (not . null) $ map (filter (\(s, _) -> s `elem` topUnivs)) allNonEqConstraints-       topUnivs = [s | (_, (_, s)) <- takeWhile (\p -> fst p == EX) qinps]--nonEqs :: RoundingMode -> [(String, CW)] -> [String]-nonEqs rm scs = format $ interp ps ++ disallow (map eqClass uninterpClasses)-  where isFree (KUserSort _ (Left _)) = True-        isFree _                      = False-        (ups, ps) = partition (isFree . kindOf . snd) scs-        format []     =  []-        format [m]    =  ["(assert " ++ m ++ ")"]-        format (m:ms) =  ["(assert (or " ++ m]-                      ++ map ("            " ++) ms-                      ++ ["        ))"]-        -- Regular (or interpreted) sorts simply get a constraint that we disallow the current assignment-        interp = map $ nonEq rm-        -- Determine the equivalence classes of uninterpreted sorts:-        uninterpClasses = filter (\l -> length l > 1) -- Only need this class if it has at least two members-                        . map (map fst)               -- throw away sorts, we only need the names-                        . groupBy ((==) `on` snd)     -- make sure they belong to the same sort and have the same value-                        . sortBy (comparing snd)      -- sort them according to their sorts first-                        $ ups                         -- take the uninterpreted sorts-        -- Uninterpreted sorts get a constraint that says the equivalence classes as determined by the solver are disallowed:-        eqClass :: [String] -> String-        eqClass [] = error "SBV.allSat.nonEqs: Impossible happened, disallow received an empty list"-        eqClass cs = "(= " ++ unwords cs ++ ")"-        -- Now, take the conjunction of equivalence classes and assert it's negation:-        disallow = map $ \ec -> "(not " ++ ec ++ ")"--nonEq :: RoundingMode -> (String, CW) -> String-nonEq rm (s, c) = "(not (= " ++ s ++ " " ++ cvtCW rm c ++ "))"- tbd :: String -> a tbd e = error $ "SBV.SMTLib2: Not-yet-supported: " ++ e  -- | Translate a problem into an SMTLib2 script-cvt :: Set.Set Kind                 -- ^ kinds used-    -> Bool                         -- ^ is this a sat problem?-    -> [String]                     -- ^ extra comments to place on top-    -> [(Quantifier, NamedSymVar)]  -- ^ inputs-    -> [Either SW (SW, [SW])]       -- ^ skolemized version inputs-    -> [(SW, CW)]                   -- ^ constants-    -> [((Int, Kind, Kind), [SW])]  -- ^ auto-generated tables-    -> [(Int, ArrayInfo)]           -- ^ user specified arrays-    -> [(String, SBVType)]          -- ^ uninterpreted functions/constants-    -> [(String, [String])]         -- ^ user given axioms-    -> SBVPgm                       -- ^ assignments-    -> [(Maybe String, SW)]         -- ^ extra constraints-    -> SW                           -- ^ output variable-    -> SMTConfig                    -- ^ configuration-    -> CaseCond                     -- ^ case analysis data-    -> [String]-cvt kindInfo isSat comments inputs skolemInps consts tbls arrs uis axs (SBVPgm asgnsSeq) cstrs out config caseCond = pgm+cvt :: SMTLibConverter [String]+cvt kindInfo isSat comments inputs skolemInps consts tbls arrs uis axs (SBVPgm asgnsSeq) cstrs out cfg = pgm   where hasInteger     = KUnbounded `Set.member` kindInfo         hasReal        = KReal      `Set.member` kindInfo         hasFloat       = KFloat     `Set.member` kindInfo@@ -103,26 +39,36 @@         hasBVs         = not $ null [() | KBounded{} <- Set.toList kindInfo]         usorts         = [(s, dt) | KUserSort s dt <- Set.toList kindInfo]         hasNonBVArrays = (not . null) [() | (_, (_, (k1, k2), _)) <- arrs, not (isBounded k1 && isBounded k2)]-        rm             = roundingMode config-        solverCaps     = capabilities (solver config)+        rm             = roundingMode cfg+        solverCaps     = capabilities (solver cfg)          -- Determining the logic is surprisingly tricky!         logic-           | Just l <- useLogic config+           -- user told us what to do: so just take it:+           | Just l <- case [l | SetLogic l <- solverSetOptions cfg] of+                         []  -> Nothing+                         [l] -> Just l+                         ls  -> error $ unlines [ ""+                                                , "*** Only one setOption call to 'SetLogic' is allowed, found: " ++ show (length ls)+                                                , "***  " ++ unwords (map show ls)+                                                ]            = ["(set-logic " ++ show l ++ ") ; NB. User specified."]-           | hasDouble || hasFloat    -- NB. We don't check for quantifiers here, we probably should..-           = if hasBVs-             then ["(set-logic QF_FPBV)"]-             else ["(set-logic QF_FP)"]++           -- Otherwise, we try to determine the most suitable logic.+           -- NB. This isn't really fool proof!+           | hasDouble || hasFloat+           = if hasInteger || not (null foralls)+             then ["(set-logic ALL)"]+             else if hasBVs+                  then ["(set-logic QF_FPBV)"]+                  else ["(set-logic QF_FP)"]            | hasInteger || hasReal || not (null usorts) || hasNonBVArrays            = let why | hasInteger        = "has unbounded values"                      | hasReal           = "has algebraic reals"                      | not (null usorts) = "has user-defined sorts"                      | hasNonBVArrays    = "has non-bitvector arrays"                      | True              = "cannot determine the SMTLib-logic to use"-             in case mbDefaultLogic solverCaps hasReal of-                  Nothing -> ["; " ++ why ++ ", no logic specified."]-                  Just l  -> ["(set-logic " ++ l ++ "); " ++ why ++ ", using solver-default logic."]+             in ["(set-logic ALL) ; "  ++ why ++ ", using catch-all."]            | True            = ["(set-logic " ++ qs ++ as ++ ufs ++ "BV)"]           where qs  | null foralls && null axs = "QF_"  -- axioms are likely to contain quantifiers@@ -132,24 +78,24 @@                 ufs | null uis && null tbls    = ""     -- we represent tables as UFs                     | True                     = "UF" -        getModels-          | supportsProduceModels solverCaps = ["(set-option :produce-models true)"]-          | True                             = []+        -- SBV always requires the production of models!+        getModels   = ["(set-option :produce-models true)"] -        unsatCore-          | not (getUnsatCore config)     = []-          | supportsUnsatCores solverCaps = ["(set-option :produce-unsat-cores true)"]-          | True                          = error $ "SBV: unsat cores are requested, but the backend solver " ++ show (solver config) ++ " doesn't support them!"+        -- process all other settings we're given+        userSettings = concatMap opts $ solverSetOptions cfg+           where opts SetLogic{} = []     -- processed already+                 opts o          = [setSMTOption o] -        pgm  =  ["; Automatically generated by SBV. Do not edit."]-             ++ map ("; " ++) comments-             ++ getModels-             ++ unsatCore-             ++ logic+        settings =  userSettings        -- NB. Make sure this comes first!+                 ++ getModels+                 ++ logic++        pgm  =  map ("; " ++) comments+             ++ settings              ++ [ "; --- uninterpreted sorts ---" ]              ++ concatMap declSort usorts              ++ [ "; --- literal constants ---" ]-             ++ concatMap declConst consts+             ++ map (declConst cfg) consts              ++ [ "; --- skolem constants ---" ]              ++ [ "(declare-fun " ++ show s ++ " " ++ swFunType ss s ++ ")" ++ userName s | Right (s, ss) <- skolemInps]              ++ [ "; --- constant tables ---" ]@@ -169,7 +115,7 @@                 | not (null foralls)                 ] -             ++ concatMap mkAssign asgns+             ++ map mkAssign asgns               ++ delayedAsserts delayedEqualities @@ -236,20 +182,9 @@            where finals  = cstrs' ++ maybe [] (\r -> [(Nothing, r)]) mbO                   cstrs' =  [(mbNm, c') | (mbNm, c) <- cstrs, Just c' <- [pos c]]-                        ++ condAsserts -                 condAsserts = map (Nothing,) $ case caseCond of-                                                    NoCase         -> []-                                                    CasePath ss    -> mapMaybe pos ss-                                                    CaseVac  ss _  -> mapMaybe pos ss-                                                    CaseCov  ss qq -> mapMaybe pos ss ++ mapMaybe neg qq-                                                    CstrVac        -> []-                                                    Opt gs         -> map mkGoal gs--                 mbO | CstrVac     <- caseCond = pos trueSW -- always a SAT call!-                     | CaseVac _ s <- caseCond = pos s      -- always a SAT call!-                     | isSat                   = pos out-                     | True                    = neg out+                 mbO | isSat = pos out+                     | True  = neg out                   neg s                   | s == trueSW  = Just $ cvtSW skolemMap falseSW@@ -261,11 +196,6 @@                   | s == falseSW = Just $ cvtSW skolemMap falseSW                   | True         = Just $ cvtSW skolemMap s -                 eq (orig, track) = "(= " ++ cvtSW skolemMap track ++ " " ++ cvtSW skolemMap orig ++ ")"-                 mkGoal (Minimize   _ ab)   = eq ab-                 mkGoal (Maximize   _ ab)   = eq ab-                 mkGoal (AssertSoft _ ab _) = eq ab-         skolemMap = M.fromList [(s, ss) | Right (s, ss) <- skolemInps, not (null ss)]         tableMap  = IM.fromList $ map mkConstTable constTables ++ map mkSkTable skolemTables           where mkConstTable (((t, _, _), _), _) = (t, "table" ++ show t)@@ -273,43 +203,65 @@         asgns = F.toList asgnsSeq          mkAssign a-          | null foralls = mkDef a-          | True         = [letShift (mkLet a)]--        mkDef (s, SBVApp (Label m) [e]) = emit (s, cvtSW                skolemMap          e) (Just m)-        mkDef (s, e)                    = emit (s, cvtExp solverCaps rm skolemMap tableMap e) Nothing+          | null foralls = declDef cfg skolemMap tableMap a+          | True         = letShift (mkLet a)          mkLet (s, SBVApp (Label m) [e]) = "(let ((" ++ show s ++ " " ++ cvtSW                skolemMap          e ++ ")) ; " ++ m         mkLet (s, e)                    = "(let ((" ++ show s ++ " " ++ cvtExp solverCaps rm skolemMap tableMap e ++ "))" -        -- does the solver allow define-fun; or do we need declare-fun/assert combo?-        useDefFun = supportsDefineFun solverCaps--        declConst (s, c) = emit (s, cvtCW rm c) Nothing--        emit (s, def) mbComment-          | useDefFun = ["(define-fun "   ++ varT ++ " " ++ def ++ ")" ++ cmnt]-          | True      = [ "(declare-fun " ++ varT ++ ")" ++ cmnt-                        , "(assert (= "   ++ show s ++ " " ++ def ++ "))"-                        ]-          where varT = show s ++ " " ++ swFunType [] s-                cmnt = maybe "" (" ; " ++) mbComment-         userName s = case s `lookup` map snd inputs of                         Just u  | show s /= u -> " ; tracks user variable " ++ show u                         _ -> ""-        -- following sorts are built-in; do not translate them:-        builtInSort = (`elem` ["RoundingMode"])-        declSort (s, _)-          | builtInSort s           = []-        declSort (s, Left  r ) = ["(declare-sort " ++ s ++ " 0)  ; N.B. Uninterpreted: " ++ r]-        declSort (s, Right fs) = [ "(declare-datatypes () ((" ++ s ++ " " ++ unwords (map (\c -> "(" ++ c ++ ")") fs) ++ ")))"-                                 , "(define-fun " ++ s ++ "_constrIndex ((x " ++ s ++ ")) Int"-                                 ] ++ ["   " ++ body fs (0::Int)] ++ [")"]-                where body []     _ = ""-                      body [_]    i = show i-                      body (c:cs) i = "(ite (= x " ++ c ++ ") " ++ show i ++ " " ++ body cs (i+1) ++ ")" +-- | Declare new sorts+declSort :: (String, Either String [String]) -> [String]+declSort (s, _)+  | s == "RoundingMode" -- built-in-sort; so don't declare.+  = []+declSort (s, Left  r ) = ["(declare-sort " ++ s ++ " 0)  ; N.B. Uninterpreted: " ++ r]+declSort (s, Right fs) = [ "(declare-datatypes () ((" ++ s ++ " " ++ unwords (map (\c -> "(" ++ c ++ ")") fs) ++ ")))"+                         , "(define-fun " ++ s ++ "_constrIndex ((x " ++ s ++ ")) Int"+                         ] ++ ["   " ++ body fs (0::Int)] ++ [")"]+        where body []     _ = ""+              body [_]    i = show i+              body (c:cs) i = "(ite (= x " ++ c ++ ") " ++ show i ++ " " ++ body cs (i+1) ++ ")"++-- | Things we do not support in interactive mode, at least for now!+noInteractive :: [String] -> a+noInteractive ss = error $ unlines $  ""+                                   :  "*** Data.SBV: Unsupported interactive/query mode feature."+                                   :  map ("***  " ++) ss+                                   ++ ["*** Data.SBV: Please report this as a feature request!"]++-- | Convert in a query context+cvtInc :: SMTLibIncConverter [String]+cvtInc inps ks consts (SBVPgm asgnsSeq) cfg =  concatMap declSort                           [(s, dt) | KUserSort s dt <- Set.toList ks]+                                            ++ map       (declConst cfg)                    consts+                                            ++ map       declInp                            inps+                                            ++ map       (declDef   cfg skolemMap tableMap) (F.toList asgnsSeq)+  where -- NB. The below setting of skolemMap to empty is OK, since we do+        -- not support queries in the context of skolemized variables+        skolemMap = M.empty+        tableMap  = noInteractive ["Programs with constant tabled data"]++        declInp (s, _) = "(declare-fun " ++ show s ++ " () " ++ swType s ++ ")"++declDef :: SMTConfig -> SkolemMap -> TableMap -> (SW, SBVExpr) -> String+declDef cfg skolemMap tableMap (s, expr) =+        case expr of+          SBVApp  (Label m) [e] -> defineFun (s, cvtSW          skolemMap          e) (Just m)+          e                     -> defineFun (s, cvtExp caps rm skolemMap tableMap e) Nothing+  where caps = capabilities (solver cfg)+        rm   = roundingMode cfg++defineFun :: (SW, String) -> Maybe String -> String+defineFun (s, def) mbComment = "(define-fun "   ++ varT ++ " " ++ def ++ ")" ++ cmnt+  where varT      = show s ++ " " ++ swFunType [] s+        cmnt      = maybe "" (" ; " ++) mbComment++declConst :: SMTConfig -> (SW, CW) -> String+declConst cfg (s, c) = defineFun (s, cvtCW (roundingMode cfg) c) Nothing+ declUI :: (String, SBVType) -> [String] declUI (i, t) = ["(declare-fun " ++ i ++ " " ++ cvtType t ++ ")"] @@ -346,16 +298,14 @@  -- TODO: We currently do not support non-constant arrays when quantifiers are present, as -- we might have to skolemize those. Implement this properly.--- The difficulty is with the ArrayReset/Mutate/Merge: We have to postpone an init if+-- 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 :: Bool -> [SW] -> SkolemMap -> (Int, ArrayInfo) -> ([String], [String])-declArray quantified consts skolemMap (i, (_, (aKnd, bKnd), ctx)) = (adecl : map wrap pre, map snd post)+declArray quantified consts skolemMap (i, (_, (aKnd, bKnd), ctx)) = (adecl : map (wrap . snd) pre, map snd post)   where topLevel = not quantified || case ctx of-                                       ArrayFree Nothing -> True-                                       ArrayFree (Just sw) -> sw `elem` consts-                                       ArrayReset _ sw     -> sw `elem` consts-                                       ArrayMutate _ a b   -> all (`elem` consts) [a, b]-                                       ArrayMerge c _ _    -> c `elem` consts+                                       ArrayFree         -> True+                                       ArrayMutate _ a b -> all (`elem` consts) [a, b]+                                       ArrayMerge c _ _  -> c `elem` consts         (pre, post) = partition fst ctxInfo         nm = "array_" ++ show i         ssw sw@@ -365,17 +315,10 @@          = tbd "Non-constant array initializer in a quantified context"         adecl = "(declare-fun " ++ nm ++ " () (Array " ++ smtType aKnd ++ " " ++ smtType bKnd ++ "))"         ctxInfo = case ctx of-                    ArrayFree Nothing   -> []-                    ArrayFree (Just sw) -> declA sw-                    ArrayReset _ sw     -> declA sw+                    ArrayFree         -> []                     ArrayMutate j a b -> [(all (`elem` consts) [a, b], "(= " ++ nm ++ " (store array_" ++ show j ++ " " ++ ssw a ++ " " ++ ssw b ++ "))")]                     ArrayMerge  t j k -> [(t `elem` consts,            "(= " ++ nm ++ " (ite " ++ ssw t ++ " array_" ++ show j ++ " array_" ++ show k ++ "))")]-        declA sw = let iv = nm ++ "_freeInitializer"-                   in [ (True,             "(declare-fun " ++ iv ++ " () " ++ smtType aKnd ++ ")")-                      , (sw `elem` consts, "(= (select " ++ nm ++ " " ++ iv ++ ") " ++ ssw sw ++ ")")-                      ]-        wrap (False, s) = s-        wrap (True, s)  = "(assert " ++ s ++ ")"+        wrap s = "(assert " ++ s ++ ")"  swType :: SW -> String swType s = smtType (kindOf s)@@ -496,7 +439,7 @@          unintComp o [a, b]           | KUserSort s (Right _) <- kindOf (head arguments)-          = let idx v = "(" ++ s ++ "_constrIndex " ++ " " ++ v ++ ")" in "(" ++ o ++ " " ++ idx a ++ " " ++ idx b ++ ")"+          = let idx v = "(" ++ s ++ "_constrIndex " ++ v ++ ")" in "(" ++ o ++ " " ++ idx a ++ " " ++ idx b ++ ")"         unintComp o sbvs = error $ "SBV.SMT.SMTLib2.sh.unintComp: Unexpected arguments: "   ++ show (o, sbvs)          lift1  o _ [x]    = "(" ++ o ++ " " ++ x ++ ")"@@ -815,7 +758,4 @@ -- Add a named annotation named :: (Maybe String, String) -> String named (Nothing, x) = x-named (Just nm, x) = "(! " ++ x ++ " :named |" ++ concatMap sanitize nm ++ "|)"-  where sanitize '|'  = "_bar_"-        sanitize '\\' = "_backslash_"-        sanitize c    = [c]+named (Just nm, x) = annotateWithName nm x
Data/SBV/SMT/SMTLibNames.hs view
@@ -21,7 +21,7 @@                         , "!", "_", "as", "BINARY", "DECIMAL", "exists", "HEXADECIMAL", "forall", "let", "NUMERAL", "par", "STRING", "CHAR"                         , "assert", "check-sat", "check-sat-assuming", "declare-const", "declare-fun", "declare-sort", "define-fun", "define-fun-rec"                         , "define-sort", "echo", "exit", "get-assertions", "get-assignment", "get-info", "get-model", "get-option", "get-proof", "get-unsat-assumptions"-                        , "get-unsat-core", "get-value", "pop", "push", "reset", "reset-assertions", "set-info", "set-logic", "set-option"+                        , "get-unsat-core", "get-value", "pop", "push", "reset", "reset-assertions", "set-info", "set-logic", "set-option", "match"                         --                         -- The following are most likely Z3 specific                         , "interval", "assert-soft"
+ Data/SBV/SMT/Utils.hs view
@@ -0,0 +1,119 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.SMT.Utils+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- A few internally used types/routines+-----------------------------------------------------------------------------++module Data.SBV.SMT.Utils (+          SMTLibConverter+        , SMTLibIncConverter+        , annotateWithName+        , showTimeoutValue+        , alignDiagnostic+        , alignPlain+        , debug+        , mergeSExpr+       )+       where++import Data.SBV.Core.Data++import Data.List (intercalate)+import qualified Data.Set as Set (Set)++-- | An instance of SMT-Lib converter; instantiated for SMT-Lib v1 and v2. (And potentially for newer versions in the future.)+type SMTLibConverter a =  Set.Set Kind                 -- ^ Kinds used in the problem+                       -> Bool                         -- ^ is this a sat problem?+                       -> [String]                     -- ^ extra comments to place on top+                       -> [(Quantifier, NamedSymVar)]  -- ^ inputs and aliasing names+                       -> [Either SW (SW, [SW])]       -- ^ skolemized inputs+                       -> [(SW, CW)]                   -- ^ constants+                       -> [((Int, Kind, Kind), [SW])]  -- ^ auto-generated tables+                       -> [(Int, ArrayInfo)]           -- ^ user specified arrays+                       -> [(String, SBVType)]          -- ^ uninterpreted functions/constants+                       -> [(String, [String])]         -- ^ user given axioms+                       -> SBVPgm                       -- ^ assignments+                       -> [(Maybe String, SW)]         -- ^ extra constraints+                       -> SW                           -- ^ output variable+                       -> SMTConfig                    -- ^ configuration+                       -> a++-- | An instance of SMT-Lib converter; instantiated for SMT-Lib v1 and v2. (And potentially for newer versions in the future.)+type SMTLibIncConverter a =  [NamedSymVar] -- ^ inputs+                          -> Set.Set Kind  -- ^ Newly registered kinds+                          -> [(SW, CW)]    -- ^ constants+                          -> SBVPgm        -- ^ assignments+                          -> SMTConfig     -- ^ configuration+                          -> a++-- | Create an annotated term with the given name+annotateWithName :: String -> String -> String+annotateWithName nm x = "(! " ++ x ++ " :named |" ++ concatMap sanitize nm ++ "|)"+  where sanitize '|'  = "_bar_"+        sanitize '\\' = "_backslash_"+        sanitize c    = [c]++-- | Show a millisecond time-out value somewhat nicely+showTimeoutValue :: Int -> String+showTimeoutValue i = case (i `quotRem` 1000000, i `quotRem` 500000) of+                       ((s, 0), _)  -> shows s                              "s"+                       (_, (hs, 0)) -> shows (fromIntegral hs / (2::Float)) "s"+                       _            -> shows i "ms"++-- | Nicely align a potentially multi-line message with some tag, but prefix with three stars+alignDiagnostic :: String -> String -> String+alignDiagnostic = alignWithPrefix "*** "++-- | Nicely align a potentially multi-line message with some tag, no prefix.+alignPlain :: String -> String -> String+alignPlain = alignWithPrefix ""++-- | Align with some given prefix+alignWithPrefix :: String -> String -> String -> String+alignWithPrefix pre tag multi = intercalate "\n" $ zipWith (++) (tag : repeat (pre ++ replicate (length tag - length pre) ' ')) (filter (not . null) (lines multi))++-- | Diagnostic message when verbose+debug :: SMTConfig -> [String] -> IO ()+debug cfg+  | not (verbose cfg)             = const (return ())+  | Just f <- redirectVerbose cfg = mapM_ (appendFile f . (++ "\n"))+  | True                          = mapM_ putStrLn++-- | In case the SMT-Lib solver returns a response over multiple lines, compress them so we have+-- each S-Expression spanning only a single line.+mergeSExpr :: [String] -> [String]+mergeSExpr []       = []+mergeSExpr (x:xs)+ | d == 0 = x : mergeSExpr xs+ | True   = let (f, r) = grab d xs in unlines (x:f) : mergeSExpr r+ where d = parenDiff x++       parenDiff :: String -> Int+       parenDiff = go 0+         where go i ""       = i+               go i ('(':cs) = let i'= i+1 in i' `seq` go i' cs+               go i (')':cs) = let i'= i-1 in i' `seq` go i' cs+               go i ('"':cs) = go i (skipString cs)+               go i ('|':cs) = go i (skipBar cs)+               go i (_  :cs) = go i cs++       grab i ls+         | i <= 0    = ([], ls)+       grab _ []     = ([], [])+       grab i (l:ls) = let (a, b) = grab (i+parenDiff l) ls in (l:a, b)++       skipString ('\\':'"':cs) = skipString cs+       skipString ('"':'"':cs)  = skipString cs+       skipString ('"':cs)      = cs+       skipString (_:cs)        = skipString cs+       skipString []            = []             -- Oh dear, line finished, but the string didn't. We're in trouble. Ignore!++       skipBar ('|':cs) = cs+       skipBar (_:cs)   = skipBar cs+       skipBar []       = []                     -- Oh dear, line finished, but the string didn't. We're in trouble. Ignore!+
− Data/SBV/Tools/ExpectedValue.hs 
@@ -1,93 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Data.SBV.Tools.ExpectedValue--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Computing the expected value of a symbolic variable--------------------------------------------------------------------------------{-# LANGUAGE PatternGuards #-}-module Data.SBV.Tools.ExpectedValue (-        -- * Computing expected values-        expectedValue-      , expectedValueWith-      )-      where--import Control.DeepSeq (rnf)-import Control.Monad   (unless)-import System.Random   (newStdGen, StdGen)-import Numeric--import Data.SBV.Core.Data---- | Generalized version of 'expectedValue', allowing the user to specify the--- warm-up count and the convergence factor. Maximum iteration count can also--- be specified, at which point convergence won't be sought. The boolean controls verbosity.-expectedValueWith :: Outputtable a => Bool -> Int -> Maybe Int -> Double -> Symbolic a -> IO [Double]-expectedValueWith chatty warmupCount mbMaxIter epsilon m-  | warmupCount < 0 || epsilon < 0-  = error $ "SBV.expectedValue: warmup count and epsilon both must be non-negative, received: " ++ show (warmupCount, epsilon)-  | True-  = warmup warmupCount (repeat 0) >>= go warmupCount-  where progress s | not chatty = return ()-                   | True       = putStr $ "\r*** " ++ s-        warmup :: Int -> [Integer] -> IO [Integer]-        warmup 0 v = do progress $ "Warmup complete, performed " ++ show warmupCount ++ " rounds.\n"-                        return v-        warmup n v = do progress $ "Performing warmup, round: " ++ show (warmupCount - n)-                        g <- newStdGen-                        t <- runOnce g-                        let v' = zipWith (+) v t-                        rnf v' `seq` warmup (n-1) v'-        runOnce :: StdGen -> IO [Integer]-        runOnce g = do (_, Result _ _ _ _ cs _ _ _ _ _ cstrs _ goals _ os) <- runSymbolic' (Concrete g) (m >>= output)-                       unless (null goals) $ error "SBV.expectedValue: Cannot compute expected-values in the presence of optimization goals!"-                       let cval o = case o `lookup` cs of-                                      Nothing -> error "SBV.expectedValue: Cannot compute expected-values in the presence of uninterpreted constants!"-                                      Just cw -> case (kindOf cw, cwVal cw) of-                                                   (KBool, _)                -> if cwToBool cw then 1 else 0-                                                   (KBounded{}, CWInteger v) -> v-                                                   (KUnbounded, CWInteger v) -> v-                                                   (KReal, _)                -> error "Cannot compute expected-values for real valued results."-                                                   _                         -> error $ "SBV.expectedValueWith: Unexpected CW: " ++ show cw-                       if all ((== 1) . cval . snd) cstrs-                          then return $ map cval os-                          else runOnce g -- constraint not satisfied try again with the same set of constraints-        go :: Int -> [Integer] -> IO [Double]-        go cases curSums-         | Just n <- mbMaxIter, n < curRound-         = do progress "\n"-              progress "Maximum iteration count reached, stopping.\n"-              return curEVs-         | True-         = do g <- newStdGen-              t <- runOnce g-              let newSums  = zipWith (+) curSums t-                  newEVs = map ev' newSums-                  diffs  = zipWith (\x y -> abs (x - y)) newEVs curEVs-              if all (< epsilon) diffs-                 then do progress $ "Converges with epsilon " ++ show epsilon ++ " after " ++ show curRound ++ " rounds.\n"-                         return newEVs-                 else do progress $ "Tuning, round: " ++ show curRound ++ " (margin: " ++ showFFloat (Just 6) (maximum (0:diffs)) "" ++ ")"-                         go newCases newSums-         where curRound = cases - warmupCount-               newCases = cases + 1-               ev, ev' :: Integer -> Double-               ev  x  = fromIntegral x / fromIntegral cases-               ev' x  = fromIntegral x / fromIntegral newCases-               curEVs = map ev curSums---- | Given a symbolic computation that produces a value, compute the--- expected value that value would take if this computation is run--- with its free variables drawn from uniform distributions of its--- respective values, satisfying the given constraints specified by--- 'constrain' and 'pConstrain' calls. This is equivalent to calling--- 'expectedValueWith' the following parameters: verbose, warm-up--- round count of @10000@, no maximum iteration count, and with--- convergence margin @0.0001@.-expectedValue :: Outputtable a => Symbolic a -> IO [Double]-expectedValue = expectedValueWith True 10000 Nothing 0.0001
Data/SBV/Tools/GenTest.hs view
@@ -19,7 +19,6 @@ import Data.Function (on) import Data.List     (intercalate, groupBy) import Data.Maybe    (fromMaybe)-import System.Random  import Data.SBV.Core.AlgReals import Data.SBV.Core.Data@@ -38,20 +37,19 @@ -- | Generate a set of concrete test values from a symbolic program. The output -- can be rendered as test vectors in different languages as necessary. Use the -- function 'output' call to indicate what fields should be in the test result.--- (Also see 'constrain' and 'pConstrain' for filtering acceptable test values.)+-- (Also see 'constrain' for filtering acceptable test values.) genTest :: Outputtable a => Int -> Symbolic a -> IO TestVectors genTest n m = gen 0 []   where gen i sofar          | i == n = return $ TV $ reverse sofar-         | True   = do g <- newStdGen-                       t <- tc g+         | True   = do t <- tc                        gen (i+1) (t:sofar)-        tc g = do (_, Result _ tvals _ _ cs _ _ _ _ _ cstrs _ _ _ os) <- runSymbolic' (Concrete g) (m >>= output)-                  let cval = fromMaybe (error "Cannot generate tests in the presence of uninterpeted constants!") . (`lookup` cs)-                      cond = all (cwToBool . cval . snd) cstrs-                  if cond-                     then return (map snd tvals, map cval os)-                     else tc g  -- try again, with the same set of constraints+        tc = do (_, Result {resTraces=tvals, resConsts=cs, resConstraints=cstrs, resOutputs=os}) <- runSymbolic Concrete (m >>= output)+                let cval = fromMaybe (error "Cannot generate tests in the presence of uninterpeted constants!") . (`lookup` cs)+                    cond = all (cwToBool . cval . snd) cstrs+                if cond+                   then return (map snd tvals, map cval os)+                   else tc   -- try again, with the same set of constraints  -- | Test output style data TestStyle = Haskell String                     -- ^ As a Haskell value with given name@@ -298,7 +296,7 @@         form []     [] = []         form []     bs = error $ "SBV.renderTest: Mismatched index in stream, extra " ++ show (length bs) ++ " bit(s) remain."         form (i:is) bs-          | length bs < i = error $ "SBV.renderTest: Mismatched index in stream, was looking for " ++ show i ++ " bit(s), but only " ++ show i ++ " remains."+          | length bs < i = error $ "SBV.renderTest: Mismatched index in stream, was looking for " ++ show i ++ " bit(s), but only " ++ show bs ++ " remains."           | i == 1        = let b:r = bs                                 v   = if b == '1' then "T" else "F"                             in v : form is r
Data/SBV/Utils/PrettyNum.hs view
@@ -240,9 +240,9 @@ toSMTLibRational :: Rational -> String toSMTLibRational r    | n < 0-   = "(- (/ "  ++ show (abs n) ++ " " ++ show d ++ "))"+   = "(- (/ "  ++ show (abs n) ++ ".0 " ++ show d ++ ".0))"    | True-   = "(/ " ++ show n ++ " " ++ show d ++ ")"+   = "(/ " ++ show n ++ ".0 " ++ show d ++ ".0)"   where n = numerator r         d = denominator r
+ Data/SBV/Utils/SExpr.hs view
@@ -0,0 +1,235 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Utils.SExpr+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Parsing of S-expressions (mainly used for parsing SMT-Lib get-value output)+-----------------------------------------------------------------------------++{-# LANGUAGE BangPatterns #-}++module Data.SBV.Utils.SExpr (SExpr(..), parenDeficit, parseSExpr) where++import Data.Bits           (setBit, testBit)+import Data.Word           (Word32, Word64)+import Data.Char           (isDigit, ord, isSpace)+import Data.List           (isPrefixOf)+import Data.Maybe          (fromMaybe, listToMaybe)+import Numeric             (readInt, readDec, readHex, fromRat)+import Data.Binary.IEEE754 (wordToFloat, wordToDouble)++import Data.SBV.Core.AlgReals+import Data.SBV.Core.Data (nan, infinity, RoundingMode(..))++-- | ADT S-Expression format, suitable for representing get-model output of SMT-Lib+data SExpr = ECon    String+           | ENum    (Integer, Maybe Int)  -- Second argument is how wide the field was in bits, if known. Useful in FP parsing.+           | EReal   AlgReal+           | EFloat  Float+           | EDouble Double+           | EApp    [SExpr]+           deriving Show++-- | Extremely simple minded tokenizer, good for our use model.+tokenize :: String -> [String]+tokenize inp = go inp []+ where go "" sofar = reverse sofar++       go (c:cs) sofar+          | isSpace c = go (dropWhile isSpace cs) sofar++       go ('(':cs) sofar = go cs ("(" : sofar)+       go (')':cs) sofar = go cs (")" : sofar)++       go (':':':':cs) sofar = go cs ("::" : sofar)++       go (':':cs) sofar = case break (`elem` stopper) cs of+                            (pre, rest) -> go rest ((':':pre) : sofar)++       go ('|':r) sofar = case span (/= '|') r of+                            (pre, '|':rest) -> go rest (pre : sofar)+                            (pre, rest)     -> go rest (pre : sofar)++       go ('"':r) sofar = go rest (show str : sofar)+           where grabString []            acc = (reverse acc, [])        -- Strictly speaking, this is the unterminated string case; but let's ignore+                 grabString ('\\':'"':cs) acc = grabString cs ('"':acc)  -- I don't think this is a valid escape actually, but it used to be. Be safe.+                 grabString ('"' :'"':cs) acc = grabString cs ('"':acc)  -- In SMTLib "" becomes ". Weird escape indeed.+                 grabString ('"':cs)      acc = (reverse acc, cs)+                 grabString (c:cs)        acc = grabString cs (c:acc)++                 (str, rest) = grabString r []++       go cs sofar = case span (`notElem` stopper) cs of+                       (pre, post) -> go post (pre : sofar)++       -- characters that can stop the current token+       -- it is *crucial* that this list contains every character+       -- we can match in one of the previous cases!+       stopper = " \t\n():|\""++-- | The balance of parens in this string. If 0, this means it's a legit line!+parenDeficit :: String -> Int+parenDeficit = go 0 . tokenize+  where go :: Int -> [String] -> Int+        go !balance []          = balance+        go !balance ("(" : rest) = go (balance+1) rest+        go !balance (")" : rest) = go (balance-1) rest+        go !balance (_   : rest) = go balance     rest++-- | Parse a string into an SExpr, potentially failing with an error message+parseSExpr :: String -> Either String SExpr+parseSExpr inp = do (sexp, extras) <- parse inpToks+                    if null extras+                       then case sexp of+                              EApp [ECon "error", ECon er] -> Left $ "Solver returned an error: " ++ er+                              _                            -> return sexp++                       else die "Extra tokens after valid input"+  where inpToks = tokenize inp++        die w = fail $  "SBV.Provers.SExpr: Failed to parse S-Expr: " ++ w+                     ++ "\n*** Input : <" ++ inp ++ ">"++        parse []         = die "ran out of tokens"+        parse ("(":toks) = do (f, r) <- parseApp toks []+                              f' <- cvt (EApp f)+                              return (f', r)+        parse (")":_)    = die "extra tokens after close paren"+        parse [tok]      = do t <- pTok tok+                              return (t, [])+        parse _          = die "ill-formed s-expr"++        parseApp []         _     = die "failed to grab s-expr application"+        parseApp (")":toks) sofar = return (reverse sofar, toks)+        parseApp ("(":toks) sofar = do (f, r) <- parse ("(":toks)+                                       parseApp r (f : sofar)+        parseApp (tok:toks) sofar = do t <- pTok tok+                                       parseApp toks (t : sofar)++        pTok "false"              = return $ ENum (0, Nothing)+        pTok "true"               = return $ ENum (1, Nothing)+        pTok ('0':'b':r)          = mkNum (Just (length r))     $ readInt 2 (`elem` "01") (\c -> ord c - ord '0') r+        pTok ('b':'v':r)          = mkNum Nothing               $ readDec (takeWhile (/= '[') r)+        pTok ('#':'b':r)          = mkNum (Just (length r))     $ readInt 2 (`elem` "01") (\c -> ord c - ord '0') r+        pTok ('#':'x':r)          = mkNum (Just (4 * length r)) $ readHex r+        pTok n+          | not (null n) && isDigit (head n)+          = if '.' `elem` n then getReal n+            else mkNum Nothing $ readDec n+        pTok n                 = return $ ECon (constantMap n)++        mkNum l [(n, "")] = return $ ENum (n, l)+        mkNum _ _         = die "cannot read number"++        getReal n = return $ EReal $ mkPolyReal (Left (exact, n'))+          where exact = not ("?" `isPrefixOf` reverse n)+                n' | exact = n+                   | True  = init n++        -- simplify numbers and root-obj values+        cvt (EApp [ECon "to_int",  EReal a])                       = return $ EReal a   -- ignore the "casting"+        cvt (EApp [ECon "to_real", EReal a])                       = return $ EReal a   -- ignore the "casting"+        cvt (EApp [ECon "/", EReal a, EReal b])                    = return $ EReal (a / b)+        cvt (EApp [ECon "/", EReal a, ENum  b])                    = return $ EReal (a                   / fromInteger (fst b))+        cvt (EApp [ECon "/", ENum  a, EReal b])                    = return $ EReal (fromInteger (fst a) /             b      )+        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+                                                                        return $ EReal $ mkPolyReal (Right (fst k, ts))+        cvt (EApp [ECon "as", n, EApp [ECon "_", ECon "FloatingPoint", ENum (11, _), ENum (53, _)]]) = getDouble n+        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+        -- 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+        cvt (EApp [ECon "_",     ECon "NaN",       ENum ( 8, _),       ENum (24,      _)])           = return $ EFloat  nan+        cvt (EApp [ECon "_",     ECon "NaN",       ENum (11, _),       ENum (53,      _)])           = return $ EDouble nan+        cvt (EApp [ECon "_",     ECon "+oo",       ENum ( 8, _),       ENum (24,      _)])           = return $ EFloat  infinity+        cvt (EApp [ECon "_",     ECon "+oo",       ENum (11, _),       ENum (53,      _)])           = return $ EDouble infinity+        cvt (EApp [ECon "_",     ECon "-oo",       ENum ( 8, _),       ENum (24,      _)])           = return $ EFloat  (-infinity)+        cvt (EApp [ECon "_",     ECon "-oo",       ENum (11, _),       ENum (53,      _)])           = return $ EDouble (-infinity)+        cvt (EApp [ECon "_",     ECon "+zero",     ENum ( 8, _),       ENum (24,      _)])           = return $ EFloat  0+        cvt (EApp [ECon "_",     ECon "+zero",     ENum (11, _),       ENum (53,      _)])           = return $ EDouble 0+        cvt (EApp [ECon "_",     ECon "-zero",     ENum ( 8, _),       ENum (24,      _)])           = return $ EFloat  (-0)+        cvt (EApp [ECon "_",     ECon "-zero",     ENum (11, _),       ENum (53,      _)])           = return $ EDouble (-0)+        cvt x                                                                                        = return x++        getCoeff (EApp [ECon "*", ENum k, EApp [ECon "^", ECon "x", ENum p]]) = return (fst k, fst p)  -- kx^p+        getCoeff (EApp [ECon "*", ENum k,                 ECon "x"        ] ) = return (fst k,     1)  -- kx+        getCoeff (                        EApp [ECon "^", ECon "x", ENum p] ) = return (    1, fst p)  --  x^p+        getCoeff (                                        ECon "x"          ) = return (    1,     1)  --  x+        getCoeff (                ENum k                                    ) = return (fst k,     0)  -- k+        getCoeff x = die $ "Cannot parse a root-obj,\nProcessing term: " ++ show x+        getDouble (ECon s)  = case (s, rdFP (dropWhile (== '+') s)) of+                                ("plusInfinity",  _     ) -> return $ EDouble infinity+                                ("minusInfinity", _     ) -> return $ EDouble (-infinity)+                                ("oo",            _     ) -> return $ EDouble infinity+                                ("-oo",           _     ) -> return $ EDouble (-infinity)+                                ("zero",          _     ) -> return $ EDouble 0+                                ("-zero",         _     ) -> return $ EDouble (-0)+                                ("NaN",           _     ) -> return $ EDouble nan+                                (_,               Just v) -> return $ EDouble v+                                _               -> die $ "Cannot parse a double value from: " ++ s+        getDouble (EApp [_, s, _, _]) = getDouble s+        getDouble (EReal r) = return $ EDouble $ fromRat $ toRational r+        getDouble x         = die $ "Cannot parse a double value from: " ++ show x+        getFloat (ECon s)   = case (s, rdFP (dropWhile (== '+') s)) of+                                ("plusInfinity",  _     ) -> return $ EFloat infinity+                                ("minusInfinity", _     ) -> return $ EFloat (-infinity)+                                ("oo",            _     ) -> return $ EFloat infinity+                                ("-oo",           _     ) -> return $ EFloat (-infinity)+                                ("zero",          _     ) -> return $ EFloat 0+                                ("-zero",         _     ) -> return $ EFloat (-0)+                                ("NaN",           _     ) -> return $ EFloat nan+                                (_,               Just v) -> return $ EFloat v+                                _               -> die $ "Cannot parse a float value from: " ++ s+        getFloat (EReal r)  = return $ EFloat $ fromRat $ toRational r+        getFloat (EApp [_, s, _, _]) = getFloat s+        getFloat x          = die $ "Cannot parse a float value from: " ++ show x++-- | Parses the Z3 floating point formatted numbers like so: 1.321p5/1.2123e9 etc.+rdFP :: (Read a, RealFloat a) => String -> Maybe a+rdFP s = case break (`elem` "pe") s of+           (m, 'p':e) -> rd m >>= \m' -> rd e >>= \e' -> return $ m' * ( 2 ** e')+           (m, 'e':e) -> rd m >>= \m' -> rd e >>= \e' -> return $ m' * (10 ** e')+           (m, "")    -> rd m+           _          -> Nothing+ where rd v = case reads v of+                [(n, "")] -> Just n+                _         -> Nothing++-- | Convert an (s, e, m) triple to a float value+getTripleFloat :: Integer -> Integer -> Integer -> Float+getTripleFloat s e m = wordToFloat w32+  where sign      = [s == 1]+        expt      = [e `testBit` i | i <- [ 7,  6 .. 0]]+        mantissa  = [m `testBit` i | i <- [22, 21 .. 0]]+        positions = [i | (i, b) <- zip [31, 30 .. 0] (sign ++ expt ++ mantissa), b]+        w32       = foldr (flip setBit) (0::Word32) positions++-- | Convert an (s, e, m) triple to a float value+getTripleDouble :: Integer -> Integer -> Integer -> Double+getTripleDouble s e m = wordToDouble w64+  where sign      = [s == 1]+        expt      = [e `testBit` i | i <- [10,  9 .. 0]]+        mantissa  = [m `testBit` i | i <- [51, 50 .. 0]]+        positions = [i | (i, b) <- zip [63, 62 .. 0] (sign ++ expt ++ mantissa), b]+        w64       = foldr (flip setBit) (0::Word64) positions++-- | Special constants of SMTLib2 and their internal translation. Mainly+-- rounding modes for now.+constantMap :: String -> String+constantMap n = fromMaybe n (listToMaybe [to | (from, to) <- special, n `elem` from])+ where special = [ (["RNE", "roundNearestTiesToEven"], show RoundNearestTiesToEven)+                 , (["RNA", "roundNearestTiesToAway"], show RoundNearestTiesToAway)+                 , (["RTP", "roundTowardPositive"],    show RoundTowardPositive)+                 , (["RTN", "roundTowardNegative"],    show RoundTowardNegative)+                 , (["RTZ", "roundTowardZero"],        show RoundTowardZero)+                 ]
Data/SBV/Utils/TDiff.hs view
@@ -10,68 +10,48 @@ -----------------------------------------------------------------------------  module Data.SBV.Utils.TDiff-  ( timeIf-  , Timing(..)-  , TimedStep(..)-  , TimingInfo+  ( Timing(..)   , showTDiff   )   where -import Control.DeepSeq (rnf, NFData(..))-import System.Time     (TimeDiff(..), normalizeTimeDiff, diffClockTimes, getClockTime)-import Numeric         (showFFloat)+import Data.Time  (NominalDiffTime)+import Data.IORef (IORef) -import           Data.Map (Map)-import qualified Data.Map as Map-import           Data.IORef(IORef, modifyIORef')+import Data.List (intercalate) --- | Specify how to save timing information, if at all.-data Timing     = NoTiming | PrintTiming | SaveTiming (IORef TimingInfo)+import Data.Ratio+import GHC.Real   (Ratio((:%))) --- | Specify what is being timed.-data TimedStep  = ProblemConstruction | Translation | WorkByProver String-                  deriving (Eq, Ord, Show)+import Numeric (showFFloat) --- | A collection of timed stepd.-type TimingInfo = Map TimedStep TimeDiff+-- | Specify how to save timing information, if at all.+data Timing = NoTiming | PrintTiming | SaveTiming (IORef NominalDiffTime) --- | A more helpful show instance for steps-timedStepLabel :: TimedStep -> String-timedStepLabel lbl =-  case lbl of-    ProblemConstruction -> "problem construction"-    Translation         -> "translation"-    WorkByProver x      -> x+-- | Show 'NominalDiffTime' in human readable form. 'NominalDiffTime' is+-- essentially picoseconds (10^-12 seconds). We show it so that+-- it's represented at the day:hour:minute:second.XXX granularity.+showTDiff :: NominalDiffTime -> String+showTDiff diff+   | denom /= 1    -- Should never happen! But just in case.+   = show diff+   | True+   = intercalate ":" fields+   where total, denom :: Integer+         total :% denom = (picoFactor % 1) * toRational diff --- | Show the time difference in a user-friendly format.-showTDiff :: TimeDiff -> String-showTDiff itd = et-  where td = normalizeTimeDiff itd-        vals = dropWhile (\(v, _) -> v == 0) (zip [tdYear td, tdMonth td, tdDay td, tdHour td, tdMin td] "YMDhm")-        sec = ' ' : show (tdSec td) ++ dropWhile (/= '.') pico-        pico = showFFloat (Just 3) (((10**(-12))::Double) * fromIntegral (tdPicosec td)) "s"-        et = concatMap (\(v, c) -> ' ':show v ++ [c]) vals ++ sec+         -- there are 10^12 pico-seconds in a second+         picoFactor :: Integer+         picoFactor = (10 :: Integer) ^ (12 :: Integer) --- | If selected, runs the computation @m@, and prints the time it took--- to run it. The return type should be an instance of 'NFData' to ensure--- the correct elapsed time is printed.-timeIf :: NFData a => Timing -> TimedStep -> IO a -> IO a-timeIf how what m =-  case how of-    NoTiming -> m-    PrintTiming ->-      do (elapsed,a) <- doTime m-         putStrLn $ "** Elapsed " ++ timedStepLabel what ++ " time:" ++ showTDiff elapsed-         return a-    SaveTiming here ->-      do (elapsed,a) <- doTime m-         modifyIORef' here (Map.insert what elapsed)-         return a+         [s2p, m2s, h2m, d2h] = drop 1 $ scanl (*) 1 [picoFactor, 60, 60, 24] -doTime :: NFData a => IO a -> IO (TimeDiff,a)-doTime m = do start <- getClockTime-              r <- m-              end <- rnf r `seq` getClockTime-              let elapsed = diffClockTimes end start-              elapsed `seq` return (elapsed, r)+         (days,    days')    = total    `divMod` d2h+         (hours,   hours')   = days'    `divMod` h2m+         (minutes, seconds') = hours'   `divMod` m2s+         (seconds, picos)    = seconds' `divMod` s2p+         secondsPicos        =  show seconds+                             ++ dropWhile (/= '.') (showFFloat (Just 3) (fromIntegral picos * (10**(-12) :: Double)) "s")++         aboveSeconds = map (\(t, v) -> show v ++ [t]) $ dropWhile (\p -> snd p == 0) [('d', days), ('h', hours), ('m', minutes)]+         fields       = aboveSeconds ++ [secondsPicos]
− GHC/SrcLoc/Compat.hs 
@@ -1,11 +0,0 @@-{-# LANGUAGE CPP #-}---- | Compatibility shims for the SrcLoc interface across GHC versions--module GHC.SrcLoc.Compat (module X) where--#if MIN_VERSION_base(4,9,0)-import SrcLoc as X hiding (srcLocFile)-#else-import GHC.SrcLoc as X-#endif
− GHC/Stack/Compat.hs 
@@ -1,6 +0,0 @@-{-# LANGUAGE CPP #-}---- | Compatibility shims for the Stack interface across GHC versions--module GHC.Stack.Compat (module GHC.Stack) where-import GHC.Stack
INSTALL view
@@ -3,17 +3,9 @@       cabal install sbv -Once the installation is done, you will get the Data.SBV library.-The installation will also put a binary named--     SBVUnitTests+SBV relies on an external SMT solver to be installed. We currently support+ABC, Boolector, CVC4, MathSAT, Yices, and Z3. We recommend installing the+freely available z3 SMT solver from Microsoft, the default solver used+by SBV. You can get it from <http://github.com/Z3Prover/z3>. -in your .cabal/bin directory (or wherever you installed it.) It's-highly recommended that you run this program to ensure everything-is working correctly. In particular, you will first need to install-Z3, the default SMT solver used by sbv, from Microsoft. (You can get it-from <http://github.com/Z3Prover/z3>.) Please make sure that the "z3" executable is in your path.--Once you have installed sbv, you can use it in your Haskell programs-by simply importing the Data.SBV module.
+ SBVTestSuite/GoldFiles/U2Bridge.gold view
@@ -0,0 +1,16 @@+Satisfiable. Model:+  s0  = False :: Bool+  s1  =  Edge :: U2Member+  s2  =  Bono :: U2Member+  s3  =  True :: Bool+  s4  =  Edge :: U2Member+  s5  =  Bono :: U2Member+  s6  = False :: Bool+  s7  = Larry :: U2Member+  s8  =  Adam :: U2Member+  s9  =  True :: Bool+  s10 =  Bono :: U2Member+  s11 =  Bono :: U2Member+  s12 = False :: Bool+  s13 =  Edge :: U2Member+  s14 =  Bono :: U2Member
+ SBVTestSuite/GoldFiles/addSub.gold view
@@ -0,0 +1,105 @@+== BEGIN: "Makefile" ================+# Makefile for addSub. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: addSub_driver++addSub.o: addSub.c addSub.h+	${CC} ${CCFLAGS} -c $< -o $@++addSub_driver.o: addSub_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++addSub_driver: addSub.o addSub_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f addSub_driver+== END: "Makefile" ==================+== BEGIN: "addSub.h" ================+/* Header file for addSub. Automatically generated by SBV. Do not edit! */++#ifndef __addSub__HEADER_INCLUDED__+#define __addSub__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+void addSub(const SWord8 x, const SWord8 y, SWord8 *sum,+            SWord8 *dif);++#endif /* __addSub__HEADER_INCLUDED__ */+== END: "addSub.h" ==================+== BEGIN: "addSub_driver.c" ================+/* Example driver program for addSub. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "addSub.h"++int main(void)+{+  SWord8 sum;+  SWord8 dif;++  addSub(76, 92, &sum, &dif);++  printf("addSub(76, 92, &sum, &dif) ->\n");+  printf("  sum = %"PRIu8"\n", sum);+  printf("  dif = %"PRIu8"\n", dif);++  return 0;+}+== END: "addSub_driver.c" ==================+== BEGIN: "addSub.c" ================+/* File: "addSub.c". Automatically generated by SBV. Do not edit! */++#include "addSub.h"++void addSub(const SWord8 x, const SWord8 y, SWord8 *sum,+            SWord8 *dif)+{+  const SWord8 s0 = x;+  const SWord8 s1 = y;+  const SWord8 s2 = s0 + s1;+  const SWord8 s3 = s0 - s1;++  *sum = s2;+  *dif = s3;+}+== END: "addSub.c" ==================
+ SBVTestSuite/GoldFiles/aes128Dec.gold view
@@ -0,0 +1,2609 @@+== BEGIN: "Makefile" ================+# Makefile for aes128Dec. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: aes128Dec_driver++aes128Dec.o: aes128Dec.c aes128Dec.h+	${CC} ${CCFLAGS} -c $< -o $@++aes128Dec_driver.o: aes128Dec_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++aes128Dec_driver: aes128Dec.o aes128Dec_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f aes128Dec_driver+== END: "Makefile" ==================+== BEGIN: "aes128Dec.h" ================+/* Header file for aes128Dec. Automatically generated by SBV. Do not edit! */++#ifndef __aes128Dec__HEADER_INCLUDED__+#define __aes128Dec__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+void aes128Dec(const SWord32 *pt, const SWord32 *key, SWord32 *ct);++#endif /* __aes128Dec__HEADER_INCLUDED__ */+== END: "aes128Dec.h" ==================+== BEGIN: "aes128Dec_driver.c" ================+/* Example driver program for aes128Dec. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "aes128Dec.h"++int main(void)+{+  const SWord32 pt[4] = {+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL+  };++  printf("Contents of input array pt:\n");+  int pt_ctr;+  for(pt_ctr = 0; pt_ctr < 4 ; ++pt_ctr)+    printf("  pt[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]);++  const SWord32 key[4] = {+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL+  };++  printf("Contents of input array key:\n");+  int key_ctr;+  for(key_ctr = 0; key_ctr < 4 ; ++key_ctr)+    printf("  key[%d] = 0x%08"PRIx32"UL\n", key_ctr ,key[key_ctr]);++  SWord32 ct[4];++  aes128Dec(pt, key, ct);++  printf("aes128Dec(pt, key, ct) ->\n");+  int ct_ctr;+  for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr)+    printf("  ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]);++  return 0;+}+== END: "aes128Dec_driver.c" ==================+== BEGIN: "aes128Dec.c" ================+/* File: "aes128Dec.c". Automatically generated by SBV. Do not edit! */++#include "aes128Dec.h"++void aes128Dec(const SWord32 *pt, const SWord32 *key, SWord32 *ct)+{+  const SWord32 s0 = pt[0];+  const SWord32 s1 = pt[1];+  const SWord32 s2 = pt[2];+  const SWord32 s3 = pt[3];+  const SWord32 s4 = key[0];+  const SWord32 s5 = key[1];+  const SWord32 s6 = key[2];+  const SWord32 s7 = key[3];+  static const SWord8 table0[] = {+       82,   9, 106, 213,  48,  54, 165,  56, 191,  64, 163, 158, 129,+      243, 215, 251, 124, 227,  57, 130, 155,  47, 255, 135,  52, 142,+       67,  68, 196, 222, 233, 203,  84, 123, 148,  50, 166, 194,  35,+       61, 238,  76, 149,  11,  66, 250, 195,  78,   8,  46, 161, 102,+       40, 217,  36, 178, 118,  91, 162,  73, 109, 139, 209,  37, 114,+      248, 246, 100, 134, 104, 152,  22, 212, 164,  92, 204,  93, 101,+      182, 146, 108, 112,  72,  80, 253, 237, 185, 218,  94,  21,  70,+       87, 167, 141, 157, 132, 144, 216, 171,   0, 140, 188, 211,  10,+      247, 228,  88,   5, 184, 179,  69,   6, 208,  44,  30, 143, 202,+       63,  15,   2, 193, 175, 189,   3,   1,  19, 138, 107,  58, 145,+       17,  65,  79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230,+      115, 150, 172, 116,  34, 231, 173,  53, 133, 226, 249,  55, 232,+       28, 117, 223, 110,  71, 241,  26, 113,  29,  41, 197, 137, 111,+      183,  98,  14, 170,  24, 190,  27, 252,  86,  62,  75, 198, 210,+      121,  32, 154, 219, 192, 254, 120, 205,  90, 244,  31, 221, 168,+       51, 136,   7, 199,  49, 177,  18,  16,  89,  39, 128, 236,  95,+       96,  81, 127, 169,  25, 181,  74,  13,  45, 229, 122, 159, 147,+      201, 156, 239, 160, 224,  59,  77, 174,  42, 245, 176, 200, 235,+      187,  60, 131,  83, 153,  97,  23,  43,   4, 126, 186, 119, 214,+       38, 225, 105,  20,  99,  85,  33,  12, 125+  };+  static const SWord32 table1[] = {+      0x51f4a750UL, 0x7e416553UL, 0x1a17a4c3UL, 0x3a275e96UL,+      0x3bab6bcbUL, 0x1f9d45f1UL, 0xacfa58abUL, 0x4be30393UL,+      0x2030fa55UL, 0xad766df6UL, 0x88cc7691UL, 0xf5024c25UL,+      0x4fe5d7fcUL, 0xc52acbd7UL, 0x26354480UL, 0xb562a38fUL,+      0xdeb15a49UL, 0x25ba1b67UL, 0x45ea0e98UL, 0x5dfec0e1UL,+      0xc32f7502UL, 0x814cf012UL, 0x8d4697a3UL, 0x6bd3f9c6UL,+      0x038f5fe7UL, 0x15929c95UL, 0xbf6d7aebUL, 0x955259daUL,+      0xd4be832dUL, 0x587421d3UL, 0x49e06929UL, 0x8ec9c844UL,+      0x75c2896aUL, 0xf48e7978UL, 0x99583e6bUL, 0x27b971ddUL,+      0xbee14fb6UL, 0xf088ad17UL, 0xc920ac66UL, 0x7dce3ab4UL,+      0x63df4a18UL, 0xe51a3182UL, 0x97513360UL, 0x62537f45UL,+      0xb16477e0UL, 0xbb6bae84UL, 0xfe81a01cUL, 0xf9082b94UL,+      0x70486858UL, 0x8f45fd19UL, 0x94de6c87UL, 0x527bf8b7UL,+      0xab73d323UL, 0x724b02e2UL, 0xe31f8f57UL, 0x6655ab2aUL,+      0xb2eb2807UL, 0x2fb5c203UL, 0x86c57b9aUL, 0xd33708a5UL,+      0x302887f2UL, 0x23bfa5b2UL, 0x02036abaUL, 0xed16825cUL,+      0x8acf1c2bUL, 0xa779b492UL, 0xf307f2f0UL, 0x4e69e2a1UL,+      0x65daf4cdUL, 0x0605bed5UL, 0xd134621fUL, 0xc4a6fe8aUL,+      0x342e539dUL, 0xa2f355a0UL, 0x058ae132UL, 0xa4f6eb75UL,+      0x0b83ec39UL, 0x4060efaaUL, 0x5e719f06UL, 0xbd6e1051UL,+      0x3e218af9UL, 0x96dd063dUL, 0xdd3e05aeUL, 0x4de6bd46UL,+      0x91548db5UL, 0x71c45d05UL, 0x0406d46fUL, 0x605015ffUL,+      0x1998fb24UL, 0xd6bde997UL, 0x894043ccUL, 0x67d99e77UL,+      0xb0e842bdUL, 0x07898b88UL, 0xe7195b38UL, 0x79c8eedbUL,+      0xa17c0a47UL, 0x7c420fe9UL, 0xf8841ec9UL, 0x00000000UL,+      0x09808683UL, 0x322bed48UL, 0x1e1170acUL, 0x6c5a724eUL,+      0xfd0efffbUL, 0x0f853856UL, 0x3daed51eUL, 0x362d3927UL,+      0x0a0fd964UL, 0x685ca621UL, 0x9b5b54d1UL, 0x24362e3aUL,+      0x0c0a67b1UL, 0x9357e70fUL, 0xb4ee96d2UL, 0x1b9b919eUL,+      0x80c0c54fUL, 0x61dc20a2UL, 0x5a774b69UL, 0x1c121a16UL,+      0xe293ba0aUL, 0xc0a02ae5UL, 0x3c22e043UL, 0x121b171dUL,+      0x0e090d0bUL, 0xf28bc7adUL, 0x2db6a8b9UL, 0x141ea9c8UL,+      0x57f11985UL, 0xaf75074cUL, 0xee99ddbbUL, 0xa37f60fdUL,+      0xf701269fUL, 0x5c72f5bcUL, 0x44663bc5UL, 0x5bfb7e34UL,+      0x8b432976UL, 0xcb23c6dcUL, 0xb6edfc68UL, 0xb8e4f163UL,+      0xd731dccaUL, 0x42638510UL, 0x13972240UL, 0x84c61120UL,+      0x854a247dUL, 0xd2bb3df8UL, 0xaef93211UL, 0xc729a16dUL,+      0x1d9e2f4bUL, 0xdcb230f3UL, 0x0d8652ecUL, 0x77c1e3d0UL,+      0x2bb3166cUL, 0xa970b999UL, 0x119448faUL, 0x47e96422UL,+      0xa8fc8cc4UL, 0xa0f03f1aUL, 0x567d2cd8UL, 0x223390efUL,+      0x87494ec7UL, 0xd938d1c1UL, 0x8ccaa2feUL, 0x98d40b36UL,+      0xa6f581cfUL, 0xa57ade28UL, 0xdab78e26UL, 0x3fadbfa4UL,+      0x2c3a9de4UL, 0x5078920dUL, 0x6a5fcc9bUL, 0x547e4662UL,+      0xf68d13c2UL, 0x90d8b8e8UL, 0x2e39f75eUL, 0x82c3aff5UL,+      0x9f5d80beUL, 0x69d0937cUL, 0x6fd52da9UL, 0xcf2512b3UL,+      0xc8ac993bUL, 0x10187da7UL, 0xe89c636eUL, 0xdb3bbb7bUL,+      0xcd267809UL, 0x6e5918f4UL, 0xec9ab701UL, 0x834f9aa8UL,+      0xe6956e65UL, 0xaaffe67eUL, 0x21bccf08UL, 0xef15e8e6UL,+      0xbae79bd9UL, 0x4a6f36ceUL, 0xea9f09d4UL, 0x29b07cd6UL,+      0x31a4b2afUL, 0x2a3f2331UL, 0xc6a59430UL, 0x35a266c0UL,+      0x744ebc37UL, 0xfc82caa6UL, 0xe090d0b0UL, 0x33a7d815UL,+      0xf104984aUL, 0x41ecdaf7UL, 0x7fcd500eUL, 0x1791f62fUL,+      0x764dd68dUL, 0x43efb04dUL, 0xccaa4d54UL, 0xe49604dfUL,+      0x9ed1b5e3UL, 0x4c6a881bUL, 0xc12c1fb8UL, 0x4665517fUL,+      0x9d5eea04UL, 0x018c355dUL, 0xfa877473UL, 0xfb0b412eUL,+      0xb3671d5aUL, 0x92dbd252UL, 0xe9105633UL, 0x6dd64713UL,+      0x9ad7618cUL, 0x37a10c7aUL, 0x59f8148eUL, 0xeb133c89UL,+      0xcea927eeUL, 0xb761c935UL, 0xe11ce5edUL, 0x7a47b13cUL,+      0x9cd2df59UL, 0x55f2733fUL, 0x1814ce79UL, 0x73c737bfUL,+      0x53f7cdeaUL, 0x5ffdaa5bUL, 0xdf3d6f14UL, 0x7844db86UL,+      0xcaaff381UL, 0xb968c43eUL, 0x3824342cUL, 0xc2a3405fUL,+      0x161dc372UL, 0xbce2250cUL, 0x283c498bUL, 0xff0d9541UL,+      0x39a80171UL, 0x080cb3deUL, 0xd8b4e49cUL, 0x6456c190UL,+      0x7bcb8461UL, 0xd532b670UL, 0x486c5c74UL, 0xd0b85742UL+  };+  static const SWord8 table2[] = {+       99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254,+      215, 171, 118, 202, 130, 201, 125, 250,  89,  71, 240, 173, 212,+      162, 175, 156, 164, 114, 192, 183, 253, 147,  38,  54,  63, 247,+      204,  52, 165, 229, 241, 113, 216,  49,  21,   4, 199,  35, 195,+       24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,   9,+      131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,+       47, 132,  83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,+       57,  74,  76,  88, 207, 208, 239, 170, 251,  67,  77,  51, 133,+       69, 249,   2, 127,  80,  60, 159, 168,  81, 163,  64, 143, 146,+      157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210, 205,  12,+       19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25,+      115,  96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20,+      222,  94,  11, 219, 224,  50,  58,  10,  73,   6,  36,  92, 194,+      211, 172,  98, 145, 149, 228, 121, 231, 200,  55, 109, 141, 213,+       78, 169, 108,  86, 244, 234, 101, 122, 174,   8, 186, 120,  37,+       46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,+      112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134,+      193,  29, 158, 225, 248, 152,  17, 105, 217, 142, 148, 155,  30,+      135, 233, 206,  85,  40, 223, 140, 161, 137,  13, 191, 230,  66,+      104,  65, 153,  45,  15, 176,  84, 187,  22+  };+  static const SWord32 table3[] = {+      0x5051f4a7UL, 0x537e4165UL, 0xc31a17a4UL, 0x963a275eUL,+      0xcb3bab6bUL, 0xf11f9d45UL, 0xabacfa58UL, 0x934be303UL,+      0x552030faUL, 0xf6ad766dUL, 0x9188cc76UL, 0x25f5024cUL,+      0xfc4fe5d7UL, 0xd7c52acbUL, 0x80263544UL, 0x8fb562a3UL,+      0x49deb15aUL, 0x6725ba1bUL, 0x9845ea0eUL, 0xe15dfec0UL,+      0x02c32f75UL, 0x12814cf0UL, 0xa38d4697UL, 0xc66bd3f9UL,+      0xe7038f5fUL, 0x9515929cUL, 0xebbf6d7aUL, 0xda955259UL,+      0x2dd4be83UL, 0xd3587421UL, 0x2949e069UL, 0x448ec9c8UL,+      0x6a75c289UL, 0x78f48e79UL, 0x6b99583eUL, 0xdd27b971UL,+      0xb6bee14fUL, 0x17f088adUL, 0x66c920acUL, 0xb47dce3aUL,+      0x1863df4aUL, 0x82e51a31UL, 0x60975133UL, 0x4562537fUL,+      0xe0b16477UL, 0x84bb6baeUL, 0x1cfe81a0UL, 0x94f9082bUL,+      0x58704868UL, 0x198f45fdUL, 0x8794de6cUL, 0xb7527bf8UL,+      0x23ab73d3UL, 0xe2724b02UL, 0x57e31f8fUL, 0x2a6655abUL,+      0x07b2eb28UL, 0x032fb5c2UL, 0x9a86c57bUL, 0xa5d33708UL,+      0xf2302887UL, 0xb223bfa5UL, 0xba02036aUL, 0x5ced1682UL,+      0x2b8acf1cUL, 0x92a779b4UL, 0xf0f307f2UL, 0xa14e69e2UL,+      0xcd65daf4UL, 0xd50605beUL, 0x1fd13462UL, 0x8ac4a6feUL,+      0x9d342e53UL, 0xa0a2f355UL, 0x32058ae1UL, 0x75a4f6ebUL,+      0x390b83ecUL, 0xaa4060efUL, 0x065e719fUL, 0x51bd6e10UL,+      0xf93e218aUL, 0x3d96dd06UL, 0xaedd3e05UL, 0x464de6bdUL,+      0xb591548dUL, 0x0571c45dUL, 0x6f0406d4UL, 0xff605015UL,+      0x241998fbUL, 0x97d6bde9UL, 0xcc894043UL, 0x7767d99eUL,+      0xbdb0e842UL, 0x8807898bUL, 0x38e7195bUL, 0xdb79c8eeUL,+      0x47a17c0aUL, 0xe97c420fUL, 0xc9f8841eUL, 0x00000000UL,+      0x83098086UL, 0x48322bedUL, 0xac1e1170UL, 0x4e6c5a72UL,+      0xfbfd0effUL, 0x560f8538UL, 0x1e3daed5UL, 0x27362d39UL,+      0x640a0fd9UL, 0x21685ca6UL, 0xd19b5b54UL, 0x3a24362eUL,+      0xb10c0a67UL, 0x0f9357e7UL, 0xd2b4ee96UL, 0x9e1b9b91UL,+      0x4f80c0c5UL, 0xa261dc20UL, 0x695a774bUL, 0x161c121aUL,+      0x0ae293baUL, 0xe5c0a02aUL, 0x433c22e0UL, 0x1d121b17UL,+      0x0b0e090dUL, 0xadf28bc7UL, 0xb92db6a8UL, 0xc8141ea9UL,+      0x8557f119UL, 0x4caf7507UL, 0xbbee99ddUL, 0xfda37f60UL,+      0x9ff70126UL, 0xbc5c72f5UL, 0xc544663bUL, 0x345bfb7eUL,+      0x768b4329UL, 0xdccb23c6UL, 0x68b6edfcUL, 0x63b8e4f1UL,+      0xcad731dcUL, 0x10426385UL, 0x40139722UL, 0x2084c611UL,+      0x7d854a24UL, 0xf8d2bb3dUL, 0x11aef932UL, 0x6dc729a1UL,+      0x4b1d9e2fUL, 0xf3dcb230UL, 0xec0d8652UL, 0xd077c1e3UL,+      0x6c2bb316UL, 0x99a970b9UL, 0xfa119448UL, 0x2247e964UL,+      0xc4a8fc8cUL, 0x1aa0f03fUL, 0xd8567d2cUL, 0xef223390UL,+      0xc787494eUL, 0xc1d938d1UL, 0xfe8ccaa2UL, 0x3698d40bUL,+      0xcfa6f581UL, 0x28a57adeUL, 0x26dab78eUL, 0xa43fadbfUL,+      0xe42c3a9dUL, 0x0d507892UL, 0x9b6a5fccUL, 0x62547e46UL,+      0xc2f68d13UL, 0xe890d8b8UL, 0x5e2e39f7UL, 0xf582c3afUL,+      0xbe9f5d80UL, 0x7c69d093UL, 0xa96fd52dUL, 0xb3cf2512UL,+      0x3bc8ac99UL, 0xa710187dUL, 0x6ee89c63UL, 0x7bdb3bbbUL,+      0x09cd2678UL, 0xf46e5918UL, 0x01ec9ab7UL, 0xa8834f9aUL,+      0x65e6956eUL, 0x7eaaffe6UL, 0x0821bccfUL, 0xe6ef15e8UL,+      0xd9bae79bUL, 0xce4a6f36UL, 0xd4ea9f09UL, 0xd629b07cUL,+      0xaf31a4b2UL, 0x312a3f23UL, 0x30c6a594UL, 0xc035a266UL,+      0x37744ebcUL, 0xa6fc82caUL, 0xb0e090d0UL, 0x1533a7d8UL,+      0x4af10498UL, 0xf741ecdaUL, 0x0e7fcd50UL, 0x2f1791f6UL,+      0x8d764dd6UL, 0x4d43efb0UL, 0x54ccaa4dUL, 0xdfe49604UL,+      0xe39ed1b5UL, 0x1b4c6a88UL, 0xb8c12c1fUL, 0x7f466551UL,+      0x049d5eeaUL, 0x5d018c35UL, 0x73fa8774UL, 0x2efb0b41UL,+      0x5ab3671dUL, 0x5292dbd2UL, 0x33e91056UL, 0x136dd647UL,+      0x8c9ad761UL, 0x7a37a10cUL, 0x8e59f814UL, 0x89eb133cUL,+      0xeecea927UL, 0x35b761c9UL, 0xede11ce5UL, 0x3c7a47b1UL,+      0x599cd2dfUL, 0x3f55f273UL, 0x791814ceUL, 0xbf73c737UL,+      0xea53f7cdUL, 0x5b5ffdaaUL, 0x14df3d6fUL, 0x867844dbUL,+      0x81caaff3UL, 0x3eb968c4UL, 0x2c382434UL, 0x5fc2a340UL,+      0x72161dc3UL, 0x0cbce225UL, 0x8b283c49UL, 0x41ff0d95UL,+      0x7139a801UL, 0xde080cb3UL, 0x9cd8b4e4UL, 0x906456c1UL,+      0x617bcb84UL, 0x70d532b6UL, 0x74486c5cUL, 0x42d0b857UL+  };+  static const SWord32 table4[] = {+      0xa75051f4UL, 0x65537e41UL, 0xa4c31a17UL, 0x5e963a27UL,+      0x6bcb3babUL, 0x45f11f9dUL, 0x58abacfaUL, 0x03934be3UL,+      0xfa552030UL, 0x6df6ad76UL, 0x769188ccUL, 0x4c25f502UL,+      0xd7fc4fe5UL, 0xcbd7c52aUL, 0x44802635UL, 0xa38fb562UL,+      0x5a49deb1UL, 0x1b6725baUL, 0x0e9845eaUL, 0xc0e15dfeUL,+      0x7502c32fUL, 0xf012814cUL, 0x97a38d46UL, 0xf9c66bd3UL,+      0x5fe7038fUL, 0x9c951592UL, 0x7aebbf6dUL, 0x59da9552UL,+      0x832dd4beUL, 0x21d35874UL, 0x692949e0UL, 0xc8448ec9UL,+      0x896a75c2UL, 0x7978f48eUL, 0x3e6b9958UL, 0x71dd27b9UL,+      0x4fb6bee1UL, 0xad17f088UL, 0xac66c920UL, 0x3ab47dceUL,+      0x4a1863dfUL, 0x3182e51aUL, 0x33609751UL, 0x7f456253UL,+      0x77e0b164UL, 0xae84bb6bUL, 0xa01cfe81UL, 0x2b94f908UL,+      0x68587048UL, 0xfd198f45UL, 0x6c8794deUL, 0xf8b7527bUL,+      0xd323ab73UL, 0x02e2724bUL, 0x8f57e31fUL, 0xab2a6655UL,+      0x2807b2ebUL, 0xc2032fb5UL, 0x7b9a86c5UL, 0x08a5d337UL,+      0x87f23028UL, 0xa5b223bfUL, 0x6aba0203UL, 0x825ced16UL,+      0x1c2b8acfUL, 0xb492a779UL, 0xf2f0f307UL, 0xe2a14e69UL,+      0xf4cd65daUL, 0xbed50605UL, 0x621fd134UL, 0xfe8ac4a6UL,+      0x539d342eUL, 0x55a0a2f3UL, 0xe132058aUL, 0xeb75a4f6UL,+      0xec390b83UL, 0xefaa4060UL, 0x9f065e71UL, 0x1051bd6eUL,+      0x8af93e21UL, 0x063d96ddUL, 0x05aedd3eUL, 0xbd464de6UL,+      0x8db59154UL, 0x5d0571c4UL, 0xd46f0406UL, 0x15ff6050UL,+      0xfb241998UL, 0xe997d6bdUL, 0x43cc8940UL, 0x9e7767d9UL,+      0x42bdb0e8UL, 0x8b880789UL, 0x5b38e719UL, 0xeedb79c8UL,+      0x0a47a17cUL, 0x0fe97c42UL, 0x1ec9f884UL, 0x00000000UL,+      0x86830980UL, 0xed48322bUL, 0x70ac1e11UL, 0x724e6c5aUL,+      0xfffbfd0eUL, 0x38560f85UL, 0xd51e3daeUL, 0x3927362dUL,+      0xd9640a0fUL, 0xa621685cUL, 0x54d19b5bUL, 0x2e3a2436UL,+      0x67b10c0aUL, 0xe70f9357UL, 0x96d2b4eeUL, 0x919e1b9bUL,+      0xc54f80c0UL, 0x20a261dcUL, 0x4b695a77UL, 0x1a161c12UL,+      0xba0ae293UL, 0x2ae5c0a0UL, 0xe0433c22UL, 0x171d121bUL,+      0x0d0b0e09UL, 0xc7adf28bUL, 0xa8b92db6UL, 0xa9c8141eUL,+      0x198557f1UL, 0x074caf75UL, 0xddbbee99UL, 0x60fda37fUL,+      0x269ff701UL, 0xf5bc5c72UL, 0x3bc54466UL, 0x7e345bfbUL,+      0x29768b43UL, 0xc6dccb23UL, 0xfc68b6edUL, 0xf163b8e4UL,+      0xdccad731UL, 0x85104263UL, 0x22401397UL, 0x112084c6UL,+      0x247d854aUL, 0x3df8d2bbUL, 0x3211aef9UL, 0xa16dc729UL,+      0x2f4b1d9eUL, 0x30f3dcb2UL, 0x52ec0d86UL, 0xe3d077c1UL,+      0x166c2bb3UL, 0xb999a970UL, 0x48fa1194UL, 0x642247e9UL,+      0x8cc4a8fcUL, 0x3f1aa0f0UL, 0x2cd8567dUL, 0x90ef2233UL,+      0x4ec78749UL, 0xd1c1d938UL, 0xa2fe8ccaUL, 0x0b3698d4UL,+      0x81cfa6f5UL, 0xde28a57aUL, 0x8e26dab7UL, 0xbfa43fadUL,+      0x9de42c3aUL, 0x920d5078UL, 0xcc9b6a5fUL, 0x4662547eUL,+      0x13c2f68dUL, 0xb8e890d8UL, 0xf75e2e39UL, 0xaff582c3UL,+      0x80be9f5dUL, 0x937c69d0UL, 0x2da96fd5UL, 0x12b3cf25UL,+      0x993bc8acUL, 0x7da71018UL, 0x636ee89cUL, 0xbb7bdb3bUL,+      0x7809cd26UL, 0x18f46e59UL, 0xb701ec9aUL, 0x9aa8834fUL,+      0x6e65e695UL, 0xe67eaaffUL, 0xcf0821bcUL, 0xe8e6ef15UL,+      0x9bd9bae7UL, 0x36ce4a6fUL, 0x09d4ea9fUL, 0x7cd629b0UL,+      0xb2af31a4UL, 0x23312a3fUL, 0x9430c6a5UL, 0x66c035a2UL,+      0xbc37744eUL, 0xcaa6fc82UL, 0xd0b0e090UL, 0xd81533a7UL,+      0x984af104UL, 0xdaf741ecUL, 0x500e7fcdUL, 0xf62f1791UL,+      0xd68d764dUL, 0xb04d43efUL, 0x4d54ccaaUL, 0x04dfe496UL,+      0xb5e39ed1UL, 0x881b4c6aUL, 0x1fb8c12cUL, 0x517f4665UL,+      0xea049d5eUL, 0x355d018cUL, 0x7473fa87UL, 0x412efb0bUL,+      0x1d5ab367UL, 0xd25292dbUL, 0x5633e910UL, 0x47136dd6UL,+      0x618c9ad7UL, 0x0c7a37a1UL, 0x148e59f8UL, 0x3c89eb13UL,+      0x27eecea9UL, 0xc935b761UL, 0xe5ede11cUL, 0xb13c7a47UL,+      0xdf599cd2UL, 0x733f55f2UL, 0xce791814UL, 0x37bf73c7UL,+      0xcdea53f7UL, 0xaa5b5ffdUL, 0x6f14df3dUL, 0xdb867844UL,+      0xf381caafUL, 0xc43eb968UL, 0x342c3824UL, 0x405fc2a3UL,+      0xc372161dUL, 0x250cbce2UL, 0x498b283cUL, 0x9541ff0dUL,+      0x017139a8UL, 0xb3de080cUL, 0xe49cd8b4UL, 0xc1906456UL,+      0x84617bcbUL, 0xb670d532UL, 0x5c74486cUL, 0x5742d0b8UL+  };+  static const SWord32 table5[] = {+      0xf4a75051UL, 0x4165537eUL, 0x17a4c31aUL, 0x275e963aUL,+      0xab6bcb3bUL, 0x9d45f11fUL, 0xfa58abacUL, 0xe303934bUL,+      0x30fa5520UL, 0x766df6adUL, 0xcc769188UL, 0x024c25f5UL,+      0xe5d7fc4fUL, 0x2acbd7c5UL, 0x35448026UL, 0x62a38fb5UL,+      0xb15a49deUL, 0xba1b6725UL, 0xea0e9845UL, 0xfec0e15dUL,+      0x2f7502c3UL, 0x4cf01281UL, 0x4697a38dUL, 0xd3f9c66bUL,+      0x8f5fe703UL, 0x929c9515UL, 0x6d7aebbfUL, 0x5259da95UL,+      0xbe832dd4UL, 0x7421d358UL, 0xe0692949UL, 0xc9c8448eUL,+      0xc2896a75UL, 0x8e7978f4UL, 0x583e6b99UL, 0xb971dd27UL,+      0xe14fb6beUL, 0x88ad17f0UL, 0x20ac66c9UL, 0xce3ab47dUL,+      0xdf4a1863UL, 0x1a3182e5UL, 0x51336097UL, 0x537f4562UL,+      0x6477e0b1UL, 0x6bae84bbUL, 0x81a01cfeUL, 0x082b94f9UL,+      0x48685870UL, 0x45fd198fUL, 0xde6c8794UL, 0x7bf8b752UL,+      0x73d323abUL, 0x4b02e272UL, 0x1f8f57e3UL, 0x55ab2a66UL,+      0xeb2807b2UL, 0xb5c2032fUL, 0xc57b9a86UL, 0x3708a5d3UL,+      0x2887f230UL, 0xbfa5b223UL, 0x036aba02UL, 0x16825cedUL,+      0xcf1c2b8aUL, 0x79b492a7UL, 0x07f2f0f3UL, 0x69e2a14eUL,+      0xdaf4cd65UL, 0x05bed506UL, 0x34621fd1UL, 0xa6fe8ac4UL,+      0x2e539d34UL, 0xf355a0a2UL, 0x8ae13205UL, 0xf6eb75a4UL,+      0x83ec390bUL, 0x60efaa40UL, 0x719f065eUL, 0x6e1051bdUL,+      0x218af93eUL, 0xdd063d96UL, 0x3e05aeddUL, 0xe6bd464dUL,+      0x548db591UL, 0xc45d0571UL, 0x06d46f04UL, 0x5015ff60UL,+      0x98fb2419UL, 0xbde997d6UL, 0x4043cc89UL, 0xd99e7767UL,+      0xe842bdb0UL, 0x898b8807UL, 0x195b38e7UL, 0xc8eedb79UL,+      0x7c0a47a1UL, 0x420fe97cUL, 0x841ec9f8UL, 0x00000000UL,+      0x80868309UL, 0x2bed4832UL, 0x1170ac1eUL, 0x5a724e6cUL,+      0x0efffbfdUL, 0x8538560fUL, 0xaed51e3dUL, 0x2d392736UL,+      0x0fd9640aUL, 0x5ca62168UL, 0x5b54d19bUL, 0x362e3a24UL,+      0x0a67b10cUL, 0x57e70f93UL, 0xee96d2b4UL, 0x9b919e1bUL,+      0xc0c54f80UL, 0xdc20a261UL, 0x774b695aUL, 0x121a161cUL,+      0x93ba0ae2UL, 0xa02ae5c0UL, 0x22e0433cUL, 0x1b171d12UL,+      0x090d0b0eUL, 0x8bc7adf2UL, 0xb6a8b92dUL, 0x1ea9c814UL,+      0xf1198557UL, 0x75074cafUL, 0x99ddbbeeUL, 0x7f60fda3UL,+      0x01269ff7UL, 0x72f5bc5cUL, 0x663bc544UL, 0xfb7e345bUL,+      0x4329768bUL, 0x23c6dccbUL, 0xedfc68b6UL, 0xe4f163b8UL,+      0x31dccad7UL, 0x63851042UL, 0x97224013UL, 0xc6112084UL,+      0x4a247d85UL, 0xbb3df8d2UL, 0xf93211aeUL, 0x29a16dc7UL,+      0x9e2f4b1dUL, 0xb230f3dcUL, 0x8652ec0dUL, 0xc1e3d077UL,+      0xb3166c2bUL, 0x70b999a9UL, 0x9448fa11UL, 0xe9642247UL,+      0xfc8cc4a8UL, 0xf03f1aa0UL, 0x7d2cd856UL, 0x3390ef22UL,+      0x494ec787UL, 0x38d1c1d9UL, 0xcaa2fe8cUL, 0xd40b3698UL,+      0xf581cfa6UL, 0x7ade28a5UL, 0xb78e26daUL, 0xadbfa43fUL,+      0x3a9de42cUL, 0x78920d50UL, 0x5fcc9b6aUL, 0x7e466254UL,+      0x8d13c2f6UL, 0xd8b8e890UL, 0x39f75e2eUL, 0xc3aff582UL,+      0x5d80be9fUL, 0xd0937c69UL, 0xd52da96fUL, 0x2512b3cfUL,+      0xac993bc8UL, 0x187da710UL, 0x9c636ee8UL, 0x3bbb7bdbUL,+      0x267809cdUL, 0x5918f46eUL, 0x9ab701ecUL, 0x4f9aa883UL,+      0x956e65e6UL, 0xffe67eaaUL, 0xbccf0821UL, 0x15e8e6efUL,+      0xe79bd9baUL, 0x6f36ce4aUL, 0x9f09d4eaUL, 0xb07cd629UL,+      0xa4b2af31UL, 0x3f23312aUL, 0xa59430c6UL, 0xa266c035UL,+      0x4ebc3774UL, 0x82caa6fcUL, 0x90d0b0e0UL, 0xa7d81533UL,+      0x04984af1UL, 0xecdaf741UL, 0xcd500e7fUL, 0x91f62f17UL,+      0x4dd68d76UL, 0xefb04d43UL, 0xaa4d54ccUL, 0x9604dfe4UL,+      0xd1b5e39eUL, 0x6a881b4cUL, 0x2c1fb8c1UL, 0x65517f46UL,+      0x5eea049dUL, 0x8c355d01UL, 0x877473faUL, 0x0b412efbUL,+      0x671d5ab3UL, 0xdbd25292UL, 0x105633e9UL, 0xd647136dUL,+      0xd7618c9aUL, 0xa10c7a37UL, 0xf8148e59UL, 0x133c89ebUL,+      0xa927eeceUL, 0x61c935b7UL, 0x1ce5ede1UL, 0x47b13c7aUL,+      0xd2df599cUL, 0xf2733f55UL, 0x14ce7918UL, 0xc737bf73UL,+      0xf7cdea53UL, 0xfdaa5b5fUL, 0x3d6f14dfUL, 0x44db8678UL,+      0xaff381caUL, 0x68c43eb9UL, 0x24342c38UL, 0xa3405fc2UL,+      0x1dc37216UL, 0xe2250cbcUL, 0x3c498b28UL, 0x0d9541ffUL,+      0xa8017139UL, 0x0cb3de08UL, 0xb4e49cd8UL, 0x56c19064UL,+      0xcb84617bUL, 0x32b670d5UL, 0x6c5c7448UL, 0xb85742d0UL+  };+  static const SWord8 table6[] = {+        0,  14,  28,  18,  56,  54,  36,  42, 112, 126, 108,  98,  72,+       70,  84,  90, 224, 238, 252, 242, 216, 214, 196, 202, 144, 158,+      140, 130, 168, 166, 180, 186, 219, 213, 199, 201, 227, 237, 255,+      241, 171, 165, 183, 185, 147, 157, 143, 129,  59,  53,  39,  41,+        3,  13,  31,  17,  75,  69,  87,  89, 115, 125, 111,  97, 173,+      163, 177, 191, 149, 155, 137, 135, 221, 211, 193, 207, 229, 235,+      249, 247,  77,  67,  81,  95, 117, 123, 105, 103,  61,  51,  33,+       47,   5,  11,  25,  23, 118, 120, 106, 100,  78,  64,  82,  92,+        6,   8,  26,  20,  62,  48,  34,  44, 150, 152, 138, 132, 174,+      160, 178, 188, 230, 232, 250, 244, 222, 208, 194, 204,  65,  79,+       93,  83, 121, 119, 101, 107,  49,  63,  45,  35,   9,   7,  21,+       27, 161, 175, 189, 179, 153, 151, 133, 139, 209, 223, 205, 195,+      233, 231, 245, 251, 154, 148, 134, 136, 162, 172, 190, 176, 234,+      228, 246, 248, 210, 220, 206, 192, 122, 116, 102, 104,  66,  76,+       94,  80,  10,   4,  22,  24,  50,  60,  46,  32, 236, 226, 240,+      254, 212, 218, 200, 198, 156, 146, 128, 142, 164, 170, 184, 182,+       12,   2,  16,  30,  52,  58,  40,  38, 124, 114,  96, 110,  68,+       74,  88,  86,  55,  57,  43,  37,  15,   1,  19,  29,  71,  73,+       91,  85, 127, 113,  99, 109, 215, 217, 203, 197, 239, 225, 243,+      253, 167, 169, 187, 181, 159, 145, 131, 141+  };+  static const SWord8 table7[] = {+        0,  11,  22,  29,  44,  39,  58,  49,  88,  83,  78,  69, 116,+      127,  98, 105, 176, 187, 166, 173, 156, 151, 138, 129, 232, 227,+      254, 245, 196, 207, 210, 217, 123, 112, 109, 102,  87,  92,  65,+       74,  35,  40,  53,  62,  15,   4,  25,  18, 203, 192, 221, 214,+      231, 236, 241, 250, 147, 152, 133, 142, 191, 180, 169, 162, 246,+      253, 224, 235, 218, 209, 204, 199, 174, 165, 184, 179, 130, 137,+      148, 159,  70,  77,  80,  91, 106,  97, 124, 119,  30,  21,   8,+        3,  50,  57,  36,  47, 141, 134, 155, 144, 161, 170, 183, 188,+      213, 222, 195, 200, 249, 242, 239, 228,  61,  54,  43,  32,  17,+       26,   7,  12, 101, 110, 115, 120,  73,  66,  95,  84, 247, 252,+      225, 234, 219, 208, 205, 198, 175, 164, 185, 178, 131, 136, 149,+      158,  71,  76,  81,  90, 107,  96, 125, 118,  31,  20,   9,   2,+       51,  56,  37,  46, 140, 135, 154, 145, 160, 171, 182, 189, 212,+      223, 194, 201, 248, 243, 238, 229,  60,  55,  42,  33,  16,  27,+        6,  13, 100, 111, 114, 121,  72,  67,  94,  85,   1,  10,  23,+       28,  45,  38,  59,  48,  89,  82,  79,  68, 117, 126,  99, 104,+      177, 186, 167, 172, 157, 150, 139, 128, 233, 226, 255, 244, 197,+      206, 211, 216, 122, 113, 108, 103,  86,  93,  64,  75,  34,  41,+       52,  63,  14,   5,  24,  19, 202, 193, 220, 215, 230, 237, 240,+      251, 146, 153, 132, 143, 190, 181, 168, 163+  };+  static const SWord8 table8[] = {+        0,  13,  26,  23,  52,  57,  46,  35, 104, 101, 114, 127,  92,+       81,  70,  75, 208, 221, 202, 199, 228, 233, 254, 243, 184, 181,+      162, 175, 140, 129, 150, 155, 187, 182, 161, 172, 143, 130, 149,+      152, 211, 222, 201, 196, 231, 234, 253, 240, 107, 102, 113, 124,+       95,  82,  69,  72,   3,  14,  25,  20,  55,  58,  45,  32, 109,+       96, 119, 122,  89,  84,  67,  78,   5,   8,  31,  18,  49,  60,+       43,  38, 189, 176, 167, 170, 137, 132, 147, 158, 213, 216, 207,+      194, 225, 236, 251, 246, 214, 219, 204, 193, 226, 239, 248, 245,+      190, 179, 164, 169, 138, 135, 144, 157,   6,  11,  28,  17,  50,+       63,  40,  37, 110,  99, 116, 121,  90,  87,  64,  77, 218, 215,+      192, 205, 238, 227, 244, 249, 178, 191, 168, 165, 134, 139, 156,+      145,  10,   7,  16,  29,  62,  51,  36,  41,  98, 111, 120, 117,+       86,  91,  76,  65,  97, 108, 123, 118,  85,  88,  79,  66,   9,+        4,  19,  30,  61,  48,  39,  42, 177, 188, 171, 166, 133, 136,+      159, 146, 217, 212, 195, 206, 237, 224, 247, 250, 183, 186, 173,+      160, 131, 142, 153, 148, 223, 210, 197, 200, 235, 230, 241, 252,+      103, 106, 125, 112,  83,  94,  73,  68,  15,   2,  21,  24,  59,+       54,  33,  44,  12,   1,  22,  27,  56,  53,  34,  47, 100, 105,+      126, 115,  80,  93,  74,  71, 220, 209, 198, 203, 232, 229, 242,+      255, 180, 185, 174, 163, 128, 141, 154, 151+  };+  static const SWord8 table9[] = {+        0,   9,  18,  27,  36,  45,  54,  63,  72,  65,  90,  83, 108,+      101, 126, 119, 144, 153, 130, 139, 180, 189, 166, 175, 216, 209,+      202, 195, 252, 245, 238, 231,  59,  50,  41,  32,  31,  22,  13,+        4, 115, 122,  97, 104,  87,  94,  69,  76, 171, 162, 185, 176,+      143, 134, 157, 148, 227, 234, 241, 248, 199, 206, 213, 220, 118,+      127, 100, 109,  82,  91,  64,  73,  62,  55,  44,  37,  26,  19,+        8,   1, 230, 239, 244, 253, 194, 203, 208, 217, 174, 167, 188,+      181, 138, 131, 152, 145,  77,  68,  95,  86, 105,  96, 123, 114,+        5,  12,  23,  30,  33,  40,  51,  58, 221, 212, 207, 198, 249,+      240, 235, 226, 149, 156, 135, 142, 177, 184, 163, 170, 236, 229,+      254, 247, 200, 193, 218, 211, 164, 173, 182, 191, 128, 137, 146,+      155, 124, 117, 110, 103,  88,  81,  74,  67,  52,  61,  38,  47,+       16,  25,   2,  11, 215, 222, 197, 204, 243, 250, 225, 232, 159,+      150, 141, 132, 187, 178, 169, 160,  71,  78,  85,  92,  99, 106,+      113, 120,  15,   6,  29,  20,  43,  34,  57,  48, 154, 147, 136,+      129, 190, 183, 172, 165, 210, 219, 192, 201, 246, 255, 228, 237,+       10,   3,  24,  17,  46,  39,  60,  53,  66,  75,  80,  89, 102,+      111, 116, 125, 161, 168, 179, 186, 133, 140, 151, 158, 233, 224,+      251, 242, 205, 196, 223, 214,  49,  56,  35,  42,  21,  28,   7,+       14, 121, 112, 107,  98,  93,  84,  79,  70+  };+  const SWord32 s520 = (s7 << 8) | (s7 >> 24);+  const SWord16 s521 = (SWord16) (s520 >> 16);+  const SWord8  s522 = (SWord8) (s521 >> 8);+  const SWord8  s523 = table2[s522];+  const SWord8  s524 = 1 ^ s523;+  const SWord8  s525 = (SWord8) s521;+  const SWord8  s526 = table2[s525];+  const SWord16 s527 = (((SWord16) s524) << 8) | ((SWord16) s526);+  const SWord16 s528 = (SWord16) s520;+  const SWord8  s529 = (SWord8) (s528 >> 8);+  const SWord8  s530 = table2[s529];+  const SWord8  s531 = (SWord8) s528;+  const SWord8  s532 = table2[s531];+  const SWord16 s533 = (((SWord16) s530) << 8) | ((SWord16) s532);+  const SWord32 s534 = (((SWord32) s527) << 16) | ((SWord32) s533);+  const SWord32 s535 = s4 ^ s534;+  const SWord32 s536 = s5 ^ s535;+  const SWord32 s537 = s6 ^ s536;+  const SWord32 s538 = s7 ^ s537;+  const SWord32 s539 = (s538 << 8) | (s538 >> 24);+  const SWord16 s540 = (SWord16) (s539 >> 16);+  const SWord8  s541 = (SWord8) (s540 >> 8);+  const SWord8  s542 = table2[s541];+  const SWord8  s543 = 2 ^ s542;+  const SWord8  s544 = (SWord8) s540;+  const SWord8  s545 = table2[s544];+  const SWord16 s546 = (((SWord16) s543) << 8) | ((SWord16) s545);+  const SWord16 s547 = (SWord16) s539;+  const SWord8  s548 = (SWord8) (s547 >> 8);+  const SWord8  s549 = table2[s548];+  const SWord8  s550 = (SWord8) s547;+  const SWord8  s551 = table2[s550];+  const SWord16 s552 = (((SWord16) s549) << 8) | ((SWord16) s551);+  const SWord32 s553 = (((SWord32) s546) << 16) | ((SWord32) s552);+  const SWord32 s554 = s535 ^ s553;+  const SWord32 s555 = s536 ^ s554;+  const SWord32 s556 = s537 ^ s555;+  const SWord32 s557 = s538 ^ s556;+  const SWord32 s558 = (s557 << 8) | (s557 >> 24);+  const SWord16 s559 = (SWord16) (s558 >> 16);+  const SWord8  s560 = (SWord8) (s559 >> 8);+  const SWord8  s561 = table2[s560];+  const SWord8  s562 = 4 ^ s561;+  const SWord8  s563 = (SWord8) s559;+  const SWord8  s564 = table2[s563];+  const SWord16 s565 = (((SWord16) s562) << 8) | ((SWord16) s564);+  const SWord16 s566 = (SWord16) s558;+  const SWord8  s567 = (SWord8) (s566 >> 8);+  const SWord8  s568 = table2[s567];+  const SWord8  s569 = (SWord8) s566;+  const SWord8  s570 = table2[s569];+  const SWord16 s571 = (((SWord16) s568) << 8) | ((SWord16) s570);+  const SWord32 s572 = (((SWord32) s565) << 16) | ((SWord32) s571);+  const SWord32 s573 = s554 ^ s572;+  const SWord32 s574 = s555 ^ s573;+  const SWord32 s575 = s556 ^ s574;+  const SWord32 s576 = s557 ^ s575;+  const SWord32 s577 = (s576 << 8) | (s576 >> 24);+  const SWord16 s578 = (SWord16) (s577 >> 16);+  const SWord8  s579 = (SWord8) (s578 >> 8);+  const SWord8  s580 = table2[s579];+  const SWord8  s581 = 8 ^ s580;+  const SWord8  s582 = (SWord8) s578;+  const SWord8  s583 = table2[s582];+  const SWord16 s584 = (((SWord16) s581) << 8) | ((SWord16) s583);+  const SWord16 s585 = (SWord16) s577;+  const SWord8  s586 = (SWord8) (s585 >> 8);+  const SWord8  s587 = table2[s586];+  const SWord8  s588 = (SWord8) s585;+  const SWord8  s589 = table2[s588];+  const SWord16 s590 = (((SWord16) s587) << 8) | ((SWord16) s589);+  const SWord32 s591 = (((SWord32) s584) << 16) | ((SWord32) s590);+  const SWord32 s592 = s573 ^ s591;+  const SWord32 s593 = s574 ^ s592;+  const SWord32 s594 = s575 ^ s593;+  const SWord32 s595 = s576 ^ s594;+  const SWord32 s596 = (s595 << 8) | (s595 >> 24);+  const SWord16 s597 = (SWord16) (s596 >> 16);+  const SWord8  s598 = (SWord8) (s597 >> 8);+  const SWord8  s599 = table2[s598];+  const SWord8  s600 = 16 ^ s599;+  const SWord8  s601 = (SWord8) s597;+  const SWord8  s602 = table2[s601];+  const SWord16 s603 = (((SWord16) s600) << 8) | ((SWord16) s602);+  const SWord16 s604 = (SWord16) s596;+  const SWord8  s605 = (SWord8) (s604 >> 8);+  const SWord8  s606 = table2[s605];+  const SWord8  s607 = (SWord8) s604;+  const SWord8  s608 = table2[s607];+  const SWord16 s609 = (((SWord16) s606) << 8) | ((SWord16) s608);+  const SWord32 s610 = (((SWord32) s603) << 16) | ((SWord32) s609);+  const SWord32 s611 = s592 ^ s610;+  const SWord32 s612 = s593 ^ s611;+  const SWord32 s613 = s594 ^ s612;+  const SWord32 s614 = s595 ^ s613;+  const SWord32 s615 = (s614 << 8) | (s614 >> 24);+  const SWord16 s616 = (SWord16) (s615 >> 16);+  const SWord8  s617 = (SWord8) (s616 >> 8);+  const SWord8  s618 = table2[s617];+  const SWord8  s619 = 32 ^ s618;+  const SWord8  s620 = (SWord8) s616;+  const SWord8  s621 = table2[s620];+  const SWord16 s622 = (((SWord16) s619) << 8) | ((SWord16) s621);+  const SWord16 s623 = (SWord16) s615;+  const SWord8  s624 = (SWord8) (s623 >> 8);+  const SWord8  s625 = table2[s624];+  const SWord8  s626 = (SWord8) s623;+  const SWord8  s627 = table2[s626];+  const SWord16 s628 = (((SWord16) s625) << 8) | ((SWord16) s627);+  const SWord32 s629 = (((SWord32) s622) << 16) | ((SWord32) s628);+  const SWord32 s630 = s611 ^ s629;+  const SWord32 s631 = s612 ^ s630;+  const SWord32 s632 = s613 ^ s631;+  const SWord32 s633 = s614 ^ s632;+  const SWord32 s634 = (s633 << 8) | (s633 >> 24);+  const SWord16 s635 = (SWord16) (s634 >> 16);+  const SWord8  s636 = (SWord8) (s635 >> 8);+  const SWord8  s637 = table2[s636];+  const SWord8  s638 = 64 ^ s637;+  const SWord8  s639 = (SWord8) s635;+  const SWord8  s640 = table2[s639];+  const SWord16 s641 = (((SWord16) s638) << 8) | ((SWord16) s640);+  const SWord16 s642 = (SWord16) s634;+  const SWord8  s643 = (SWord8) (s642 >> 8);+  const SWord8  s644 = table2[s643];+  const SWord8  s645 = (SWord8) s642;+  const SWord8  s646 = table2[s645];+  const SWord16 s647 = (((SWord16) s644) << 8) | ((SWord16) s646);+  const SWord32 s648 = (((SWord32) s641) << 16) | ((SWord32) s647);+  const SWord32 s649 = s630 ^ s648;+  const SWord32 s650 = s631 ^ s649;+  const SWord32 s651 = s632 ^ s650;+  const SWord32 s652 = s633 ^ s651;+  const SWord32 s653 = (s652 << 8) | (s652 >> 24);+  const SWord16 s654 = (SWord16) (s653 >> 16);+  const SWord8  s655 = (SWord8) (s654 >> 8);+  const SWord8  s656 = table2[s655];+  const SWord8  s657 = 128 ^ s656;+  const SWord8  s658 = (SWord8) s654;+  const SWord8  s659 = table2[s658];+  const SWord16 s660 = (((SWord16) s657) << 8) | ((SWord16) s659);+  const SWord16 s661 = (SWord16) s653;+  const SWord8  s662 = (SWord8) (s661 >> 8);+  const SWord8  s663 = table2[s662];+  const SWord8  s664 = (SWord8) s661;+  const SWord8  s665 = table2[s664];+  const SWord16 s666 = (((SWord16) s663) << 8) | ((SWord16) s665);+  const SWord32 s667 = (((SWord32) s660) << 16) | ((SWord32) s666);+  const SWord32 s668 = s649 ^ s667;+  const SWord32 s669 = s650 ^ s668;+  const SWord32 s670 = s651 ^ s669;+  const SWord32 s671 = s652 ^ s670;+  const SWord32 s672 = (s671 << 8) | (s671 >> 24);+  const SWord16 s673 = (SWord16) (s672 >> 16);+  const SWord8  s674 = (SWord8) (s673 >> 8);+  const SWord8  s675 = table2[s674];+  const SWord8  s676 = 27 ^ s675;+  const SWord8  s677 = (SWord8) s673;+  const SWord8  s678 = table2[s677];+  const SWord16 s679 = (((SWord16) s676) << 8) | ((SWord16) s678);+  const SWord16 s680 = (SWord16) s672;+  const SWord8  s681 = (SWord8) (s680 >> 8);+  const SWord8  s682 = table2[s681];+  const SWord8  s683 = (SWord8) s680;+  const SWord8  s684 = table2[s683];+  const SWord16 s685 = (((SWord16) s682) << 8) | ((SWord16) s684);+  const SWord32 s686 = (((SWord32) s679) << 16) | ((SWord32) s685);+  const SWord32 s687 = s668 ^ s686;+  const SWord32 s688 = s669 ^ s687;+  const SWord32 s689 = s670 ^ s688;+  const SWord32 s690 = s671 ^ s689;+  const SWord32 s691 = (s690 << 8) | (s690 >> 24);+  const SWord16 s692 = (SWord16) (s691 >> 16);+  const SWord8  s693 = (SWord8) (s692 >> 8);+  const SWord8  s694 = table2[s693];+  const SWord8  s695 = 54 ^ s694;+  const SWord8  s696 = (SWord8) s692;+  const SWord8  s697 = table2[s696];+  const SWord16 s698 = (((SWord16) s695) << 8) | ((SWord16) s697);+  const SWord16 s699 = (SWord16) s691;+  const SWord8  s700 = (SWord8) (s699 >> 8);+  const SWord8  s701 = table2[s700];+  const SWord8  s702 = (SWord8) s699;+  const SWord8  s703 = table2[s702];+  const SWord16 s704 = (((SWord16) s701) << 8) | ((SWord16) s703);+  const SWord32 s705 = (((SWord32) s698) << 16) | ((SWord32) s704);+  const SWord32 s706 = s687 ^ s705;+  const SWord32 s707 = s0 ^ s706;+  const SWord16 s708 = (SWord16) (s707 >> 16);+  const SWord8  s709 = (SWord8) (s708 >> 8);+  const SWord32 s710 = table1[s709];+  const SWord32 s966 = s688 ^ s706;+  const SWord32 s967 = s689 ^ s966;+  const SWord32 s968 = s690 ^ s967;+  const SWord32 s969 = s3 ^ s968;+  const SWord16 s970 = (SWord16) (s969 >> 16);+  const SWord8  s971 = (SWord8) s970;+  const SWord32 s972 = table3[s971];+  const SWord32 s973 = s710 ^ s972;+  const SWord32 s1229 = s2 ^ s967;+  const SWord16 s1230 = (SWord16) s1229;+  const SWord8  s1231 = (SWord8) (s1230 >> 8);+  const SWord32 s1232 = table4[s1231];+  const SWord32 s1233 = s973 ^ s1232;+  const SWord32 s1489 = s1 ^ s966;+  const SWord16 s1490 = (SWord16) s1489;+  const SWord8  s1491 = (SWord8) s1490;+  const SWord32 s1492 = table5[s1491];+  const SWord32 s1493 = s1233 ^ s1492;+  const SWord16 s1494 = (SWord16) (s687 >> 16);+  const SWord8  s1495 = (SWord8) (s1494 >> 8);+  const SWord8  s1496 = table6[s1495];+  const SWord8  s1497 = (SWord8) s1494;+  const SWord8  s1498 = table7[s1497];+  const SWord16 s1499 = (SWord16) s687;+  const SWord8  s1500 = (SWord8) (s1499 >> 8);+  const SWord8  s1501 = table8[s1500];+  const SWord8  s1502 = (SWord8) s1499;+  const SWord8  s1503 = table9[s1502];+  const SWord8  s1504 = s1501 ^ s1503;+  const SWord8  s1505 = s1498 ^ s1504;+  const SWord8  s1506 = s1496 ^ s1505;+  const SWord8  s1507 = table9[s1495];+  const SWord8  s1508 = table6[s1497];+  const SWord8  s1509 = table7[s1500];+  const SWord8  s1510 = table8[s1502];+  const SWord8  s1511 = s1509 ^ s1510;+  const SWord8  s1512 = s1508 ^ s1511;+  const SWord8  s1513 = s1507 ^ s1512;+  const SWord16 s1514 = (((SWord16) s1506) << 8) | ((SWord16) s1513);+  const SWord8  s1515 = table8[s1495];+  const SWord8  s1516 = table9[s1497];+  const SWord8  s1517 = table6[s1500];+  const SWord8  s1518 = table7[s1502];+  const SWord8  s1519 = s1517 ^ s1518;+  const SWord8  s1520 = s1516 ^ s1519;+  const SWord8  s1521 = s1515 ^ s1520;+  const SWord8  s1522 = table7[s1495];+  const SWord8  s1523 = table8[s1497];+  const SWord8  s1524 = table9[s1500];+  const SWord8  s1525 = table6[s1502];+  const SWord8  s1526 = s1524 ^ s1525;+  const SWord8  s1527 = s1523 ^ s1526;+  const SWord8  s1528 = s1522 ^ s1527;+  const SWord16 s1529 = (((SWord16) s1521) << 8) | ((SWord16) s1528);+  const SWord32 s1530 = (((SWord32) s1514) << 16) | ((SWord32) s1529);+  const SWord32 s1531 = s1493 ^ s1530;+  const SWord16 s1532 = (SWord16) (s1531 >> 16);+  const SWord8  s1533 = (SWord8) (s1532 >> 8);+  const SWord32 s1534 = table1[s1533];+  const SWord8  s1535 = (SWord8) (s970 >> 8);+  const SWord32 s1536 = table1[s1535];+  const SWord16 s1537 = (SWord16) (s1229 >> 16);+  const SWord8  s1538 = (SWord8) s1537;+  const SWord32 s1539 = table3[s1538];+  const SWord32 s1540 = s1536 ^ s1539;+  const SWord8  s1541 = (SWord8) (s1490 >> 8);+  const SWord32 s1542 = table4[s1541];+  const SWord32 s1543 = s1540 ^ s1542;+  const SWord16 s1544 = (SWord16) s707;+  const SWord8  s1545 = (SWord8) s1544;+  const SWord32 s1546 = table5[s1545];+  const SWord32 s1547 = s1543 ^ s1546;+  const SWord16 s1548 = (SWord16) (s690 >> 16);+  const SWord8  s1549 = (SWord8) (s1548 >> 8);+  const SWord8  s1550 = table6[s1549];+  const SWord8  s1551 = (SWord8) s1548;+  const SWord8  s1552 = table7[s1551];+  const SWord16 s1553 = (SWord16) s690;+  const SWord8  s1554 = (SWord8) (s1553 >> 8);+  const SWord8  s1555 = table8[s1554];+  const SWord8  s1556 = (SWord8) s1553;+  const SWord8  s1557 = table9[s1556];+  const SWord8  s1558 = s1555 ^ s1557;+  const SWord8  s1559 = s1552 ^ s1558;+  const SWord8  s1560 = s1550 ^ s1559;+  const SWord8  s1561 = table9[s1549];+  const SWord8  s1562 = table6[s1551];+  const SWord8  s1563 = table7[s1554];+  const SWord8  s1564 = table8[s1556];+  const SWord8  s1565 = s1563 ^ s1564;+  const SWord8  s1566 = s1562 ^ s1565;+  const SWord8  s1567 = s1561 ^ s1566;+  const SWord16 s1568 = (((SWord16) s1560) << 8) | ((SWord16) s1567);+  const SWord8  s1569 = table8[s1549];+  const SWord8  s1570 = table9[s1551];+  const SWord8  s1571 = table6[s1554];+  const SWord8  s1572 = table7[s1556];+  const SWord8  s1573 = s1571 ^ s1572;+  const SWord8  s1574 = s1570 ^ s1573;+  const SWord8  s1575 = s1569 ^ s1574;+  const SWord8  s1576 = table7[s1549];+  const SWord8  s1577 = table8[s1551];+  const SWord8  s1578 = table9[s1554];+  const SWord8  s1579 = table6[s1556];+  const SWord8  s1580 = s1578 ^ s1579;+  const SWord8  s1581 = s1577 ^ s1580;+  const SWord8  s1582 = s1576 ^ s1581;+  const SWord16 s1583 = (((SWord16) s1575) << 8) | ((SWord16) s1582);+  const SWord32 s1584 = (((SWord32) s1568) << 16) | ((SWord32) s1583);+  const SWord32 s1585 = s1547 ^ s1584;+  const SWord16 s1586 = (SWord16) (s1585 >> 16);+  const SWord8  s1587 = (SWord8) s1586;+  const SWord32 s1588 = table3[s1587];+  const SWord32 s1589 = s1534 ^ s1588;+  const SWord8  s1590 = (SWord8) (s1537 >> 8);+  const SWord32 s1591 = table1[s1590];+  const SWord16 s1592 = (SWord16) (s1489 >> 16);+  const SWord8  s1593 = (SWord8) s1592;+  const SWord32 s1594 = table3[s1593];+  const SWord32 s1595 = s1591 ^ s1594;+  const SWord8  s1596 = (SWord8) (s1544 >> 8);+  const SWord32 s1597 = table4[s1596];+  const SWord32 s1598 = s1595 ^ s1597;+  const SWord16 s1599 = (SWord16) s969;+  const SWord8  s1600 = (SWord8) s1599;+  const SWord32 s1601 = table5[s1600];+  const SWord32 s1602 = s1598 ^ s1601;+  const SWord16 s1603 = (SWord16) (s689 >> 16);+  const SWord8  s1604 = (SWord8) (s1603 >> 8);+  const SWord8  s1605 = table6[s1604];+  const SWord8  s1606 = (SWord8) s1603;+  const SWord8  s1607 = table7[s1606];+  const SWord16 s1608 = (SWord16) s689;+  const SWord8  s1609 = (SWord8) (s1608 >> 8);+  const SWord8  s1610 = table8[s1609];+  const SWord8  s1611 = (SWord8) s1608;+  const SWord8  s1612 = table9[s1611];+  const SWord8  s1613 = s1610 ^ s1612;+  const SWord8  s1614 = s1607 ^ s1613;+  const SWord8  s1615 = s1605 ^ s1614;+  const SWord8  s1616 = table9[s1604];+  const SWord8  s1617 = table6[s1606];+  const SWord8  s1618 = table7[s1609];+  const SWord8  s1619 = table8[s1611];+  const SWord8  s1620 = s1618 ^ s1619;+  const SWord8  s1621 = s1617 ^ s1620;+  const SWord8  s1622 = s1616 ^ s1621;+  const SWord16 s1623 = (((SWord16) s1615) << 8) | ((SWord16) s1622);+  const SWord8  s1624 = table8[s1604];+  const SWord8  s1625 = table9[s1606];+  const SWord8  s1626 = table6[s1609];+  const SWord8  s1627 = table7[s1611];+  const SWord8  s1628 = s1626 ^ s1627;+  const SWord8  s1629 = s1625 ^ s1628;+  const SWord8  s1630 = s1624 ^ s1629;+  const SWord8  s1631 = table7[s1604];+  const SWord8  s1632 = table8[s1606];+  const SWord8  s1633 = table9[s1609];+  const SWord8  s1634 = table6[s1611];+  const SWord8  s1635 = s1633 ^ s1634;+  const SWord8  s1636 = s1632 ^ s1635;+  const SWord8  s1637 = s1631 ^ s1636;+  const SWord16 s1638 = (((SWord16) s1630) << 8) | ((SWord16) s1637);+  const SWord32 s1639 = (((SWord32) s1623) << 16) | ((SWord32) s1638);+  const SWord32 s1640 = s1602 ^ s1639;+  const SWord16 s1641 = (SWord16) s1640;+  const SWord8  s1642 = (SWord8) (s1641 >> 8);+  const SWord32 s1643 = table4[s1642];+  const SWord32 s1644 = s1589 ^ s1643;+  const SWord8  s1645 = (SWord8) (s1592 >> 8);+  const SWord32 s1646 = table1[s1645];+  const SWord8  s1647 = (SWord8) s708;+  const SWord32 s1648 = table3[s1647];+  const SWord32 s1649 = s1646 ^ s1648;+  const SWord8  s1650 = (SWord8) (s1599 >> 8);+  const SWord32 s1651 = table4[s1650];+  const SWord32 s1652 = s1649 ^ s1651;+  const SWord8  s1653 = (SWord8) s1230;+  const SWord32 s1654 = table5[s1653];+  const SWord32 s1655 = s1652 ^ s1654;+  const SWord16 s1656 = (SWord16) (s688 >> 16);+  const SWord8  s1657 = (SWord8) (s1656 >> 8);+  const SWord8  s1658 = table6[s1657];+  const SWord8  s1659 = (SWord8) s1656;+  const SWord8  s1660 = table7[s1659];+  const SWord16 s1661 = (SWord16) s688;+  const SWord8  s1662 = (SWord8) (s1661 >> 8);+  const SWord8  s1663 = table8[s1662];+  const SWord8  s1664 = (SWord8) s1661;+  const SWord8  s1665 = table9[s1664];+  const SWord8  s1666 = s1663 ^ s1665;+  const SWord8  s1667 = s1660 ^ s1666;+  const SWord8  s1668 = s1658 ^ s1667;+  const SWord8  s1669 = table9[s1657];+  const SWord8  s1670 = table6[s1659];+  const SWord8  s1671 = table7[s1662];+  const SWord8  s1672 = table8[s1664];+  const SWord8  s1673 = s1671 ^ s1672;+  const SWord8  s1674 = s1670 ^ s1673;+  const SWord8  s1675 = s1669 ^ s1674;+  const SWord16 s1676 = (((SWord16) s1668) << 8) | ((SWord16) s1675);+  const SWord8  s1677 = table8[s1657];+  const SWord8  s1678 = table9[s1659];+  const SWord8  s1679 = table6[s1662];+  const SWord8  s1680 = table7[s1664];+  const SWord8  s1681 = s1679 ^ s1680;+  const SWord8  s1682 = s1678 ^ s1681;+  const SWord8  s1683 = s1677 ^ s1682;+  const SWord8  s1684 = table7[s1657];+  const SWord8  s1685 = table8[s1659];+  const SWord8  s1686 = table9[s1662];+  const SWord8  s1687 = table6[s1664];+  const SWord8  s1688 = s1686 ^ s1687;+  const SWord8  s1689 = s1685 ^ s1688;+  const SWord8  s1690 = s1684 ^ s1689;+  const SWord16 s1691 = (((SWord16) s1683) << 8) | ((SWord16) s1690);+  const SWord32 s1692 = (((SWord32) s1676) << 16) | ((SWord32) s1691);+  const SWord32 s1693 = s1655 ^ s1692;+  const SWord16 s1694 = (SWord16) s1693;+  const SWord8  s1695 = (SWord8) s1694;+  const SWord32 s1696 = table5[s1695];+  const SWord32 s1697 = s1644 ^ s1696;+  const SWord16 s1698 = (SWord16) (s668 >> 16);+  const SWord8  s1699 = (SWord8) (s1698 >> 8);+  const SWord8  s1700 = table6[s1699];+  const SWord8  s1701 = (SWord8) s1698;+  const SWord8  s1702 = table7[s1701];+  const SWord16 s1703 = (SWord16) s668;+  const SWord8  s1704 = (SWord8) (s1703 >> 8);+  const SWord8  s1705 = table8[s1704];+  const SWord8  s1706 = (SWord8) s1703;+  const SWord8  s1707 = table9[s1706];+  const SWord8  s1708 = s1705 ^ s1707;+  const SWord8  s1709 = s1702 ^ s1708;+  const SWord8  s1710 = s1700 ^ s1709;+  const SWord8  s1711 = table9[s1699];+  const SWord8  s1712 = table6[s1701];+  const SWord8  s1713 = table7[s1704];+  const SWord8  s1714 = table8[s1706];+  const SWord8  s1715 = s1713 ^ s1714;+  const SWord8  s1716 = s1712 ^ s1715;+  const SWord8  s1717 = s1711 ^ s1716;+  const SWord16 s1718 = (((SWord16) s1710) << 8) | ((SWord16) s1717);+  const SWord8  s1719 = table8[s1699];+  const SWord8  s1720 = table9[s1701];+  const SWord8  s1721 = table6[s1704];+  const SWord8  s1722 = table7[s1706];+  const SWord8  s1723 = s1721 ^ s1722;+  const SWord8  s1724 = s1720 ^ s1723;+  const SWord8  s1725 = s1719 ^ s1724;+  const SWord8  s1726 = table7[s1699];+  const SWord8  s1727 = table8[s1701];+  const SWord8  s1728 = table9[s1704];+  const SWord8  s1729 = table6[s1706];+  const SWord8  s1730 = s1728 ^ s1729;+  const SWord8  s1731 = s1727 ^ s1730;+  const SWord8  s1732 = s1726 ^ s1731;+  const SWord16 s1733 = (((SWord16) s1725) << 8) | ((SWord16) s1732);+  const SWord32 s1734 = (((SWord32) s1718) << 16) | ((SWord32) s1733);+  const SWord32 s1735 = s1697 ^ s1734;+  const SWord16 s1736 = (SWord16) (s1735 >> 16);+  const SWord8  s1737 = (SWord8) (s1736 >> 8);+  const SWord32 s1738 = table1[s1737];+  const SWord8  s1739 = (SWord8) (s1586 >> 8);+  const SWord32 s1740 = table1[s1739];+  const SWord16 s1741 = (SWord16) (s1640 >> 16);+  const SWord8  s1742 = (SWord8) s1741;+  const SWord32 s1743 = table3[s1742];+  const SWord32 s1744 = s1740 ^ s1743;+  const SWord8  s1745 = (SWord8) (s1694 >> 8);+  const SWord32 s1746 = table4[s1745];+  const SWord32 s1747 = s1744 ^ s1746;+  const SWord16 s1748 = (SWord16) s1531;+  const SWord8  s1749 = (SWord8) s1748;+  const SWord32 s1750 = table5[s1749];+  const SWord32 s1751 = s1747 ^ s1750;+  const SWord16 s1752 = (SWord16) (s671 >> 16);+  const SWord8  s1753 = (SWord8) (s1752 >> 8);+  const SWord8  s1754 = table6[s1753];+  const SWord8  s1755 = (SWord8) s1752;+  const SWord8  s1756 = table7[s1755];+  const SWord16 s1757 = (SWord16) s671;+  const SWord8  s1758 = (SWord8) (s1757 >> 8);+  const SWord8  s1759 = table8[s1758];+  const SWord8  s1760 = (SWord8) s1757;+  const SWord8  s1761 = table9[s1760];+  const SWord8  s1762 = s1759 ^ s1761;+  const SWord8  s1763 = s1756 ^ s1762;+  const SWord8  s1764 = s1754 ^ s1763;+  const SWord8  s1765 = table9[s1753];+  const SWord8  s1766 = table6[s1755];+  const SWord8  s1767 = table7[s1758];+  const SWord8  s1768 = table8[s1760];+  const SWord8  s1769 = s1767 ^ s1768;+  const SWord8  s1770 = s1766 ^ s1769;+  const SWord8  s1771 = s1765 ^ s1770;+  const SWord16 s1772 = (((SWord16) s1764) << 8) | ((SWord16) s1771);+  const SWord8  s1773 = table8[s1753];+  const SWord8  s1774 = table9[s1755];+  const SWord8  s1775 = table6[s1758];+  const SWord8  s1776 = table7[s1760];+  const SWord8  s1777 = s1775 ^ s1776;+  const SWord8  s1778 = s1774 ^ s1777;+  const SWord8  s1779 = s1773 ^ s1778;+  const SWord8  s1780 = table7[s1753];+  const SWord8  s1781 = table8[s1755];+  const SWord8  s1782 = table9[s1758];+  const SWord8  s1783 = table6[s1760];+  const SWord8  s1784 = s1782 ^ s1783;+  const SWord8  s1785 = s1781 ^ s1784;+  const SWord8  s1786 = s1780 ^ s1785;+  const SWord16 s1787 = (((SWord16) s1779) << 8) | ((SWord16) s1786);+  const SWord32 s1788 = (((SWord32) s1772) << 16) | ((SWord32) s1787);+  const SWord32 s1789 = s1751 ^ s1788;+  const SWord16 s1790 = (SWord16) (s1789 >> 16);+  const SWord8  s1791 = (SWord8) s1790;+  const SWord32 s1792 = table3[s1791];+  const SWord32 s1793 = s1738 ^ s1792;+  const SWord8  s1794 = (SWord8) (s1741 >> 8);+  const SWord32 s1795 = table1[s1794];+  const SWord16 s1796 = (SWord16) (s1693 >> 16);+  const SWord8  s1797 = (SWord8) s1796;+  const SWord32 s1798 = table3[s1797];+  const SWord32 s1799 = s1795 ^ s1798;+  const SWord8  s1800 = (SWord8) (s1748 >> 8);+  const SWord32 s1801 = table4[s1800];+  const SWord32 s1802 = s1799 ^ s1801;+  const SWord16 s1803 = (SWord16) s1585;+  const SWord8  s1804 = (SWord8) s1803;+  const SWord32 s1805 = table5[s1804];+  const SWord32 s1806 = s1802 ^ s1805;+  const SWord16 s1807 = (SWord16) (s670 >> 16);+  const SWord8  s1808 = (SWord8) (s1807 >> 8);+  const SWord8  s1809 = table6[s1808];+  const SWord8  s1810 = (SWord8) s1807;+  const SWord8  s1811 = table7[s1810];+  const SWord16 s1812 = (SWord16) s670;+  const SWord8  s1813 = (SWord8) (s1812 >> 8);+  const SWord8  s1814 = table8[s1813];+  const SWord8  s1815 = (SWord8) s1812;+  const SWord8  s1816 = table9[s1815];+  const SWord8  s1817 = s1814 ^ s1816;+  const SWord8  s1818 = s1811 ^ s1817;+  const SWord8  s1819 = s1809 ^ s1818;+  const SWord8  s1820 = table9[s1808];+  const SWord8  s1821 = table6[s1810];+  const SWord8  s1822 = table7[s1813];+  const SWord8  s1823 = table8[s1815];+  const SWord8  s1824 = s1822 ^ s1823;+  const SWord8  s1825 = s1821 ^ s1824;+  const SWord8  s1826 = s1820 ^ s1825;+  const SWord16 s1827 = (((SWord16) s1819) << 8) | ((SWord16) s1826);+  const SWord8  s1828 = table8[s1808];+  const SWord8  s1829 = table9[s1810];+  const SWord8  s1830 = table6[s1813];+  const SWord8  s1831 = table7[s1815];+  const SWord8  s1832 = s1830 ^ s1831;+  const SWord8  s1833 = s1829 ^ s1832;+  const SWord8  s1834 = s1828 ^ s1833;+  const SWord8  s1835 = table7[s1808];+  const SWord8  s1836 = table8[s1810];+  const SWord8  s1837 = table9[s1813];+  const SWord8  s1838 = table6[s1815];+  const SWord8  s1839 = s1837 ^ s1838;+  const SWord8  s1840 = s1836 ^ s1839;+  const SWord8  s1841 = s1835 ^ s1840;+  const SWord16 s1842 = (((SWord16) s1834) << 8) | ((SWord16) s1841);+  const SWord32 s1843 = (((SWord32) s1827) << 16) | ((SWord32) s1842);+  const SWord32 s1844 = s1806 ^ s1843;+  const SWord16 s1845 = (SWord16) s1844;+  const SWord8  s1846 = (SWord8) (s1845 >> 8);+  const SWord32 s1847 = table4[s1846];+  const SWord32 s1848 = s1793 ^ s1847;+  const SWord8  s1849 = (SWord8) (s1796 >> 8);+  const SWord32 s1850 = table1[s1849];+  const SWord8  s1851 = (SWord8) s1532;+  const SWord32 s1852 = table3[s1851];+  const SWord32 s1853 = s1850 ^ s1852;+  const SWord8  s1854 = (SWord8) (s1803 >> 8);+  const SWord32 s1855 = table4[s1854];+  const SWord32 s1856 = s1853 ^ s1855;+  const SWord8  s1857 = (SWord8) s1641;+  const SWord32 s1858 = table5[s1857];+  const SWord32 s1859 = s1856 ^ s1858;+  const SWord16 s1860 = (SWord16) (s669 >> 16);+  const SWord8  s1861 = (SWord8) (s1860 >> 8);+  const SWord8  s1862 = table6[s1861];+  const SWord8  s1863 = (SWord8) s1860;+  const SWord8  s1864 = table7[s1863];+  const SWord16 s1865 = (SWord16) s669;+  const SWord8  s1866 = (SWord8) (s1865 >> 8);+  const SWord8  s1867 = table8[s1866];+  const SWord8  s1868 = (SWord8) s1865;+  const SWord8  s1869 = table9[s1868];+  const SWord8  s1870 = s1867 ^ s1869;+  const SWord8  s1871 = s1864 ^ s1870;+  const SWord8  s1872 = s1862 ^ s1871;+  const SWord8  s1873 = table9[s1861];+  const SWord8  s1874 = table6[s1863];+  const SWord8  s1875 = table7[s1866];+  const SWord8  s1876 = table8[s1868];+  const SWord8  s1877 = s1875 ^ s1876;+  const SWord8  s1878 = s1874 ^ s1877;+  const SWord8  s1879 = s1873 ^ s1878;+  const SWord16 s1880 = (((SWord16) s1872) << 8) | ((SWord16) s1879);+  const SWord8  s1881 = table8[s1861];+  const SWord8  s1882 = table9[s1863];+  const SWord8  s1883 = table6[s1866];+  const SWord8  s1884 = table7[s1868];+  const SWord8  s1885 = s1883 ^ s1884;+  const SWord8  s1886 = s1882 ^ s1885;+  const SWord8  s1887 = s1881 ^ s1886;+  const SWord8  s1888 = table7[s1861];+  const SWord8  s1889 = table8[s1863];+  const SWord8  s1890 = table9[s1866];+  const SWord8  s1891 = table6[s1868];+  const SWord8  s1892 = s1890 ^ s1891;+  const SWord8  s1893 = s1889 ^ s1892;+  const SWord8  s1894 = s1888 ^ s1893;+  const SWord16 s1895 = (((SWord16) s1887) << 8) | ((SWord16) s1894);+  const SWord32 s1896 = (((SWord32) s1880) << 16) | ((SWord32) s1895);+  const SWord32 s1897 = s1859 ^ s1896;+  const SWord16 s1898 = (SWord16) s1897;+  const SWord8  s1899 = (SWord8) s1898;+  const SWord32 s1900 = table5[s1899];+  const SWord32 s1901 = s1848 ^ s1900;+  const SWord16 s1902 = (SWord16) (s649 >> 16);+  const SWord8  s1903 = (SWord8) (s1902 >> 8);+  const SWord8  s1904 = table6[s1903];+  const SWord8  s1905 = (SWord8) s1902;+  const SWord8  s1906 = table7[s1905];+  const SWord16 s1907 = (SWord16) s649;+  const SWord8  s1908 = (SWord8) (s1907 >> 8);+  const SWord8  s1909 = table8[s1908];+  const SWord8  s1910 = (SWord8) s1907;+  const SWord8  s1911 = table9[s1910];+  const SWord8  s1912 = s1909 ^ s1911;+  const SWord8  s1913 = s1906 ^ s1912;+  const SWord8  s1914 = s1904 ^ s1913;+  const SWord8  s1915 = table9[s1903];+  const SWord8  s1916 = table6[s1905];+  const SWord8  s1917 = table7[s1908];+  const SWord8  s1918 = table8[s1910];+  const SWord8  s1919 = s1917 ^ s1918;+  const SWord8  s1920 = s1916 ^ s1919;+  const SWord8  s1921 = s1915 ^ s1920;+  const SWord16 s1922 = (((SWord16) s1914) << 8) | ((SWord16) s1921);+  const SWord8  s1923 = table8[s1903];+  const SWord8  s1924 = table9[s1905];+  const SWord8  s1925 = table6[s1908];+  const SWord8  s1926 = table7[s1910];+  const SWord8  s1927 = s1925 ^ s1926;+  const SWord8  s1928 = s1924 ^ s1927;+  const SWord8  s1929 = s1923 ^ s1928;+  const SWord8  s1930 = table7[s1903];+  const SWord8  s1931 = table8[s1905];+  const SWord8  s1932 = table9[s1908];+  const SWord8  s1933 = table6[s1910];+  const SWord8  s1934 = s1932 ^ s1933;+  const SWord8  s1935 = s1931 ^ s1934;+  const SWord8  s1936 = s1930 ^ s1935;+  const SWord16 s1937 = (((SWord16) s1929) << 8) | ((SWord16) s1936);+  const SWord32 s1938 = (((SWord32) s1922) << 16) | ((SWord32) s1937);+  const SWord32 s1939 = s1901 ^ s1938;+  const SWord16 s1940 = (SWord16) (s1939 >> 16);+  const SWord8  s1941 = (SWord8) (s1940 >> 8);+  const SWord32 s1942 = table1[s1941];+  const SWord8  s1943 = (SWord8) (s1790 >> 8);+  const SWord32 s1944 = table1[s1943];+  const SWord16 s1945 = (SWord16) (s1844 >> 16);+  const SWord8  s1946 = (SWord8) s1945;+  const SWord32 s1947 = table3[s1946];+  const SWord32 s1948 = s1944 ^ s1947;+  const SWord8  s1949 = (SWord8) (s1898 >> 8);+  const SWord32 s1950 = table4[s1949];+  const SWord32 s1951 = s1948 ^ s1950;+  const SWord16 s1952 = (SWord16) s1735;+  const SWord8  s1953 = (SWord8) s1952;+  const SWord32 s1954 = table5[s1953];+  const SWord32 s1955 = s1951 ^ s1954;+  const SWord16 s1956 = (SWord16) (s652 >> 16);+  const SWord8  s1957 = (SWord8) (s1956 >> 8);+  const SWord8  s1958 = table6[s1957];+  const SWord8  s1959 = (SWord8) s1956;+  const SWord8  s1960 = table7[s1959];+  const SWord16 s1961 = (SWord16) s652;+  const SWord8  s1962 = (SWord8) (s1961 >> 8);+  const SWord8  s1963 = table8[s1962];+  const SWord8  s1964 = (SWord8) s1961;+  const SWord8  s1965 = table9[s1964];+  const SWord8  s1966 = s1963 ^ s1965;+  const SWord8  s1967 = s1960 ^ s1966;+  const SWord8  s1968 = s1958 ^ s1967;+  const SWord8  s1969 = table9[s1957];+  const SWord8  s1970 = table6[s1959];+  const SWord8  s1971 = table7[s1962];+  const SWord8  s1972 = table8[s1964];+  const SWord8  s1973 = s1971 ^ s1972;+  const SWord8  s1974 = s1970 ^ s1973;+  const SWord8  s1975 = s1969 ^ s1974;+  const SWord16 s1976 = (((SWord16) s1968) << 8) | ((SWord16) s1975);+  const SWord8  s1977 = table8[s1957];+  const SWord8  s1978 = table9[s1959];+  const SWord8  s1979 = table6[s1962];+  const SWord8  s1980 = table7[s1964];+  const SWord8  s1981 = s1979 ^ s1980;+  const SWord8  s1982 = s1978 ^ s1981;+  const SWord8  s1983 = s1977 ^ s1982;+  const SWord8  s1984 = table7[s1957];+  const SWord8  s1985 = table8[s1959];+  const SWord8  s1986 = table9[s1962];+  const SWord8  s1987 = table6[s1964];+  const SWord8  s1988 = s1986 ^ s1987;+  const SWord8  s1989 = s1985 ^ s1988;+  const SWord8  s1990 = s1984 ^ s1989;+  const SWord16 s1991 = (((SWord16) s1983) << 8) | ((SWord16) s1990);+  const SWord32 s1992 = (((SWord32) s1976) << 16) | ((SWord32) s1991);+  const SWord32 s1993 = s1955 ^ s1992;+  const SWord16 s1994 = (SWord16) (s1993 >> 16);+  const SWord8  s1995 = (SWord8) s1994;+  const SWord32 s1996 = table3[s1995];+  const SWord32 s1997 = s1942 ^ s1996;+  const SWord8  s1998 = (SWord8) (s1945 >> 8);+  const SWord32 s1999 = table1[s1998];+  const SWord16 s2000 = (SWord16) (s1897 >> 16);+  const SWord8  s2001 = (SWord8) s2000;+  const SWord32 s2002 = table3[s2001];+  const SWord32 s2003 = s1999 ^ s2002;+  const SWord8  s2004 = (SWord8) (s1952 >> 8);+  const SWord32 s2005 = table4[s2004];+  const SWord32 s2006 = s2003 ^ s2005;+  const SWord16 s2007 = (SWord16) s1789;+  const SWord8  s2008 = (SWord8) s2007;+  const SWord32 s2009 = table5[s2008];+  const SWord32 s2010 = s2006 ^ s2009;+  const SWord16 s2011 = (SWord16) (s651 >> 16);+  const SWord8  s2012 = (SWord8) (s2011 >> 8);+  const SWord8  s2013 = table6[s2012];+  const SWord8  s2014 = (SWord8) s2011;+  const SWord8  s2015 = table7[s2014];+  const SWord16 s2016 = (SWord16) s651;+  const SWord8  s2017 = (SWord8) (s2016 >> 8);+  const SWord8  s2018 = table8[s2017];+  const SWord8  s2019 = (SWord8) s2016;+  const SWord8  s2020 = table9[s2019];+  const SWord8  s2021 = s2018 ^ s2020;+  const SWord8  s2022 = s2015 ^ s2021;+  const SWord8  s2023 = s2013 ^ s2022;+  const SWord8  s2024 = table9[s2012];+  const SWord8  s2025 = table6[s2014];+  const SWord8  s2026 = table7[s2017];+  const SWord8  s2027 = table8[s2019];+  const SWord8  s2028 = s2026 ^ s2027;+  const SWord8  s2029 = s2025 ^ s2028;+  const SWord8  s2030 = s2024 ^ s2029;+  const SWord16 s2031 = (((SWord16) s2023) << 8) | ((SWord16) s2030);+  const SWord8  s2032 = table8[s2012];+  const SWord8  s2033 = table9[s2014];+  const SWord8  s2034 = table6[s2017];+  const SWord8  s2035 = table7[s2019];+  const SWord8  s2036 = s2034 ^ s2035;+  const SWord8  s2037 = s2033 ^ s2036;+  const SWord8  s2038 = s2032 ^ s2037;+  const SWord8  s2039 = table7[s2012];+  const SWord8  s2040 = table8[s2014];+  const SWord8  s2041 = table9[s2017];+  const SWord8  s2042 = table6[s2019];+  const SWord8  s2043 = s2041 ^ s2042;+  const SWord8  s2044 = s2040 ^ s2043;+  const SWord8  s2045 = s2039 ^ s2044;+  const SWord16 s2046 = (((SWord16) s2038) << 8) | ((SWord16) s2045);+  const SWord32 s2047 = (((SWord32) s2031) << 16) | ((SWord32) s2046);+  const SWord32 s2048 = s2010 ^ s2047;+  const SWord16 s2049 = (SWord16) s2048;+  const SWord8  s2050 = (SWord8) (s2049 >> 8);+  const SWord32 s2051 = table4[s2050];+  const SWord32 s2052 = s1997 ^ s2051;+  const SWord8  s2053 = (SWord8) (s2000 >> 8);+  const SWord32 s2054 = table1[s2053];+  const SWord8  s2055 = (SWord8) s1736;+  const SWord32 s2056 = table3[s2055];+  const SWord32 s2057 = s2054 ^ s2056;+  const SWord8  s2058 = (SWord8) (s2007 >> 8);+  const SWord32 s2059 = table4[s2058];+  const SWord32 s2060 = s2057 ^ s2059;+  const SWord8  s2061 = (SWord8) s1845;+  const SWord32 s2062 = table5[s2061];+  const SWord32 s2063 = s2060 ^ s2062;+  const SWord16 s2064 = (SWord16) (s650 >> 16);+  const SWord8  s2065 = (SWord8) (s2064 >> 8);+  const SWord8  s2066 = table6[s2065];+  const SWord8  s2067 = (SWord8) s2064;+  const SWord8  s2068 = table7[s2067];+  const SWord16 s2069 = (SWord16) s650;+  const SWord8  s2070 = (SWord8) (s2069 >> 8);+  const SWord8  s2071 = table8[s2070];+  const SWord8  s2072 = (SWord8) s2069;+  const SWord8  s2073 = table9[s2072];+  const SWord8  s2074 = s2071 ^ s2073;+  const SWord8  s2075 = s2068 ^ s2074;+  const SWord8  s2076 = s2066 ^ s2075;+  const SWord8  s2077 = table9[s2065];+  const SWord8  s2078 = table6[s2067];+  const SWord8  s2079 = table7[s2070];+  const SWord8  s2080 = table8[s2072];+  const SWord8  s2081 = s2079 ^ s2080;+  const SWord8  s2082 = s2078 ^ s2081;+  const SWord8  s2083 = s2077 ^ s2082;+  const SWord16 s2084 = (((SWord16) s2076) << 8) | ((SWord16) s2083);+  const SWord8  s2085 = table8[s2065];+  const SWord8  s2086 = table9[s2067];+  const SWord8  s2087 = table6[s2070];+  const SWord8  s2088 = table7[s2072];+  const SWord8  s2089 = s2087 ^ s2088;+  const SWord8  s2090 = s2086 ^ s2089;+  const SWord8  s2091 = s2085 ^ s2090;+  const SWord8  s2092 = table7[s2065];+  const SWord8  s2093 = table8[s2067];+  const SWord8  s2094 = table9[s2070];+  const SWord8  s2095 = table6[s2072];+  const SWord8  s2096 = s2094 ^ s2095;+  const SWord8  s2097 = s2093 ^ s2096;+  const SWord8  s2098 = s2092 ^ s2097;+  const SWord16 s2099 = (((SWord16) s2091) << 8) | ((SWord16) s2098);+  const SWord32 s2100 = (((SWord32) s2084) << 16) | ((SWord32) s2099);+  const SWord32 s2101 = s2063 ^ s2100;+  const SWord16 s2102 = (SWord16) s2101;+  const SWord8  s2103 = (SWord8) s2102;+  const SWord32 s2104 = table5[s2103];+  const SWord32 s2105 = s2052 ^ s2104;+  const SWord16 s2106 = (SWord16) (s630 >> 16);+  const SWord8  s2107 = (SWord8) (s2106 >> 8);+  const SWord8  s2108 = table6[s2107];+  const SWord8  s2109 = (SWord8) s2106;+  const SWord8  s2110 = table7[s2109];+  const SWord16 s2111 = (SWord16) s630;+  const SWord8  s2112 = (SWord8) (s2111 >> 8);+  const SWord8  s2113 = table8[s2112];+  const SWord8  s2114 = (SWord8) s2111;+  const SWord8  s2115 = table9[s2114];+  const SWord8  s2116 = s2113 ^ s2115;+  const SWord8  s2117 = s2110 ^ s2116;+  const SWord8  s2118 = s2108 ^ s2117;+  const SWord8  s2119 = table9[s2107];+  const SWord8  s2120 = table6[s2109];+  const SWord8  s2121 = table7[s2112];+  const SWord8  s2122 = table8[s2114];+  const SWord8  s2123 = s2121 ^ s2122;+  const SWord8  s2124 = s2120 ^ s2123;+  const SWord8  s2125 = s2119 ^ s2124;+  const SWord16 s2126 = (((SWord16) s2118) << 8) | ((SWord16) s2125);+  const SWord8  s2127 = table8[s2107];+  const SWord8  s2128 = table9[s2109];+  const SWord8  s2129 = table6[s2112];+  const SWord8  s2130 = table7[s2114];+  const SWord8  s2131 = s2129 ^ s2130;+  const SWord8  s2132 = s2128 ^ s2131;+  const SWord8  s2133 = s2127 ^ s2132;+  const SWord8  s2134 = table7[s2107];+  const SWord8  s2135 = table8[s2109];+  const SWord8  s2136 = table9[s2112];+  const SWord8  s2137 = table6[s2114];+  const SWord8  s2138 = s2136 ^ s2137;+  const SWord8  s2139 = s2135 ^ s2138;+  const SWord8  s2140 = s2134 ^ s2139;+  const SWord16 s2141 = (((SWord16) s2133) << 8) | ((SWord16) s2140);+  const SWord32 s2142 = (((SWord32) s2126) << 16) | ((SWord32) s2141);+  const SWord32 s2143 = s2105 ^ s2142;+  const SWord16 s2144 = (SWord16) (s2143 >> 16);+  const SWord8  s2145 = (SWord8) (s2144 >> 8);+  const SWord32 s2146 = table1[s2145];+  const SWord8  s2147 = (SWord8) (s1994 >> 8);+  const SWord32 s2148 = table1[s2147];+  const SWord16 s2149 = (SWord16) (s2048 >> 16);+  const SWord8  s2150 = (SWord8) s2149;+  const SWord32 s2151 = table3[s2150];+  const SWord32 s2152 = s2148 ^ s2151;+  const SWord8  s2153 = (SWord8) (s2102 >> 8);+  const SWord32 s2154 = table4[s2153];+  const SWord32 s2155 = s2152 ^ s2154;+  const SWord16 s2156 = (SWord16) s1939;+  const SWord8  s2157 = (SWord8) s2156;+  const SWord32 s2158 = table5[s2157];+  const SWord32 s2159 = s2155 ^ s2158;+  const SWord16 s2160 = (SWord16) (s633 >> 16);+  const SWord8  s2161 = (SWord8) (s2160 >> 8);+  const SWord8  s2162 = table6[s2161];+  const SWord8  s2163 = (SWord8) s2160;+  const SWord8  s2164 = table7[s2163];+  const SWord16 s2165 = (SWord16) s633;+  const SWord8  s2166 = (SWord8) (s2165 >> 8);+  const SWord8  s2167 = table8[s2166];+  const SWord8  s2168 = (SWord8) s2165;+  const SWord8  s2169 = table9[s2168];+  const SWord8  s2170 = s2167 ^ s2169;+  const SWord8  s2171 = s2164 ^ s2170;+  const SWord8  s2172 = s2162 ^ s2171;+  const SWord8  s2173 = table9[s2161];+  const SWord8  s2174 = table6[s2163];+  const SWord8  s2175 = table7[s2166];+  const SWord8  s2176 = table8[s2168];+  const SWord8  s2177 = s2175 ^ s2176;+  const SWord8  s2178 = s2174 ^ s2177;+  const SWord8  s2179 = s2173 ^ s2178;+  const SWord16 s2180 = (((SWord16) s2172) << 8) | ((SWord16) s2179);+  const SWord8  s2181 = table8[s2161];+  const SWord8  s2182 = table9[s2163];+  const SWord8  s2183 = table6[s2166];+  const SWord8  s2184 = table7[s2168];+  const SWord8  s2185 = s2183 ^ s2184;+  const SWord8  s2186 = s2182 ^ s2185;+  const SWord8  s2187 = s2181 ^ s2186;+  const SWord8  s2188 = table7[s2161];+  const SWord8  s2189 = table8[s2163];+  const SWord8  s2190 = table9[s2166];+  const SWord8  s2191 = table6[s2168];+  const SWord8  s2192 = s2190 ^ s2191;+  const SWord8  s2193 = s2189 ^ s2192;+  const SWord8  s2194 = s2188 ^ s2193;+  const SWord16 s2195 = (((SWord16) s2187) << 8) | ((SWord16) s2194);+  const SWord32 s2196 = (((SWord32) s2180) << 16) | ((SWord32) s2195);+  const SWord32 s2197 = s2159 ^ s2196;+  const SWord16 s2198 = (SWord16) (s2197 >> 16);+  const SWord8  s2199 = (SWord8) s2198;+  const SWord32 s2200 = table3[s2199];+  const SWord32 s2201 = s2146 ^ s2200;+  const SWord8  s2202 = (SWord8) (s2149 >> 8);+  const SWord32 s2203 = table1[s2202];+  const SWord16 s2204 = (SWord16) (s2101 >> 16);+  const SWord8  s2205 = (SWord8) s2204;+  const SWord32 s2206 = table3[s2205];+  const SWord32 s2207 = s2203 ^ s2206;+  const SWord8  s2208 = (SWord8) (s2156 >> 8);+  const SWord32 s2209 = table4[s2208];+  const SWord32 s2210 = s2207 ^ s2209;+  const SWord16 s2211 = (SWord16) s1993;+  const SWord8  s2212 = (SWord8) s2211;+  const SWord32 s2213 = table5[s2212];+  const SWord32 s2214 = s2210 ^ s2213;+  const SWord16 s2215 = (SWord16) (s632 >> 16);+  const SWord8  s2216 = (SWord8) (s2215 >> 8);+  const SWord8  s2217 = table6[s2216];+  const SWord8  s2218 = (SWord8) s2215;+  const SWord8  s2219 = table7[s2218];+  const SWord16 s2220 = (SWord16) s632;+  const SWord8  s2221 = (SWord8) (s2220 >> 8);+  const SWord8  s2222 = table8[s2221];+  const SWord8  s2223 = (SWord8) s2220;+  const SWord8  s2224 = table9[s2223];+  const SWord8  s2225 = s2222 ^ s2224;+  const SWord8  s2226 = s2219 ^ s2225;+  const SWord8  s2227 = s2217 ^ s2226;+  const SWord8  s2228 = table9[s2216];+  const SWord8  s2229 = table6[s2218];+  const SWord8  s2230 = table7[s2221];+  const SWord8  s2231 = table8[s2223];+  const SWord8  s2232 = s2230 ^ s2231;+  const SWord8  s2233 = s2229 ^ s2232;+  const SWord8  s2234 = s2228 ^ s2233;+  const SWord16 s2235 = (((SWord16) s2227) << 8) | ((SWord16) s2234);+  const SWord8  s2236 = table8[s2216];+  const SWord8  s2237 = table9[s2218];+  const SWord8  s2238 = table6[s2221];+  const SWord8  s2239 = table7[s2223];+  const SWord8  s2240 = s2238 ^ s2239;+  const SWord8  s2241 = s2237 ^ s2240;+  const SWord8  s2242 = s2236 ^ s2241;+  const SWord8  s2243 = table7[s2216];+  const SWord8  s2244 = table8[s2218];+  const SWord8  s2245 = table9[s2221];+  const SWord8  s2246 = table6[s2223];+  const SWord8  s2247 = s2245 ^ s2246;+  const SWord8  s2248 = s2244 ^ s2247;+  const SWord8  s2249 = s2243 ^ s2248;+  const SWord16 s2250 = (((SWord16) s2242) << 8) | ((SWord16) s2249);+  const SWord32 s2251 = (((SWord32) s2235) << 16) | ((SWord32) s2250);+  const SWord32 s2252 = s2214 ^ s2251;+  const SWord16 s2253 = (SWord16) s2252;+  const SWord8  s2254 = (SWord8) (s2253 >> 8);+  const SWord32 s2255 = table4[s2254];+  const SWord32 s2256 = s2201 ^ s2255;+  const SWord8  s2257 = (SWord8) (s2204 >> 8);+  const SWord32 s2258 = table1[s2257];+  const SWord8  s2259 = (SWord8) s1940;+  const SWord32 s2260 = table3[s2259];+  const SWord32 s2261 = s2258 ^ s2260;+  const SWord8  s2262 = (SWord8) (s2211 >> 8);+  const SWord32 s2263 = table4[s2262];+  const SWord32 s2264 = s2261 ^ s2263;+  const SWord8  s2265 = (SWord8) s2049;+  const SWord32 s2266 = table5[s2265];+  const SWord32 s2267 = s2264 ^ s2266;+  const SWord16 s2268 = (SWord16) (s631 >> 16);+  const SWord8  s2269 = (SWord8) (s2268 >> 8);+  const SWord8  s2270 = table6[s2269];+  const SWord8  s2271 = (SWord8) s2268;+  const SWord8  s2272 = table7[s2271];+  const SWord16 s2273 = (SWord16) s631;+  const SWord8  s2274 = (SWord8) (s2273 >> 8);+  const SWord8  s2275 = table8[s2274];+  const SWord8  s2276 = (SWord8) s2273;+  const SWord8  s2277 = table9[s2276];+  const SWord8  s2278 = s2275 ^ s2277;+  const SWord8  s2279 = s2272 ^ s2278;+  const SWord8  s2280 = s2270 ^ s2279;+  const SWord8  s2281 = table9[s2269];+  const SWord8  s2282 = table6[s2271];+  const SWord8  s2283 = table7[s2274];+  const SWord8  s2284 = table8[s2276];+  const SWord8  s2285 = s2283 ^ s2284;+  const SWord8  s2286 = s2282 ^ s2285;+  const SWord8  s2287 = s2281 ^ s2286;+  const SWord16 s2288 = (((SWord16) s2280) << 8) | ((SWord16) s2287);+  const SWord8  s2289 = table8[s2269];+  const SWord8  s2290 = table9[s2271];+  const SWord8  s2291 = table6[s2274];+  const SWord8  s2292 = table7[s2276];+  const SWord8  s2293 = s2291 ^ s2292;+  const SWord8  s2294 = s2290 ^ s2293;+  const SWord8  s2295 = s2289 ^ s2294;+  const SWord8  s2296 = table7[s2269];+  const SWord8  s2297 = table8[s2271];+  const SWord8  s2298 = table9[s2274];+  const SWord8  s2299 = table6[s2276];+  const SWord8  s2300 = s2298 ^ s2299;+  const SWord8  s2301 = s2297 ^ s2300;+  const SWord8  s2302 = s2296 ^ s2301;+  const SWord16 s2303 = (((SWord16) s2295) << 8) | ((SWord16) s2302);+  const SWord32 s2304 = (((SWord32) s2288) << 16) | ((SWord32) s2303);+  const SWord32 s2305 = s2267 ^ s2304;+  const SWord16 s2306 = (SWord16) s2305;+  const SWord8  s2307 = (SWord8) s2306;+  const SWord32 s2308 = table5[s2307];+  const SWord32 s2309 = s2256 ^ s2308;+  const SWord16 s2310 = (SWord16) (s611 >> 16);+  const SWord8  s2311 = (SWord8) (s2310 >> 8);+  const SWord8  s2312 = table6[s2311];+  const SWord8  s2313 = (SWord8) s2310;+  const SWord8  s2314 = table7[s2313];+  const SWord16 s2315 = (SWord16) s611;+  const SWord8  s2316 = (SWord8) (s2315 >> 8);+  const SWord8  s2317 = table8[s2316];+  const SWord8  s2318 = (SWord8) s2315;+  const SWord8  s2319 = table9[s2318];+  const SWord8  s2320 = s2317 ^ s2319;+  const SWord8  s2321 = s2314 ^ s2320;+  const SWord8  s2322 = s2312 ^ s2321;+  const SWord8  s2323 = table9[s2311];+  const SWord8  s2324 = table6[s2313];+  const SWord8  s2325 = table7[s2316];+  const SWord8  s2326 = table8[s2318];+  const SWord8  s2327 = s2325 ^ s2326;+  const SWord8  s2328 = s2324 ^ s2327;+  const SWord8  s2329 = s2323 ^ s2328;+  const SWord16 s2330 = (((SWord16) s2322) << 8) | ((SWord16) s2329);+  const SWord8  s2331 = table8[s2311];+  const SWord8  s2332 = table9[s2313];+  const SWord8  s2333 = table6[s2316];+  const SWord8  s2334 = table7[s2318];+  const SWord8  s2335 = s2333 ^ s2334;+  const SWord8  s2336 = s2332 ^ s2335;+  const SWord8  s2337 = s2331 ^ s2336;+  const SWord8  s2338 = table7[s2311];+  const SWord8  s2339 = table8[s2313];+  const SWord8  s2340 = table9[s2316];+  const SWord8  s2341 = table6[s2318];+  const SWord8  s2342 = s2340 ^ s2341;+  const SWord8  s2343 = s2339 ^ s2342;+  const SWord8  s2344 = s2338 ^ s2343;+  const SWord16 s2345 = (((SWord16) s2337) << 8) | ((SWord16) s2344);+  const SWord32 s2346 = (((SWord32) s2330) << 16) | ((SWord32) s2345);+  const SWord32 s2347 = s2309 ^ s2346;+  const SWord16 s2348 = (SWord16) (s2347 >> 16);+  const SWord8  s2349 = (SWord8) (s2348 >> 8);+  const SWord32 s2350 = table1[s2349];+  const SWord8  s2351 = (SWord8) (s2198 >> 8);+  const SWord32 s2352 = table1[s2351];+  const SWord16 s2353 = (SWord16) (s2252 >> 16);+  const SWord8  s2354 = (SWord8) s2353;+  const SWord32 s2355 = table3[s2354];+  const SWord32 s2356 = s2352 ^ s2355;+  const SWord8  s2357 = (SWord8) (s2306 >> 8);+  const SWord32 s2358 = table4[s2357];+  const SWord32 s2359 = s2356 ^ s2358;+  const SWord16 s2360 = (SWord16) s2143;+  const SWord8  s2361 = (SWord8) s2360;+  const SWord32 s2362 = table5[s2361];+  const SWord32 s2363 = s2359 ^ s2362;+  const SWord16 s2364 = (SWord16) (s614 >> 16);+  const SWord8  s2365 = (SWord8) (s2364 >> 8);+  const SWord8  s2366 = table6[s2365];+  const SWord8  s2367 = (SWord8) s2364;+  const SWord8  s2368 = table7[s2367];+  const SWord16 s2369 = (SWord16) s614;+  const SWord8  s2370 = (SWord8) (s2369 >> 8);+  const SWord8  s2371 = table8[s2370];+  const SWord8  s2372 = (SWord8) s2369;+  const SWord8  s2373 = table9[s2372];+  const SWord8  s2374 = s2371 ^ s2373;+  const SWord8  s2375 = s2368 ^ s2374;+  const SWord8  s2376 = s2366 ^ s2375;+  const SWord8  s2377 = table9[s2365];+  const SWord8  s2378 = table6[s2367];+  const SWord8  s2379 = table7[s2370];+  const SWord8  s2380 = table8[s2372];+  const SWord8  s2381 = s2379 ^ s2380;+  const SWord8  s2382 = s2378 ^ s2381;+  const SWord8  s2383 = s2377 ^ s2382;+  const SWord16 s2384 = (((SWord16) s2376) << 8) | ((SWord16) s2383);+  const SWord8  s2385 = table8[s2365];+  const SWord8  s2386 = table9[s2367];+  const SWord8  s2387 = table6[s2370];+  const SWord8  s2388 = table7[s2372];+  const SWord8  s2389 = s2387 ^ s2388;+  const SWord8  s2390 = s2386 ^ s2389;+  const SWord8  s2391 = s2385 ^ s2390;+  const SWord8  s2392 = table7[s2365];+  const SWord8  s2393 = table8[s2367];+  const SWord8  s2394 = table9[s2370];+  const SWord8  s2395 = table6[s2372];+  const SWord8  s2396 = s2394 ^ s2395;+  const SWord8  s2397 = s2393 ^ s2396;+  const SWord8  s2398 = s2392 ^ s2397;+  const SWord16 s2399 = (((SWord16) s2391) << 8) | ((SWord16) s2398);+  const SWord32 s2400 = (((SWord32) s2384) << 16) | ((SWord32) s2399);+  const SWord32 s2401 = s2363 ^ s2400;+  const SWord16 s2402 = (SWord16) (s2401 >> 16);+  const SWord8  s2403 = (SWord8) s2402;+  const SWord32 s2404 = table3[s2403];+  const SWord32 s2405 = s2350 ^ s2404;+  const SWord8  s2406 = (SWord8) (s2353 >> 8);+  const SWord32 s2407 = table1[s2406];+  const SWord16 s2408 = (SWord16) (s2305 >> 16);+  const SWord8  s2409 = (SWord8) s2408;+  const SWord32 s2410 = table3[s2409];+  const SWord32 s2411 = s2407 ^ s2410;+  const SWord8  s2412 = (SWord8) (s2360 >> 8);+  const SWord32 s2413 = table4[s2412];+  const SWord32 s2414 = s2411 ^ s2413;+  const SWord16 s2415 = (SWord16) s2197;+  const SWord8  s2416 = (SWord8) s2415;+  const SWord32 s2417 = table5[s2416];+  const SWord32 s2418 = s2414 ^ s2417;+  const SWord16 s2419 = (SWord16) (s613 >> 16);+  const SWord8  s2420 = (SWord8) (s2419 >> 8);+  const SWord8  s2421 = table6[s2420];+  const SWord8  s2422 = (SWord8) s2419;+  const SWord8  s2423 = table7[s2422];+  const SWord16 s2424 = (SWord16) s613;+  const SWord8  s2425 = (SWord8) (s2424 >> 8);+  const SWord8  s2426 = table8[s2425];+  const SWord8  s2427 = (SWord8) s2424;+  const SWord8  s2428 = table9[s2427];+  const SWord8  s2429 = s2426 ^ s2428;+  const SWord8  s2430 = s2423 ^ s2429;+  const SWord8  s2431 = s2421 ^ s2430;+  const SWord8  s2432 = table9[s2420];+  const SWord8  s2433 = table6[s2422];+  const SWord8  s2434 = table7[s2425];+  const SWord8  s2435 = table8[s2427];+  const SWord8  s2436 = s2434 ^ s2435;+  const SWord8  s2437 = s2433 ^ s2436;+  const SWord8  s2438 = s2432 ^ s2437;+  const SWord16 s2439 = (((SWord16) s2431) << 8) | ((SWord16) s2438);+  const SWord8  s2440 = table8[s2420];+  const SWord8  s2441 = table9[s2422];+  const SWord8  s2442 = table6[s2425];+  const SWord8  s2443 = table7[s2427];+  const SWord8  s2444 = s2442 ^ s2443;+  const SWord8  s2445 = s2441 ^ s2444;+  const SWord8  s2446 = s2440 ^ s2445;+  const SWord8  s2447 = table7[s2420];+  const SWord8  s2448 = table8[s2422];+  const SWord8  s2449 = table9[s2425];+  const SWord8  s2450 = table6[s2427];+  const SWord8  s2451 = s2449 ^ s2450;+  const SWord8  s2452 = s2448 ^ s2451;+  const SWord8  s2453 = s2447 ^ s2452;+  const SWord16 s2454 = (((SWord16) s2446) << 8) | ((SWord16) s2453);+  const SWord32 s2455 = (((SWord32) s2439) << 16) | ((SWord32) s2454);+  const SWord32 s2456 = s2418 ^ s2455;+  const SWord16 s2457 = (SWord16) s2456;+  const SWord8  s2458 = (SWord8) (s2457 >> 8);+  const SWord32 s2459 = table4[s2458];+  const SWord32 s2460 = s2405 ^ s2459;+  const SWord8  s2461 = (SWord8) (s2408 >> 8);+  const SWord32 s2462 = table1[s2461];+  const SWord8  s2463 = (SWord8) s2144;+  const SWord32 s2464 = table3[s2463];+  const SWord32 s2465 = s2462 ^ s2464;+  const SWord8  s2466 = (SWord8) (s2415 >> 8);+  const SWord32 s2467 = table4[s2466];+  const SWord32 s2468 = s2465 ^ s2467;+  const SWord8  s2469 = (SWord8) s2253;+  const SWord32 s2470 = table5[s2469];+  const SWord32 s2471 = s2468 ^ s2470;+  const SWord16 s2472 = (SWord16) (s612 >> 16);+  const SWord8  s2473 = (SWord8) (s2472 >> 8);+  const SWord8  s2474 = table6[s2473];+  const SWord8  s2475 = (SWord8) s2472;+  const SWord8  s2476 = table7[s2475];+  const SWord16 s2477 = (SWord16) s612;+  const SWord8  s2478 = (SWord8) (s2477 >> 8);+  const SWord8  s2479 = table8[s2478];+  const SWord8  s2480 = (SWord8) s2477;+  const SWord8  s2481 = table9[s2480];+  const SWord8  s2482 = s2479 ^ s2481;+  const SWord8  s2483 = s2476 ^ s2482;+  const SWord8  s2484 = s2474 ^ s2483;+  const SWord8  s2485 = table9[s2473];+  const SWord8  s2486 = table6[s2475];+  const SWord8  s2487 = table7[s2478];+  const SWord8  s2488 = table8[s2480];+  const SWord8  s2489 = s2487 ^ s2488;+  const SWord8  s2490 = s2486 ^ s2489;+  const SWord8  s2491 = s2485 ^ s2490;+  const SWord16 s2492 = (((SWord16) s2484) << 8) | ((SWord16) s2491);+  const SWord8  s2493 = table8[s2473];+  const SWord8  s2494 = table9[s2475];+  const SWord8  s2495 = table6[s2478];+  const SWord8  s2496 = table7[s2480];+  const SWord8  s2497 = s2495 ^ s2496;+  const SWord8  s2498 = s2494 ^ s2497;+  const SWord8  s2499 = s2493 ^ s2498;+  const SWord8  s2500 = table7[s2473];+  const SWord8  s2501 = table8[s2475];+  const SWord8  s2502 = table9[s2478];+  const SWord8  s2503 = table6[s2480];+  const SWord8  s2504 = s2502 ^ s2503;+  const SWord8  s2505 = s2501 ^ s2504;+  const SWord8  s2506 = s2500 ^ s2505;+  const SWord16 s2507 = (((SWord16) s2499) << 8) | ((SWord16) s2506);+  const SWord32 s2508 = (((SWord32) s2492) << 16) | ((SWord32) s2507);+  const SWord32 s2509 = s2471 ^ s2508;+  const SWord16 s2510 = (SWord16) s2509;+  const SWord8  s2511 = (SWord8) s2510;+  const SWord32 s2512 = table5[s2511];+  const SWord32 s2513 = s2460 ^ s2512;+  const SWord16 s2514 = (SWord16) (s592 >> 16);+  const SWord8  s2515 = (SWord8) (s2514 >> 8);+  const SWord8  s2516 = table6[s2515];+  const SWord8  s2517 = (SWord8) s2514;+  const SWord8  s2518 = table7[s2517];+  const SWord16 s2519 = (SWord16) s592;+  const SWord8  s2520 = (SWord8) (s2519 >> 8);+  const SWord8  s2521 = table8[s2520];+  const SWord8  s2522 = (SWord8) s2519;+  const SWord8  s2523 = table9[s2522];+  const SWord8  s2524 = s2521 ^ s2523;+  const SWord8  s2525 = s2518 ^ s2524;+  const SWord8  s2526 = s2516 ^ s2525;+  const SWord8  s2527 = table9[s2515];+  const SWord8  s2528 = table6[s2517];+  const SWord8  s2529 = table7[s2520];+  const SWord8  s2530 = table8[s2522];+  const SWord8  s2531 = s2529 ^ s2530;+  const SWord8  s2532 = s2528 ^ s2531;+  const SWord8  s2533 = s2527 ^ s2532;+  const SWord16 s2534 = (((SWord16) s2526) << 8) | ((SWord16) s2533);+  const SWord8  s2535 = table8[s2515];+  const SWord8  s2536 = table9[s2517];+  const SWord8  s2537 = table6[s2520];+  const SWord8  s2538 = table7[s2522];+  const SWord8  s2539 = s2537 ^ s2538;+  const SWord8  s2540 = s2536 ^ s2539;+  const SWord8  s2541 = s2535 ^ s2540;+  const SWord8  s2542 = table7[s2515];+  const SWord8  s2543 = table8[s2517];+  const SWord8  s2544 = table9[s2520];+  const SWord8  s2545 = table6[s2522];+  const SWord8  s2546 = s2544 ^ s2545;+  const SWord8  s2547 = s2543 ^ s2546;+  const SWord8  s2548 = s2542 ^ s2547;+  const SWord16 s2549 = (((SWord16) s2541) << 8) | ((SWord16) s2548);+  const SWord32 s2550 = (((SWord32) s2534) << 16) | ((SWord32) s2549);+  const SWord32 s2551 = s2513 ^ s2550;+  const SWord16 s2552 = (SWord16) (s2551 >> 16);+  const SWord8  s2553 = (SWord8) (s2552 >> 8);+  const SWord32 s2554 = table1[s2553];+  const SWord8  s2555 = (SWord8) (s2402 >> 8);+  const SWord32 s2556 = table1[s2555];+  const SWord16 s2557 = (SWord16) (s2456 >> 16);+  const SWord8  s2558 = (SWord8) s2557;+  const SWord32 s2559 = table3[s2558];+  const SWord32 s2560 = s2556 ^ s2559;+  const SWord8  s2561 = (SWord8) (s2510 >> 8);+  const SWord32 s2562 = table4[s2561];+  const SWord32 s2563 = s2560 ^ s2562;+  const SWord16 s2564 = (SWord16) s2347;+  const SWord8  s2565 = (SWord8) s2564;+  const SWord32 s2566 = table5[s2565];+  const SWord32 s2567 = s2563 ^ s2566;+  const SWord16 s2568 = (SWord16) (s595 >> 16);+  const SWord8  s2569 = (SWord8) (s2568 >> 8);+  const SWord8  s2570 = table6[s2569];+  const SWord8  s2571 = (SWord8) s2568;+  const SWord8  s2572 = table7[s2571];+  const SWord16 s2573 = (SWord16) s595;+  const SWord8  s2574 = (SWord8) (s2573 >> 8);+  const SWord8  s2575 = table8[s2574];+  const SWord8  s2576 = (SWord8) s2573;+  const SWord8  s2577 = table9[s2576];+  const SWord8  s2578 = s2575 ^ s2577;+  const SWord8  s2579 = s2572 ^ s2578;+  const SWord8  s2580 = s2570 ^ s2579;+  const SWord8  s2581 = table9[s2569];+  const SWord8  s2582 = table6[s2571];+  const SWord8  s2583 = table7[s2574];+  const SWord8  s2584 = table8[s2576];+  const SWord8  s2585 = s2583 ^ s2584;+  const SWord8  s2586 = s2582 ^ s2585;+  const SWord8  s2587 = s2581 ^ s2586;+  const SWord16 s2588 = (((SWord16) s2580) << 8) | ((SWord16) s2587);+  const SWord8  s2589 = table8[s2569];+  const SWord8  s2590 = table9[s2571];+  const SWord8  s2591 = table6[s2574];+  const SWord8  s2592 = table7[s2576];+  const SWord8  s2593 = s2591 ^ s2592;+  const SWord8  s2594 = s2590 ^ s2593;+  const SWord8  s2595 = s2589 ^ s2594;+  const SWord8  s2596 = table7[s2569];+  const SWord8  s2597 = table8[s2571];+  const SWord8  s2598 = table9[s2574];+  const SWord8  s2599 = table6[s2576];+  const SWord8  s2600 = s2598 ^ s2599;+  const SWord8  s2601 = s2597 ^ s2600;+  const SWord8  s2602 = s2596 ^ s2601;+  const SWord16 s2603 = (((SWord16) s2595) << 8) | ((SWord16) s2602);+  const SWord32 s2604 = (((SWord32) s2588) << 16) | ((SWord32) s2603);+  const SWord32 s2605 = s2567 ^ s2604;+  const SWord16 s2606 = (SWord16) (s2605 >> 16);+  const SWord8  s2607 = (SWord8) s2606;+  const SWord32 s2608 = table3[s2607];+  const SWord32 s2609 = s2554 ^ s2608;+  const SWord8  s2610 = (SWord8) (s2557 >> 8);+  const SWord32 s2611 = table1[s2610];+  const SWord16 s2612 = (SWord16) (s2509 >> 16);+  const SWord8  s2613 = (SWord8) s2612;+  const SWord32 s2614 = table3[s2613];+  const SWord32 s2615 = s2611 ^ s2614;+  const SWord8  s2616 = (SWord8) (s2564 >> 8);+  const SWord32 s2617 = table4[s2616];+  const SWord32 s2618 = s2615 ^ s2617;+  const SWord16 s2619 = (SWord16) s2401;+  const SWord8  s2620 = (SWord8) s2619;+  const SWord32 s2621 = table5[s2620];+  const SWord32 s2622 = s2618 ^ s2621;+  const SWord16 s2623 = (SWord16) (s594 >> 16);+  const SWord8  s2624 = (SWord8) (s2623 >> 8);+  const SWord8  s2625 = table6[s2624];+  const SWord8  s2626 = (SWord8) s2623;+  const SWord8  s2627 = table7[s2626];+  const SWord16 s2628 = (SWord16) s594;+  const SWord8  s2629 = (SWord8) (s2628 >> 8);+  const SWord8  s2630 = table8[s2629];+  const SWord8  s2631 = (SWord8) s2628;+  const SWord8  s2632 = table9[s2631];+  const SWord8  s2633 = s2630 ^ s2632;+  const SWord8  s2634 = s2627 ^ s2633;+  const SWord8  s2635 = s2625 ^ s2634;+  const SWord8  s2636 = table9[s2624];+  const SWord8  s2637 = table6[s2626];+  const SWord8  s2638 = table7[s2629];+  const SWord8  s2639 = table8[s2631];+  const SWord8  s2640 = s2638 ^ s2639;+  const SWord8  s2641 = s2637 ^ s2640;+  const SWord8  s2642 = s2636 ^ s2641;+  const SWord16 s2643 = (((SWord16) s2635) << 8) | ((SWord16) s2642);+  const SWord8  s2644 = table8[s2624];+  const SWord8  s2645 = table9[s2626];+  const SWord8  s2646 = table6[s2629];+  const SWord8  s2647 = table7[s2631];+  const SWord8  s2648 = s2646 ^ s2647;+  const SWord8  s2649 = s2645 ^ s2648;+  const SWord8  s2650 = s2644 ^ s2649;+  const SWord8  s2651 = table7[s2624];+  const SWord8  s2652 = table8[s2626];+  const SWord8  s2653 = table9[s2629];+  const SWord8  s2654 = table6[s2631];+  const SWord8  s2655 = s2653 ^ s2654;+  const SWord8  s2656 = s2652 ^ s2655;+  const SWord8  s2657 = s2651 ^ s2656;+  const SWord16 s2658 = (((SWord16) s2650) << 8) | ((SWord16) s2657);+  const SWord32 s2659 = (((SWord32) s2643) << 16) | ((SWord32) s2658);+  const SWord32 s2660 = s2622 ^ s2659;+  const SWord16 s2661 = (SWord16) s2660;+  const SWord8  s2662 = (SWord8) (s2661 >> 8);+  const SWord32 s2663 = table4[s2662];+  const SWord32 s2664 = s2609 ^ s2663;+  const SWord8  s2665 = (SWord8) (s2612 >> 8);+  const SWord32 s2666 = table1[s2665];+  const SWord8  s2667 = (SWord8) s2348;+  const SWord32 s2668 = table3[s2667];+  const SWord32 s2669 = s2666 ^ s2668;+  const SWord8  s2670 = (SWord8) (s2619 >> 8);+  const SWord32 s2671 = table4[s2670];+  const SWord32 s2672 = s2669 ^ s2671;+  const SWord8  s2673 = (SWord8) s2457;+  const SWord32 s2674 = table5[s2673];+  const SWord32 s2675 = s2672 ^ s2674;+  const SWord16 s2676 = (SWord16) (s593 >> 16);+  const SWord8  s2677 = (SWord8) (s2676 >> 8);+  const SWord8  s2678 = table6[s2677];+  const SWord8  s2679 = (SWord8) s2676;+  const SWord8  s2680 = table7[s2679];+  const SWord16 s2681 = (SWord16) s593;+  const SWord8  s2682 = (SWord8) (s2681 >> 8);+  const SWord8  s2683 = table8[s2682];+  const SWord8  s2684 = (SWord8) s2681;+  const SWord8  s2685 = table9[s2684];+  const SWord8  s2686 = s2683 ^ s2685;+  const SWord8  s2687 = s2680 ^ s2686;+  const SWord8  s2688 = s2678 ^ s2687;+  const SWord8  s2689 = table9[s2677];+  const SWord8  s2690 = table6[s2679];+  const SWord8  s2691 = table7[s2682];+  const SWord8  s2692 = table8[s2684];+  const SWord8  s2693 = s2691 ^ s2692;+  const SWord8  s2694 = s2690 ^ s2693;+  const SWord8  s2695 = s2689 ^ s2694;+  const SWord16 s2696 = (((SWord16) s2688) << 8) | ((SWord16) s2695);+  const SWord8  s2697 = table8[s2677];+  const SWord8  s2698 = table9[s2679];+  const SWord8  s2699 = table6[s2682];+  const SWord8  s2700 = table7[s2684];+  const SWord8  s2701 = s2699 ^ s2700;+  const SWord8  s2702 = s2698 ^ s2701;+  const SWord8  s2703 = s2697 ^ s2702;+  const SWord8  s2704 = table7[s2677];+  const SWord8  s2705 = table8[s2679];+  const SWord8  s2706 = table9[s2682];+  const SWord8  s2707 = table6[s2684];+  const SWord8  s2708 = s2706 ^ s2707;+  const SWord8  s2709 = s2705 ^ s2708;+  const SWord8  s2710 = s2704 ^ s2709;+  const SWord16 s2711 = (((SWord16) s2703) << 8) | ((SWord16) s2710);+  const SWord32 s2712 = (((SWord32) s2696) << 16) | ((SWord32) s2711);+  const SWord32 s2713 = s2675 ^ s2712;+  const SWord16 s2714 = (SWord16) s2713;+  const SWord8  s2715 = (SWord8) s2714;+  const SWord32 s2716 = table5[s2715];+  const SWord32 s2717 = s2664 ^ s2716;+  const SWord16 s2718 = (SWord16) (s573 >> 16);+  const SWord8  s2719 = (SWord8) (s2718 >> 8);+  const SWord8  s2720 = table6[s2719];+  const SWord8  s2721 = (SWord8) s2718;+  const SWord8  s2722 = table7[s2721];+  const SWord16 s2723 = (SWord16) s573;+  const SWord8  s2724 = (SWord8) (s2723 >> 8);+  const SWord8  s2725 = table8[s2724];+  const SWord8  s2726 = (SWord8) s2723;+  const SWord8  s2727 = table9[s2726];+  const SWord8  s2728 = s2725 ^ s2727;+  const SWord8  s2729 = s2722 ^ s2728;+  const SWord8  s2730 = s2720 ^ s2729;+  const SWord8  s2731 = table9[s2719];+  const SWord8  s2732 = table6[s2721];+  const SWord8  s2733 = table7[s2724];+  const SWord8  s2734 = table8[s2726];+  const SWord8  s2735 = s2733 ^ s2734;+  const SWord8  s2736 = s2732 ^ s2735;+  const SWord8  s2737 = s2731 ^ s2736;+  const SWord16 s2738 = (((SWord16) s2730) << 8) | ((SWord16) s2737);+  const SWord8  s2739 = table8[s2719];+  const SWord8  s2740 = table9[s2721];+  const SWord8  s2741 = table6[s2724];+  const SWord8  s2742 = table7[s2726];+  const SWord8  s2743 = s2741 ^ s2742;+  const SWord8  s2744 = s2740 ^ s2743;+  const SWord8  s2745 = s2739 ^ s2744;+  const SWord8  s2746 = table7[s2719];+  const SWord8  s2747 = table8[s2721];+  const SWord8  s2748 = table9[s2724];+  const SWord8  s2749 = table6[s2726];+  const SWord8  s2750 = s2748 ^ s2749;+  const SWord8  s2751 = s2747 ^ s2750;+  const SWord8  s2752 = s2746 ^ s2751;+  const SWord16 s2753 = (((SWord16) s2745) << 8) | ((SWord16) s2752);+  const SWord32 s2754 = (((SWord32) s2738) << 16) | ((SWord32) s2753);+  const SWord32 s2755 = s2717 ^ s2754;+  const SWord16 s2756 = (SWord16) (s2755 >> 16);+  const SWord8  s2757 = (SWord8) (s2756 >> 8);+  const SWord32 s2758 = table1[s2757];+  const SWord8  s2759 = (SWord8) (s2606 >> 8);+  const SWord32 s2760 = table1[s2759];+  const SWord16 s2761 = (SWord16) (s2660 >> 16);+  const SWord8  s2762 = (SWord8) s2761;+  const SWord32 s2763 = table3[s2762];+  const SWord32 s2764 = s2760 ^ s2763;+  const SWord8  s2765 = (SWord8) (s2714 >> 8);+  const SWord32 s2766 = table4[s2765];+  const SWord32 s2767 = s2764 ^ s2766;+  const SWord16 s2768 = (SWord16) s2551;+  const SWord8  s2769 = (SWord8) s2768;+  const SWord32 s2770 = table5[s2769];+  const SWord32 s2771 = s2767 ^ s2770;+  const SWord16 s2772 = (SWord16) (s576 >> 16);+  const SWord8  s2773 = (SWord8) (s2772 >> 8);+  const SWord8  s2774 = table6[s2773];+  const SWord8  s2775 = (SWord8) s2772;+  const SWord8  s2776 = table7[s2775];+  const SWord16 s2777 = (SWord16) s576;+  const SWord8  s2778 = (SWord8) (s2777 >> 8);+  const SWord8  s2779 = table8[s2778];+  const SWord8  s2780 = (SWord8) s2777;+  const SWord8  s2781 = table9[s2780];+  const SWord8  s2782 = s2779 ^ s2781;+  const SWord8  s2783 = s2776 ^ s2782;+  const SWord8  s2784 = s2774 ^ s2783;+  const SWord8  s2785 = table9[s2773];+  const SWord8  s2786 = table6[s2775];+  const SWord8  s2787 = table7[s2778];+  const SWord8  s2788 = table8[s2780];+  const SWord8  s2789 = s2787 ^ s2788;+  const SWord8  s2790 = s2786 ^ s2789;+  const SWord8  s2791 = s2785 ^ s2790;+  const SWord16 s2792 = (((SWord16) s2784) << 8) | ((SWord16) s2791);+  const SWord8  s2793 = table8[s2773];+  const SWord8  s2794 = table9[s2775];+  const SWord8  s2795 = table6[s2778];+  const SWord8  s2796 = table7[s2780];+  const SWord8  s2797 = s2795 ^ s2796;+  const SWord8  s2798 = s2794 ^ s2797;+  const SWord8  s2799 = s2793 ^ s2798;+  const SWord8  s2800 = table7[s2773];+  const SWord8  s2801 = table8[s2775];+  const SWord8  s2802 = table9[s2778];+  const SWord8  s2803 = table6[s2780];+  const SWord8  s2804 = s2802 ^ s2803;+  const SWord8  s2805 = s2801 ^ s2804;+  const SWord8  s2806 = s2800 ^ s2805;+  const SWord16 s2807 = (((SWord16) s2799) << 8) | ((SWord16) s2806);+  const SWord32 s2808 = (((SWord32) s2792) << 16) | ((SWord32) s2807);+  const SWord32 s2809 = s2771 ^ s2808;+  const SWord16 s2810 = (SWord16) (s2809 >> 16);+  const SWord8  s2811 = (SWord8) s2810;+  const SWord32 s2812 = table3[s2811];+  const SWord32 s2813 = s2758 ^ s2812;+  const SWord8  s2814 = (SWord8) (s2761 >> 8);+  const SWord32 s2815 = table1[s2814];+  const SWord16 s2816 = (SWord16) (s2713 >> 16);+  const SWord8  s2817 = (SWord8) s2816;+  const SWord32 s2818 = table3[s2817];+  const SWord32 s2819 = s2815 ^ s2818;+  const SWord8  s2820 = (SWord8) (s2768 >> 8);+  const SWord32 s2821 = table4[s2820];+  const SWord32 s2822 = s2819 ^ s2821;+  const SWord16 s2823 = (SWord16) s2605;+  const SWord8  s2824 = (SWord8) s2823;+  const SWord32 s2825 = table5[s2824];+  const SWord32 s2826 = s2822 ^ s2825;+  const SWord16 s2827 = (SWord16) (s575 >> 16);+  const SWord8  s2828 = (SWord8) (s2827 >> 8);+  const SWord8  s2829 = table6[s2828];+  const SWord8  s2830 = (SWord8) s2827;+  const SWord8  s2831 = table7[s2830];+  const SWord16 s2832 = (SWord16) s575;+  const SWord8  s2833 = (SWord8) (s2832 >> 8);+  const SWord8  s2834 = table8[s2833];+  const SWord8  s2835 = (SWord8) s2832;+  const SWord8  s2836 = table9[s2835];+  const SWord8  s2837 = s2834 ^ s2836;+  const SWord8  s2838 = s2831 ^ s2837;+  const SWord8  s2839 = s2829 ^ s2838;+  const SWord8  s2840 = table9[s2828];+  const SWord8  s2841 = table6[s2830];+  const SWord8  s2842 = table7[s2833];+  const SWord8  s2843 = table8[s2835];+  const SWord8  s2844 = s2842 ^ s2843;+  const SWord8  s2845 = s2841 ^ s2844;+  const SWord8  s2846 = s2840 ^ s2845;+  const SWord16 s2847 = (((SWord16) s2839) << 8) | ((SWord16) s2846);+  const SWord8  s2848 = table8[s2828];+  const SWord8  s2849 = table9[s2830];+  const SWord8  s2850 = table6[s2833];+  const SWord8  s2851 = table7[s2835];+  const SWord8  s2852 = s2850 ^ s2851;+  const SWord8  s2853 = s2849 ^ s2852;+  const SWord8  s2854 = s2848 ^ s2853;+  const SWord8  s2855 = table7[s2828];+  const SWord8  s2856 = table8[s2830];+  const SWord8  s2857 = table9[s2833];+  const SWord8  s2858 = table6[s2835];+  const SWord8  s2859 = s2857 ^ s2858;+  const SWord8  s2860 = s2856 ^ s2859;+  const SWord8  s2861 = s2855 ^ s2860;+  const SWord16 s2862 = (((SWord16) s2854) << 8) | ((SWord16) s2861);+  const SWord32 s2863 = (((SWord32) s2847) << 16) | ((SWord32) s2862);+  const SWord32 s2864 = s2826 ^ s2863;+  const SWord16 s2865 = (SWord16) s2864;+  const SWord8  s2866 = (SWord8) (s2865 >> 8);+  const SWord32 s2867 = table4[s2866];+  const SWord32 s2868 = s2813 ^ s2867;+  const SWord8  s2869 = (SWord8) (s2816 >> 8);+  const SWord32 s2870 = table1[s2869];+  const SWord8  s2871 = (SWord8) s2552;+  const SWord32 s2872 = table3[s2871];+  const SWord32 s2873 = s2870 ^ s2872;+  const SWord8  s2874 = (SWord8) (s2823 >> 8);+  const SWord32 s2875 = table4[s2874];+  const SWord32 s2876 = s2873 ^ s2875;+  const SWord8  s2877 = (SWord8) s2661;+  const SWord32 s2878 = table5[s2877];+  const SWord32 s2879 = s2876 ^ s2878;+  const SWord16 s2880 = (SWord16) (s574 >> 16);+  const SWord8  s2881 = (SWord8) (s2880 >> 8);+  const SWord8  s2882 = table6[s2881];+  const SWord8  s2883 = (SWord8) s2880;+  const SWord8  s2884 = table7[s2883];+  const SWord16 s2885 = (SWord16) s574;+  const SWord8  s2886 = (SWord8) (s2885 >> 8);+  const SWord8  s2887 = table8[s2886];+  const SWord8  s2888 = (SWord8) s2885;+  const SWord8  s2889 = table9[s2888];+  const SWord8  s2890 = s2887 ^ s2889;+  const SWord8  s2891 = s2884 ^ s2890;+  const SWord8  s2892 = s2882 ^ s2891;+  const SWord8  s2893 = table9[s2881];+  const SWord8  s2894 = table6[s2883];+  const SWord8  s2895 = table7[s2886];+  const SWord8  s2896 = table8[s2888];+  const SWord8  s2897 = s2895 ^ s2896;+  const SWord8  s2898 = s2894 ^ s2897;+  const SWord8  s2899 = s2893 ^ s2898;+  const SWord16 s2900 = (((SWord16) s2892) << 8) | ((SWord16) s2899);+  const SWord8  s2901 = table8[s2881];+  const SWord8  s2902 = table9[s2883];+  const SWord8  s2903 = table6[s2886];+  const SWord8  s2904 = table7[s2888];+  const SWord8  s2905 = s2903 ^ s2904;+  const SWord8  s2906 = s2902 ^ s2905;+  const SWord8  s2907 = s2901 ^ s2906;+  const SWord8  s2908 = table7[s2881];+  const SWord8  s2909 = table8[s2883];+  const SWord8  s2910 = table9[s2886];+  const SWord8  s2911 = table6[s2888];+  const SWord8  s2912 = s2910 ^ s2911;+  const SWord8  s2913 = s2909 ^ s2912;+  const SWord8  s2914 = s2908 ^ s2913;+  const SWord16 s2915 = (((SWord16) s2907) << 8) | ((SWord16) s2914);+  const SWord32 s2916 = (((SWord32) s2900) << 16) | ((SWord32) s2915);+  const SWord32 s2917 = s2879 ^ s2916;+  const SWord16 s2918 = (SWord16) s2917;+  const SWord8  s2919 = (SWord8) s2918;+  const SWord32 s2920 = table5[s2919];+  const SWord32 s2921 = s2868 ^ s2920;+  const SWord16 s2922 = (SWord16) (s554 >> 16);+  const SWord8  s2923 = (SWord8) (s2922 >> 8);+  const SWord8  s2924 = table6[s2923];+  const SWord8  s2925 = (SWord8) s2922;+  const SWord8  s2926 = table7[s2925];+  const SWord16 s2927 = (SWord16) s554;+  const SWord8  s2928 = (SWord8) (s2927 >> 8);+  const SWord8  s2929 = table8[s2928];+  const SWord8  s2930 = (SWord8) s2927;+  const SWord8  s2931 = table9[s2930];+  const SWord8  s2932 = s2929 ^ s2931;+  const SWord8  s2933 = s2926 ^ s2932;+  const SWord8  s2934 = s2924 ^ s2933;+  const SWord8  s2935 = table9[s2923];+  const SWord8  s2936 = table6[s2925];+  const SWord8  s2937 = table7[s2928];+  const SWord8  s2938 = table8[s2930];+  const SWord8  s2939 = s2937 ^ s2938;+  const SWord8  s2940 = s2936 ^ s2939;+  const SWord8  s2941 = s2935 ^ s2940;+  const SWord16 s2942 = (((SWord16) s2934) << 8) | ((SWord16) s2941);+  const SWord8  s2943 = table8[s2923];+  const SWord8  s2944 = table9[s2925];+  const SWord8  s2945 = table6[s2928];+  const SWord8  s2946 = table7[s2930];+  const SWord8  s2947 = s2945 ^ s2946;+  const SWord8  s2948 = s2944 ^ s2947;+  const SWord8  s2949 = s2943 ^ s2948;+  const SWord8  s2950 = table7[s2923];+  const SWord8  s2951 = table8[s2925];+  const SWord8  s2952 = table9[s2928];+  const SWord8  s2953 = table6[s2930];+  const SWord8  s2954 = s2952 ^ s2953;+  const SWord8  s2955 = s2951 ^ s2954;+  const SWord8  s2956 = s2950 ^ s2955;+  const SWord16 s2957 = (((SWord16) s2949) << 8) | ((SWord16) s2956);+  const SWord32 s2958 = (((SWord32) s2942) << 16) | ((SWord32) s2957);+  const SWord32 s2959 = s2921 ^ s2958;+  const SWord16 s2960 = (SWord16) (s2959 >> 16);+  const SWord8  s2961 = (SWord8) (s2960 >> 8);+  const SWord32 s2962 = table1[s2961];+  const SWord8  s2963 = (SWord8) (s2810 >> 8);+  const SWord32 s2964 = table1[s2963];+  const SWord16 s2965 = (SWord16) (s2864 >> 16);+  const SWord8  s2966 = (SWord8) s2965;+  const SWord32 s2967 = table3[s2966];+  const SWord32 s2968 = s2964 ^ s2967;+  const SWord8  s2969 = (SWord8) (s2918 >> 8);+  const SWord32 s2970 = table4[s2969];+  const SWord32 s2971 = s2968 ^ s2970;+  const SWord16 s2972 = (SWord16) s2755;+  const SWord8  s2973 = (SWord8) s2972;+  const SWord32 s2974 = table5[s2973];+  const SWord32 s2975 = s2971 ^ s2974;+  const SWord16 s2976 = (SWord16) (s557 >> 16);+  const SWord8  s2977 = (SWord8) (s2976 >> 8);+  const SWord8  s2978 = table6[s2977];+  const SWord8  s2979 = (SWord8) s2976;+  const SWord8  s2980 = table7[s2979];+  const SWord16 s2981 = (SWord16) s557;+  const SWord8  s2982 = (SWord8) (s2981 >> 8);+  const SWord8  s2983 = table8[s2982];+  const SWord8  s2984 = (SWord8) s2981;+  const SWord8  s2985 = table9[s2984];+  const SWord8  s2986 = s2983 ^ s2985;+  const SWord8  s2987 = s2980 ^ s2986;+  const SWord8  s2988 = s2978 ^ s2987;+  const SWord8  s2989 = table9[s2977];+  const SWord8  s2990 = table6[s2979];+  const SWord8  s2991 = table7[s2982];+  const SWord8  s2992 = table8[s2984];+  const SWord8  s2993 = s2991 ^ s2992;+  const SWord8  s2994 = s2990 ^ s2993;+  const SWord8  s2995 = s2989 ^ s2994;+  const SWord16 s2996 = (((SWord16) s2988) << 8) | ((SWord16) s2995);+  const SWord8  s2997 = table8[s2977];+  const SWord8  s2998 = table9[s2979];+  const SWord8  s2999 = table6[s2982];+  const SWord8  s3000 = table7[s2984];+  const SWord8  s3001 = s2999 ^ s3000;+  const SWord8  s3002 = s2998 ^ s3001;+  const SWord8  s3003 = s2997 ^ s3002;+  const SWord8  s3004 = table7[s2977];+  const SWord8  s3005 = table8[s2979];+  const SWord8  s3006 = table9[s2982];+  const SWord8  s3007 = table6[s2984];+  const SWord8  s3008 = s3006 ^ s3007;+  const SWord8  s3009 = s3005 ^ s3008;+  const SWord8  s3010 = s3004 ^ s3009;+  const SWord16 s3011 = (((SWord16) s3003) << 8) | ((SWord16) s3010);+  const SWord32 s3012 = (((SWord32) s2996) << 16) | ((SWord32) s3011);+  const SWord32 s3013 = s2975 ^ s3012;+  const SWord16 s3014 = (SWord16) (s3013 >> 16);+  const SWord8  s3015 = (SWord8) s3014;+  const SWord32 s3016 = table3[s3015];+  const SWord32 s3017 = s2962 ^ s3016;+  const SWord8  s3018 = (SWord8) (s2965 >> 8);+  const SWord32 s3019 = table1[s3018];+  const SWord16 s3020 = (SWord16) (s2917 >> 16);+  const SWord8  s3021 = (SWord8) s3020;+  const SWord32 s3022 = table3[s3021];+  const SWord32 s3023 = s3019 ^ s3022;+  const SWord8  s3024 = (SWord8) (s2972 >> 8);+  const SWord32 s3025 = table4[s3024];+  const SWord32 s3026 = s3023 ^ s3025;+  const SWord16 s3027 = (SWord16) s2809;+  const SWord8  s3028 = (SWord8) s3027;+  const SWord32 s3029 = table5[s3028];+  const SWord32 s3030 = s3026 ^ s3029;+  const SWord16 s3031 = (SWord16) (s556 >> 16);+  const SWord8  s3032 = (SWord8) (s3031 >> 8);+  const SWord8  s3033 = table6[s3032];+  const SWord8  s3034 = (SWord8) s3031;+  const SWord8  s3035 = table7[s3034];+  const SWord16 s3036 = (SWord16) s556;+  const SWord8  s3037 = (SWord8) (s3036 >> 8);+  const SWord8  s3038 = table8[s3037];+  const SWord8  s3039 = (SWord8) s3036;+  const SWord8  s3040 = table9[s3039];+  const SWord8  s3041 = s3038 ^ s3040;+  const SWord8  s3042 = s3035 ^ s3041;+  const SWord8  s3043 = s3033 ^ s3042;+  const SWord8  s3044 = table9[s3032];+  const SWord8  s3045 = table6[s3034];+  const SWord8  s3046 = table7[s3037];+  const SWord8  s3047 = table8[s3039];+  const SWord8  s3048 = s3046 ^ s3047;+  const SWord8  s3049 = s3045 ^ s3048;+  const SWord8  s3050 = s3044 ^ s3049;+  const SWord16 s3051 = (((SWord16) s3043) << 8) | ((SWord16) s3050);+  const SWord8  s3052 = table8[s3032];+  const SWord8  s3053 = table9[s3034];+  const SWord8  s3054 = table6[s3037];+  const SWord8  s3055 = table7[s3039];+  const SWord8  s3056 = s3054 ^ s3055;+  const SWord8  s3057 = s3053 ^ s3056;+  const SWord8  s3058 = s3052 ^ s3057;+  const SWord8  s3059 = table7[s3032];+  const SWord8  s3060 = table8[s3034];+  const SWord8  s3061 = table9[s3037];+  const SWord8  s3062 = table6[s3039];+  const SWord8  s3063 = s3061 ^ s3062;+  const SWord8  s3064 = s3060 ^ s3063;+  const SWord8  s3065 = s3059 ^ s3064;+  const SWord16 s3066 = (((SWord16) s3058) << 8) | ((SWord16) s3065);+  const SWord32 s3067 = (((SWord32) s3051) << 16) | ((SWord32) s3066);+  const SWord32 s3068 = s3030 ^ s3067;+  const SWord16 s3069 = (SWord16) s3068;+  const SWord8  s3070 = (SWord8) (s3069 >> 8);+  const SWord32 s3071 = table4[s3070];+  const SWord32 s3072 = s3017 ^ s3071;+  const SWord8  s3073 = (SWord8) (s3020 >> 8);+  const SWord32 s3074 = table1[s3073];+  const SWord8  s3075 = (SWord8) s2756;+  const SWord32 s3076 = table3[s3075];+  const SWord32 s3077 = s3074 ^ s3076;+  const SWord8  s3078 = (SWord8) (s3027 >> 8);+  const SWord32 s3079 = table4[s3078];+  const SWord32 s3080 = s3077 ^ s3079;+  const SWord8  s3081 = (SWord8) s2865;+  const SWord32 s3082 = table5[s3081];+  const SWord32 s3083 = s3080 ^ s3082;+  const SWord16 s3084 = (SWord16) (s555 >> 16);+  const SWord8  s3085 = (SWord8) (s3084 >> 8);+  const SWord8  s3086 = table6[s3085];+  const SWord8  s3087 = (SWord8) s3084;+  const SWord8  s3088 = table7[s3087];+  const SWord16 s3089 = (SWord16) s555;+  const SWord8  s3090 = (SWord8) (s3089 >> 8);+  const SWord8  s3091 = table8[s3090];+  const SWord8  s3092 = (SWord8) s3089;+  const SWord8  s3093 = table9[s3092];+  const SWord8  s3094 = s3091 ^ s3093;+  const SWord8  s3095 = s3088 ^ s3094;+  const SWord8  s3096 = s3086 ^ s3095;+  const SWord8  s3097 = table9[s3085];+  const SWord8  s3098 = table6[s3087];+  const SWord8  s3099 = table7[s3090];+  const SWord8  s3100 = table8[s3092];+  const SWord8  s3101 = s3099 ^ s3100;+  const SWord8  s3102 = s3098 ^ s3101;+  const SWord8  s3103 = s3097 ^ s3102;+  const SWord16 s3104 = (((SWord16) s3096) << 8) | ((SWord16) s3103);+  const SWord8  s3105 = table8[s3085];+  const SWord8  s3106 = table9[s3087];+  const SWord8  s3107 = table6[s3090];+  const SWord8  s3108 = table7[s3092];+  const SWord8  s3109 = s3107 ^ s3108;+  const SWord8  s3110 = s3106 ^ s3109;+  const SWord8  s3111 = s3105 ^ s3110;+  const SWord8  s3112 = table7[s3085];+  const SWord8  s3113 = table8[s3087];+  const SWord8  s3114 = table9[s3090];+  const SWord8  s3115 = table6[s3092];+  const SWord8  s3116 = s3114 ^ s3115;+  const SWord8  s3117 = s3113 ^ s3116;+  const SWord8  s3118 = s3112 ^ s3117;+  const SWord16 s3119 = (((SWord16) s3111) << 8) | ((SWord16) s3118);+  const SWord32 s3120 = (((SWord32) s3104) << 16) | ((SWord32) s3119);+  const SWord32 s3121 = s3083 ^ s3120;+  const SWord16 s3122 = (SWord16) s3121;+  const SWord8  s3123 = (SWord8) s3122;+  const SWord32 s3124 = table5[s3123];+  const SWord32 s3125 = s3072 ^ s3124;+  const SWord16 s3126 = (SWord16) (s535 >> 16);+  const SWord8  s3127 = (SWord8) (s3126 >> 8);+  const SWord8  s3128 = table6[s3127];+  const SWord8  s3129 = (SWord8) s3126;+  const SWord8  s3130 = table7[s3129];+  const SWord16 s3131 = (SWord16) s535;+  const SWord8  s3132 = (SWord8) (s3131 >> 8);+  const SWord8  s3133 = table8[s3132];+  const SWord8  s3134 = (SWord8) s3131;+  const SWord8  s3135 = table9[s3134];+  const SWord8  s3136 = s3133 ^ s3135;+  const SWord8  s3137 = s3130 ^ s3136;+  const SWord8  s3138 = s3128 ^ s3137;+  const SWord8  s3139 = table9[s3127];+  const SWord8  s3140 = table6[s3129];+  const SWord8  s3141 = table7[s3132];+  const SWord8  s3142 = table8[s3134];+  const SWord8  s3143 = s3141 ^ s3142;+  const SWord8  s3144 = s3140 ^ s3143;+  const SWord8  s3145 = s3139 ^ s3144;+  const SWord16 s3146 = (((SWord16) s3138) << 8) | ((SWord16) s3145);+  const SWord8  s3147 = table8[s3127];+  const SWord8  s3148 = table9[s3129];+  const SWord8  s3149 = table6[s3132];+  const SWord8  s3150 = table7[s3134];+  const SWord8  s3151 = s3149 ^ s3150;+  const SWord8  s3152 = s3148 ^ s3151;+  const SWord8  s3153 = s3147 ^ s3152;+  const SWord8  s3154 = table7[s3127];+  const SWord8  s3155 = table8[s3129];+  const SWord8  s3156 = table9[s3132];+  const SWord8  s3157 = table6[s3134];+  const SWord8  s3158 = s3156 ^ s3157;+  const SWord8  s3159 = s3155 ^ s3158;+  const SWord8  s3160 = s3154 ^ s3159;+  const SWord16 s3161 = (((SWord16) s3153) << 8) | ((SWord16) s3160);+  const SWord32 s3162 = (((SWord32) s3146) << 16) | ((SWord32) s3161);+  const SWord32 s3163 = s3125 ^ s3162;+  const SWord16 s3164 = (SWord16) (s3163 >> 16);+  const SWord8  s3165 = (SWord8) (s3164 >> 8);+  const SWord8  s3166 = table0[s3165];+  const SWord8  s3167 = (SWord8) (s3014 >> 8);+  const SWord32 s3168 = table1[s3167];+  const SWord16 s3169 = (SWord16) (s3068 >> 16);+  const SWord8  s3170 = (SWord8) s3169;+  const SWord32 s3171 = table3[s3170];+  const SWord32 s3172 = s3168 ^ s3171;+  const SWord8  s3173 = (SWord8) (s3122 >> 8);+  const SWord32 s3174 = table4[s3173];+  const SWord32 s3175 = s3172 ^ s3174;+  const SWord16 s3176 = (SWord16) s2959;+  const SWord8  s3177 = (SWord8) s3176;+  const SWord32 s3178 = table5[s3177];+  const SWord32 s3179 = s3175 ^ s3178;+  const SWord16 s3180 = (SWord16) (s538 >> 16);+  const SWord8  s3181 = (SWord8) (s3180 >> 8);+  const SWord8  s3182 = table6[s3181];+  const SWord8  s3183 = (SWord8) s3180;+  const SWord8  s3184 = table7[s3183];+  const SWord16 s3185 = (SWord16) s538;+  const SWord8  s3186 = (SWord8) (s3185 >> 8);+  const SWord8  s3187 = table8[s3186];+  const SWord8  s3188 = (SWord8) s3185;+  const SWord8  s3189 = table9[s3188];+  const SWord8  s3190 = s3187 ^ s3189;+  const SWord8  s3191 = s3184 ^ s3190;+  const SWord8  s3192 = s3182 ^ s3191;+  const SWord8  s3193 = table9[s3181];+  const SWord8  s3194 = table6[s3183];+  const SWord8  s3195 = table7[s3186];+  const SWord8  s3196 = table8[s3188];+  const SWord8  s3197 = s3195 ^ s3196;+  const SWord8  s3198 = s3194 ^ s3197;+  const SWord8  s3199 = s3193 ^ s3198;+  const SWord16 s3200 = (((SWord16) s3192) << 8) | ((SWord16) s3199);+  const SWord8  s3201 = table8[s3181];+  const SWord8  s3202 = table9[s3183];+  const SWord8  s3203 = table6[s3186];+  const SWord8  s3204 = table7[s3188];+  const SWord8  s3205 = s3203 ^ s3204;+  const SWord8  s3206 = s3202 ^ s3205;+  const SWord8  s3207 = s3201 ^ s3206;+  const SWord8  s3208 = table7[s3181];+  const SWord8  s3209 = table8[s3183];+  const SWord8  s3210 = table9[s3186];+  const SWord8  s3211 = table6[s3188];+  const SWord8  s3212 = s3210 ^ s3211;+  const SWord8  s3213 = s3209 ^ s3212;+  const SWord8  s3214 = s3208 ^ s3213;+  const SWord16 s3215 = (((SWord16) s3207) << 8) | ((SWord16) s3214);+  const SWord32 s3216 = (((SWord32) s3200) << 16) | ((SWord32) s3215);+  const SWord32 s3217 = s3179 ^ s3216;+  const SWord16 s3218 = (SWord16) (s3217 >> 16);+  const SWord8  s3219 = (SWord8) s3218;+  const SWord8  s3220 = table0[s3219];+  const SWord16 s3221 = (((SWord16) s3166) << 8) | ((SWord16) s3220);+  const SWord8  s3222 = (SWord8) (s3169 >> 8);+  const SWord32 s3223 = table1[s3222];+  const SWord16 s3224 = (SWord16) (s3121 >> 16);+  const SWord8  s3225 = (SWord8) s3224;+  const SWord32 s3226 = table3[s3225];+  const SWord32 s3227 = s3223 ^ s3226;+  const SWord8  s3228 = (SWord8) (s3176 >> 8);+  const SWord32 s3229 = table4[s3228];+  const SWord32 s3230 = s3227 ^ s3229;+  const SWord16 s3231 = (SWord16) s3013;+  const SWord8  s3232 = (SWord8) s3231;+  const SWord32 s3233 = table5[s3232];+  const SWord32 s3234 = s3230 ^ s3233;+  const SWord16 s3235 = (SWord16) (s537 >> 16);+  const SWord8  s3236 = (SWord8) (s3235 >> 8);+  const SWord8  s3237 = table6[s3236];+  const SWord8  s3238 = (SWord8) s3235;+  const SWord8  s3239 = table7[s3238];+  const SWord16 s3240 = (SWord16) s537;+  const SWord8  s3241 = (SWord8) (s3240 >> 8);+  const SWord8  s3242 = table8[s3241];+  const SWord8  s3243 = (SWord8) s3240;+  const SWord8  s3244 = table9[s3243];+  const SWord8  s3245 = s3242 ^ s3244;+  const SWord8  s3246 = s3239 ^ s3245;+  const SWord8  s3247 = s3237 ^ s3246;+  const SWord8  s3248 = table9[s3236];+  const SWord8  s3249 = table6[s3238];+  const SWord8  s3250 = table7[s3241];+  const SWord8  s3251 = table8[s3243];+  const SWord8  s3252 = s3250 ^ s3251;+  const SWord8  s3253 = s3249 ^ s3252;+  const SWord8  s3254 = s3248 ^ s3253;+  const SWord16 s3255 = (((SWord16) s3247) << 8) | ((SWord16) s3254);+  const SWord8  s3256 = table8[s3236];+  const SWord8  s3257 = table9[s3238];+  const SWord8  s3258 = table6[s3241];+  const SWord8  s3259 = table7[s3243];+  const SWord8  s3260 = s3258 ^ s3259;+  const SWord8  s3261 = s3257 ^ s3260;+  const SWord8  s3262 = s3256 ^ s3261;+  const SWord8  s3263 = table7[s3236];+  const SWord8  s3264 = table8[s3238];+  const SWord8  s3265 = table9[s3241];+  const SWord8  s3266 = table6[s3243];+  const SWord8  s3267 = s3265 ^ s3266;+  const SWord8  s3268 = s3264 ^ s3267;+  const SWord8  s3269 = s3263 ^ s3268;+  const SWord16 s3270 = (((SWord16) s3262) << 8) | ((SWord16) s3269);+  const SWord32 s3271 = (((SWord32) s3255) << 16) | ((SWord32) s3270);+  const SWord32 s3272 = s3234 ^ s3271;+  const SWord16 s3273 = (SWord16) s3272;+  const SWord8  s3274 = (SWord8) (s3273 >> 8);+  const SWord8  s3275 = table0[s3274];+  const SWord8  s3276 = (SWord8) (s3224 >> 8);+  const SWord32 s3277 = table1[s3276];+  const SWord8  s3278 = (SWord8) s2960;+  const SWord32 s3279 = table3[s3278];+  const SWord32 s3280 = s3277 ^ s3279;+  const SWord8  s3281 = (SWord8) (s3231 >> 8);+  const SWord32 s3282 = table4[s3281];+  const SWord32 s3283 = s3280 ^ s3282;+  const SWord8  s3284 = (SWord8) s3069;+  const SWord32 s3285 = table5[s3284];+  const SWord32 s3286 = s3283 ^ s3285;+  const SWord16 s3287 = (SWord16) (s536 >> 16);+  const SWord8  s3288 = (SWord8) (s3287 >> 8);+  const SWord8  s3289 = table6[s3288];+  const SWord8  s3290 = (SWord8) s3287;+  const SWord8  s3291 = table7[s3290];+  const SWord16 s3292 = (SWord16) s536;+  const SWord8  s3293 = (SWord8) (s3292 >> 8);+  const SWord8  s3294 = table8[s3293];+  const SWord8  s3295 = (SWord8) s3292;+  const SWord8  s3296 = table9[s3295];+  const SWord8  s3297 = s3294 ^ s3296;+  const SWord8  s3298 = s3291 ^ s3297;+  const SWord8  s3299 = s3289 ^ s3298;+  const SWord8  s3300 = table9[s3288];+  const SWord8  s3301 = table6[s3290];+  const SWord8  s3302 = table7[s3293];+  const SWord8  s3303 = table8[s3295];+  const SWord8  s3304 = s3302 ^ s3303;+  const SWord8  s3305 = s3301 ^ s3304;+  const SWord8  s3306 = s3300 ^ s3305;+  const SWord16 s3307 = (((SWord16) s3299) << 8) | ((SWord16) s3306);+  const SWord8  s3308 = table8[s3288];+  const SWord8  s3309 = table9[s3290];+  const SWord8  s3310 = table6[s3293];+  const SWord8  s3311 = table7[s3295];+  const SWord8  s3312 = s3310 ^ s3311;+  const SWord8  s3313 = s3309 ^ s3312;+  const SWord8  s3314 = s3308 ^ s3313;+  const SWord8  s3315 = table7[s3288];+  const SWord8  s3316 = table8[s3290];+  const SWord8  s3317 = table9[s3293];+  const SWord8  s3318 = table6[s3295];+  const SWord8  s3319 = s3317 ^ s3318;+  const SWord8  s3320 = s3316 ^ s3319;+  const SWord8  s3321 = s3315 ^ s3320;+  const SWord16 s3322 = (((SWord16) s3314) << 8) | ((SWord16) s3321);+  const SWord32 s3323 = (((SWord32) s3307) << 16) | ((SWord32) s3322);+  const SWord32 s3324 = s3286 ^ s3323;+  const SWord16 s3325 = (SWord16) s3324;+  const SWord8  s3326 = (SWord8) s3325;+  const SWord8  s3327 = table0[s3326];+  const SWord16 s3328 = (((SWord16) s3275) << 8) | ((SWord16) s3327);+  const SWord32 s3329 = (((SWord32) s3221) << 16) | ((SWord32) s3328);+  const SWord32 s3330 = s4 ^ s3329;+  const SWord16 s3331 = (SWord16) (s3324 >> 16);+  const SWord8  s3332 = (SWord8) (s3331 >> 8);+  const SWord8  s3333 = table0[s3332];+  const SWord8  s3334 = (SWord8) s3164;+  const SWord8  s3335 = table0[s3334];+  const SWord16 s3336 = (((SWord16) s3333) << 8) | ((SWord16) s3335);+  const SWord16 s3337 = (SWord16) s3217;+  const SWord8  s3338 = (SWord8) (s3337 >> 8);+  const SWord8  s3339 = table0[s3338];+  const SWord8  s3340 = (SWord8) s3273;+  const SWord8  s3341 = table0[s3340];+  const SWord16 s3342 = (((SWord16) s3339) << 8) | ((SWord16) s3341);+  const SWord32 s3343 = (((SWord32) s3336) << 16) | ((SWord32) s3342);+  const SWord32 s3344 = s5 ^ s3343;+  const SWord16 s3345 = (SWord16) (s3272 >> 16);+  const SWord8  s3346 = (SWord8) (s3345 >> 8);+  const SWord8  s3347 = table0[s3346];+  const SWord8  s3348 = (SWord8) s3331;+  const SWord8  s3349 = table0[s3348];+  const SWord16 s3350 = (((SWord16) s3347) << 8) | ((SWord16) s3349);+  const SWord16 s3351 = (SWord16) s3163;+  const SWord8  s3352 = (SWord8) (s3351 >> 8);+  const SWord8  s3353 = table0[s3352];+  const SWord8  s3354 = (SWord8) s3337;+  const SWord8  s3355 = table0[s3354];+  const SWord16 s3356 = (((SWord16) s3353) << 8) | ((SWord16) s3355);+  const SWord32 s3357 = (((SWord32) s3350) << 16) | ((SWord32) s3356);+  const SWord32 s3358 = s6 ^ s3357;+  const SWord8  s3359 = (SWord8) (s3218 >> 8);+  const SWord8  s3360 = table0[s3359];+  const SWord8  s3361 = (SWord8) s3345;+  const SWord8  s3362 = table0[s3361];+  const SWord16 s3363 = (((SWord16) s3360) << 8) | ((SWord16) s3362);+  const SWord8  s3364 = (SWord8) (s3325 >> 8);+  const SWord8  s3365 = table0[s3364];+  const SWord8  s3366 = (SWord8) s3351;+  const SWord8  s3367 = table0[s3366];+  const SWord16 s3368 = (((SWord16) s3365) << 8) | ((SWord16) s3367);+  const SWord32 s3369 = (((SWord32) s3363) << 16) | ((SWord32) s3368);+  const SWord32 s3370 = s7 ^ s3369;++  ct[0] = s3330;+  ct[1] = s3344;+  ct[2] = s3358;+  ct[3] = s3370;+}+== END: "aes128Dec.c" ==================
+ SBVTestSuite/GoldFiles/aes128Enc.gold view
@@ -0,0 +1,1167 @@+== BEGIN: "Makefile" ================+# Makefile for aes128Enc. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: aes128Enc_driver++aes128Enc.o: aes128Enc.c aes128Enc.h+	${CC} ${CCFLAGS} -c $< -o $@++aes128Enc_driver.o: aes128Enc_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++aes128Enc_driver: aes128Enc.o aes128Enc_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f aes128Enc_driver+== END: "Makefile" ==================+== BEGIN: "aes128Enc.h" ================+/* Header file for aes128Enc. Automatically generated by SBV. Do not edit! */++#ifndef __aes128Enc__HEADER_INCLUDED__+#define __aes128Enc__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+void aes128Enc(const SWord32 *pt, const SWord32 *key, SWord32 *ct);++#endif /* __aes128Enc__HEADER_INCLUDED__ */+== END: "aes128Enc.h" ==================+== BEGIN: "aes128Enc_driver.c" ================+/* Example driver program for aes128Enc. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "aes128Enc.h"++int main(void)+{+  const SWord32 pt[4] = {+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL+  };++  printf("Contents of input array pt:\n");+  int pt_ctr;+  for(pt_ctr = 0; pt_ctr < 4 ; ++pt_ctr)+    printf("  pt[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]);++  const SWord32 key[4] = {+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL+  };++  printf("Contents of input array key:\n");+  int key_ctr;+  for(key_ctr = 0; key_ctr < 4 ; ++key_ctr)+    printf("  key[%d] = 0x%08"PRIx32"UL\n", key_ctr ,key[key_ctr]);++  SWord32 ct[4];++  aes128Enc(pt, key, ct);++  printf("aes128Enc(pt, key, ct) ->\n");+  int ct_ctr;+  for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr)+    printf("  ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]);++  return 0;+}+== END: "aes128Enc_driver.c" ==================+== BEGIN: "aes128Enc.c" ================+/* File: "aes128Enc.c". Automatically generated by SBV. Do not edit! */++#include "aes128Enc.h"++void aes128Enc(const SWord32 *pt, const SWord32 *key, SWord32 *ct)+{+  const SWord32 s0 = pt[0];+  const SWord32 s1 = pt[1];+  const SWord32 s2 = pt[2];+  const SWord32 s3 = pt[3];+  const SWord32 s4 = key[0];+  const SWord32 s5 = key[1];+  const SWord32 s6 = key[2];+  const SWord32 s7 = key[3];+  static const SWord8 table0[] = {+       99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254,+      215, 171, 118, 202, 130, 201, 125, 250,  89,  71, 240, 173, 212,+      162, 175, 156, 164, 114, 192, 183, 253, 147,  38,  54,  63, 247,+      204,  52, 165, 229, 241, 113, 216,  49,  21,   4, 199,  35, 195,+       24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,   9,+      131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,+       47, 132,  83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,+       57,  74,  76,  88, 207, 208, 239, 170, 251,  67,  77,  51, 133,+       69, 249,   2, 127,  80,  60, 159, 168,  81, 163,  64, 143, 146,+      157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210, 205,  12,+       19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25,+      115,  96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20,+      222,  94,  11, 219, 224,  50,  58,  10,  73,   6,  36,  92, 194,+      211, 172,  98, 145, 149, 228, 121, 231, 200,  55, 109, 141, 213,+       78, 169, 108,  86, 244, 234, 101, 122, 174,   8, 186, 120,  37,+       46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,+      112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134,+      193,  29, 158, 225, 248, 152,  17, 105, 217, 142, 148, 155,  30,+      135, 233, 206,  85,  40, 223, 140, 161, 137,  13, 191, 230,  66,+      104,  65, 153,  45,  15, 176,  84, 187,  22+  };+  static const SWord32 table1[] = {+      0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL,+      0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL,+      0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL,+      0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL,+      0x8fcaca45UL, 0x1f82829dUL, 0x89c9c940UL, 0xfa7d7d87UL,+      0xeffafa15UL, 0xb25959ebUL, 0x8e4747c9UL, 0xfbf0f00bUL,+      0x41adadecUL, 0xb3d4d467UL, 0x5fa2a2fdUL, 0x45afafeaUL,+      0x239c9cbfUL, 0x53a4a4f7UL, 0xe4727296UL, 0x9bc0c05bUL,+      0x75b7b7c2UL, 0xe1fdfd1cUL, 0x3d9393aeUL, 0x4c26266aUL,+      0x6c36365aUL, 0x7e3f3f41UL, 0xf5f7f702UL, 0x83cccc4fUL,+      0x6834345cUL, 0x51a5a5f4UL, 0xd1e5e534UL, 0xf9f1f108UL,+      0xe2717193UL, 0xabd8d873UL, 0x62313153UL, 0x2a15153fUL,+      0x0804040cUL, 0x95c7c752UL, 0x46232365UL, 0x9dc3c35eUL,+      0x30181828UL, 0x379696a1UL, 0x0a05050fUL, 0x2f9a9ab5UL,+      0x0e070709UL, 0x24121236UL, 0x1b80809bUL, 0xdfe2e23dUL,+      0xcdebeb26UL, 0x4e272769UL, 0x7fb2b2cdUL, 0xea75759fUL,+      0x1209091bUL, 0x1d83839eUL, 0x582c2c74UL, 0x341a1a2eUL,+      0x361b1b2dUL, 0xdc6e6eb2UL, 0xb45a5aeeUL, 0x5ba0a0fbUL,+      0xa45252f6UL, 0x763b3b4dUL, 0xb7d6d661UL, 0x7db3b3ceUL,+      0x5229297bUL, 0xdde3e33eUL, 0x5e2f2f71UL, 0x13848497UL,+      0xa65353f5UL, 0xb9d1d168UL, 0x00000000UL, 0xc1eded2cUL,+      0x40202060UL, 0xe3fcfc1fUL, 0x79b1b1c8UL, 0xb65b5bedUL,+      0xd46a6abeUL, 0x8dcbcb46UL, 0x67bebed9UL, 0x7239394bUL,+      0x944a4adeUL, 0x984c4cd4UL, 0xb05858e8UL, 0x85cfcf4aUL,+      0xbbd0d06bUL, 0xc5efef2aUL, 0x4faaaae5UL, 0xedfbfb16UL,+      0x864343c5UL, 0x9a4d4dd7UL, 0x66333355UL, 0x11858594UL,+      0x8a4545cfUL, 0xe9f9f910UL, 0x04020206UL, 0xfe7f7f81UL,+      0xa05050f0UL, 0x783c3c44UL, 0x259f9fbaUL, 0x4ba8a8e3UL,+      0xa25151f3UL, 0x5da3a3feUL, 0x804040c0UL, 0x058f8f8aUL,+      0x3f9292adUL, 0x219d9dbcUL, 0x70383848UL, 0xf1f5f504UL,+      0x63bcbcdfUL, 0x77b6b6c1UL, 0xafdada75UL, 0x42212163UL,+      0x20101030UL, 0xe5ffff1aUL, 0xfdf3f30eUL, 0xbfd2d26dUL,+      0x81cdcd4cUL, 0x180c0c14UL, 0x26131335UL, 0xc3ecec2fUL,+      0xbe5f5fe1UL, 0x359797a2UL, 0x884444ccUL, 0x2e171739UL,+      0x93c4c457UL, 0x55a7a7f2UL, 0xfc7e7e82UL, 0x7a3d3d47UL,+      0xc86464acUL, 0xba5d5de7UL, 0x3219192bUL, 0xe6737395UL,+      0xc06060a0UL, 0x19818198UL, 0x9e4f4fd1UL, 0xa3dcdc7fUL,+      0x44222266UL, 0x542a2a7eUL, 0x3b9090abUL, 0x0b888883UL,+      0x8c4646caUL, 0xc7eeee29UL, 0x6bb8b8d3UL, 0x2814143cUL,+      0xa7dede79UL, 0xbc5e5ee2UL, 0x160b0b1dUL, 0xaddbdb76UL,+      0xdbe0e03bUL, 0x64323256UL, 0x743a3a4eUL, 0x140a0a1eUL,+      0x924949dbUL, 0x0c06060aUL, 0x4824246cUL, 0xb85c5ce4UL,+      0x9fc2c25dUL, 0xbdd3d36eUL, 0x43acacefUL, 0xc46262a6UL,+      0x399191a8UL, 0x319595a4UL, 0xd3e4e437UL, 0xf279798bUL,+      0xd5e7e732UL, 0x8bc8c843UL, 0x6e373759UL, 0xda6d6db7UL,+      0x018d8d8cUL, 0xb1d5d564UL, 0x9c4e4ed2UL, 0x49a9a9e0UL,+      0xd86c6cb4UL, 0xac5656faUL, 0xf3f4f407UL, 0xcfeaea25UL,+      0xca6565afUL, 0xf47a7a8eUL, 0x47aeaee9UL, 0x10080818UL,+      0x6fbabad5UL, 0xf0787888UL, 0x4a25256fUL, 0x5c2e2e72UL,+      0x381c1c24UL, 0x57a6a6f1UL, 0x73b4b4c7UL, 0x97c6c651UL,+      0xcbe8e823UL, 0xa1dddd7cUL, 0xe874749cUL, 0x3e1f1f21UL,+      0x964b4bddUL, 0x61bdbddcUL, 0x0d8b8b86UL, 0x0f8a8a85UL,+      0xe0707090UL, 0x7c3e3e42UL, 0x71b5b5c4UL, 0xcc6666aaUL,+      0x904848d8UL, 0x06030305UL, 0xf7f6f601UL, 0x1c0e0e12UL,+      0xc26161a3UL, 0x6a35355fUL, 0xae5757f9UL, 0x69b9b9d0UL,+      0x17868691UL, 0x99c1c158UL, 0x3a1d1d27UL, 0x279e9eb9UL,+      0xd9e1e138UL, 0xebf8f813UL, 0x2b9898b3UL, 0x22111133UL,+      0xd26969bbUL, 0xa9d9d970UL, 0x078e8e89UL, 0x339494a7UL,+      0x2d9b9bb6UL, 0x3c1e1e22UL, 0x15878792UL, 0xc9e9e920UL,+      0x87cece49UL, 0xaa5555ffUL, 0x50282878UL, 0xa5dfdf7aUL,+      0x038c8c8fUL, 0x59a1a1f8UL, 0x09898980UL, 0x1a0d0d17UL,+      0x65bfbfdaUL, 0xd7e6e631UL, 0x844242c6UL, 0xd06868b8UL,+      0x824141c3UL, 0x299999b0UL, 0x5a2d2d77UL, 0x1e0f0f11UL,+      0x7bb0b0cbUL, 0xa85454fcUL, 0x6dbbbbd6UL, 0x2c16163aUL+  };+  static const SWord32 table2[] = {+      0xa5c66363UL, 0x84f87c7cUL, 0x99ee7777UL, 0x8df67b7bUL,+      0x0dfff2f2UL, 0xbdd66b6bUL, 0xb1de6f6fUL, 0x5491c5c5UL,+      0x50603030UL, 0x03020101UL, 0xa9ce6767UL, 0x7d562b2bUL,+      0x19e7fefeUL, 0x62b5d7d7UL, 0xe64dababUL, 0x9aec7676UL,+      0x458fcacaUL, 0x9d1f8282UL, 0x4089c9c9UL, 0x87fa7d7dUL,+      0x15effafaUL, 0xebb25959UL, 0xc98e4747UL, 0x0bfbf0f0UL,+      0xec41adadUL, 0x67b3d4d4UL, 0xfd5fa2a2UL, 0xea45afafUL,+      0xbf239c9cUL, 0xf753a4a4UL, 0x96e47272UL, 0x5b9bc0c0UL,+      0xc275b7b7UL, 0x1ce1fdfdUL, 0xae3d9393UL, 0x6a4c2626UL,+      0x5a6c3636UL, 0x417e3f3fUL, 0x02f5f7f7UL, 0x4f83ccccUL,+      0x5c683434UL, 0xf451a5a5UL, 0x34d1e5e5UL, 0x08f9f1f1UL,+      0x93e27171UL, 0x73abd8d8UL, 0x53623131UL, 0x3f2a1515UL,+      0x0c080404UL, 0x5295c7c7UL, 0x65462323UL, 0x5e9dc3c3UL,+      0x28301818UL, 0xa1379696UL, 0x0f0a0505UL, 0xb52f9a9aUL,+      0x090e0707UL, 0x36241212UL, 0x9b1b8080UL, 0x3ddfe2e2UL,+      0x26cdebebUL, 0x694e2727UL, 0xcd7fb2b2UL, 0x9fea7575UL,+      0x1b120909UL, 0x9e1d8383UL, 0x74582c2cUL, 0x2e341a1aUL,+      0x2d361b1bUL, 0xb2dc6e6eUL, 0xeeb45a5aUL, 0xfb5ba0a0UL,+      0xf6a45252UL, 0x4d763b3bUL, 0x61b7d6d6UL, 0xce7db3b3UL,+      0x7b522929UL, 0x3edde3e3UL, 0x715e2f2fUL, 0x97138484UL,+      0xf5a65353UL, 0x68b9d1d1UL, 0x00000000UL, 0x2cc1ededUL,+      0x60402020UL, 0x1fe3fcfcUL, 0xc879b1b1UL, 0xedb65b5bUL,+      0xbed46a6aUL, 0x468dcbcbUL, 0xd967bebeUL, 0x4b723939UL,+      0xde944a4aUL, 0xd4984c4cUL, 0xe8b05858UL, 0x4a85cfcfUL,+      0x6bbbd0d0UL, 0x2ac5efefUL, 0xe54faaaaUL, 0x16edfbfbUL,+      0xc5864343UL, 0xd79a4d4dUL, 0x55663333UL, 0x94118585UL,+      0xcf8a4545UL, 0x10e9f9f9UL, 0x06040202UL, 0x81fe7f7fUL,+      0xf0a05050UL, 0x44783c3cUL, 0xba259f9fUL, 0xe34ba8a8UL,+      0xf3a25151UL, 0xfe5da3a3UL, 0xc0804040UL, 0x8a058f8fUL,+      0xad3f9292UL, 0xbc219d9dUL, 0x48703838UL, 0x04f1f5f5UL,+      0xdf63bcbcUL, 0xc177b6b6UL, 0x75afdadaUL, 0x63422121UL,+      0x30201010UL, 0x1ae5ffffUL, 0x0efdf3f3UL, 0x6dbfd2d2UL,+      0x4c81cdcdUL, 0x14180c0cUL, 0x35261313UL, 0x2fc3ececUL,+      0xe1be5f5fUL, 0xa2359797UL, 0xcc884444UL, 0x392e1717UL,+      0x5793c4c4UL, 0xf255a7a7UL, 0x82fc7e7eUL, 0x477a3d3dUL,+      0xacc86464UL, 0xe7ba5d5dUL, 0x2b321919UL, 0x95e67373UL,+      0xa0c06060UL, 0x98198181UL, 0xd19e4f4fUL, 0x7fa3dcdcUL,+      0x66442222UL, 0x7e542a2aUL, 0xab3b9090UL, 0x830b8888UL,+      0xca8c4646UL, 0x29c7eeeeUL, 0xd36bb8b8UL, 0x3c281414UL,+      0x79a7dedeUL, 0xe2bc5e5eUL, 0x1d160b0bUL, 0x76addbdbUL,+      0x3bdbe0e0UL, 0x56643232UL, 0x4e743a3aUL, 0x1e140a0aUL,+      0xdb924949UL, 0x0a0c0606UL, 0x6c482424UL, 0xe4b85c5cUL,+      0x5d9fc2c2UL, 0x6ebdd3d3UL, 0xef43acacUL, 0xa6c46262UL,+      0xa8399191UL, 0xa4319595UL, 0x37d3e4e4UL, 0x8bf27979UL,+      0x32d5e7e7UL, 0x438bc8c8UL, 0x596e3737UL, 0xb7da6d6dUL,+      0x8c018d8dUL, 0x64b1d5d5UL, 0xd29c4e4eUL, 0xe049a9a9UL,+      0xb4d86c6cUL, 0xfaac5656UL, 0x07f3f4f4UL, 0x25cfeaeaUL,+      0xafca6565UL, 0x8ef47a7aUL, 0xe947aeaeUL, 0x18100808UL,+      0xd56fbabaUL, 0x88f07878UL, 0x6f4a2525UL, 0x725c2e2eUL,+      0x24381c1cUL, 0xf157a6a6UL, 0xc773b4b4UL, 0x5197c6c6UL,+      0x23cbe8e8UL, 0x7ca1ddddUL, 0x9ce87474UL, 0x213e1f1fUL,+      0xdd964b4bUL, 0xdc61bdbdUL, 0x860d8b8bUL, 0x850f8a8aUL,+      0x90e07070UL, 0x427c3e3eUL, 0xc471b5b5UL, 0xaacc6666UL,+      0xd8904848UL, 0x05060303UL, 0x01f7f6f6UL, 0x121c0e0eUL,+      0xa3c26161UL, 0x5f6a3535UL, 0xf9ae5757UL, 0xd069b9b9UL,+      0x91178686UL, 0x5899c1c1UL, 0x273a1d1dUL, 0xb9279e9eUL,+      0x38d9e1e1UL, 0x13ebf8f8UL, 0xb32b9898UL, 0x33221111UL,+      0xbbd26969UL, 0x70a9d9d9UL, 0x89078e8eUL, 0xa7339494UL,+      0xb62d9b9bUL, 0x223c1e1eUL, 0x92158787UL, 0x20c9e9e9UL,+      0x4987ceceUL, 0xffaa5555UL, 0x78502828UL, 0x7aa5dfdfUL,+      0x8f038c8cUL, 0xf859a1a1UL, 0x80098989UL, 0x171a0d0dUL,+      0xda65bfbfUL, 0x31d7e6e6UL, 0xc6844242UL, 0xb8d06868UL,+      0xc3824141UL, 0xb0299999UL, 0x775a2d2dUL, 0x111e0f0fUL,+      0xcb7bb0b0UL, 0xfca85454UL, 0xd66dbbbbUL, 0x3a2c1616UL+  };+  static const SWord32 table3[] = {+      0x63a5c663UL, 0x7c84f87cUL, 0x7799ee77UL, 0x7b8df67bUL,+      0xf20dfff2UL, 0x6bbdd66bUL, 0x6fb1de6fUL, 0xc55491c5UL,+      0x30506030UL, 0x01030201UL, 0x67a9ce67UL, 0x2b7d562bUL,+      0xfe19e7feUL, 0xd762b5d7UL, 0xabe64dabUL, 0x769aec76UL,+      0xca458fcaUL, 0x829d1f82UL, 0xc94089c9UL, 0x7d87fa7dUL,+      0xfa15effaUL, 0x59ebb259UL, 0x47c98e47UL, 0xf00bfbf0UL,+      0xadec41adUL, 0xd467b3d4UL, 0xa2fd5fa2UL, 0xafea45afUL,+      0x9cbf239cUL, 0xa4f753a4UL, 0x7296e472UL, 0xc05b9bc0UL,+      0xb7c275b7UL, 0xfd1ce1fdUL, 0x93ae3d93UL, 0x266a4c26UL,+      0x365a6c36UL, 0x3f417e3fUL, 0xf702f5f7UL, 0xcc4f83ccUL,+      0x345c6834UL, 0xa5f451a5UL, 0xe534d1e5UL, 0xf108f9f1UL,+      0x7193e271UL, 0xd873abd8UL, 0x31536231UL, 0x153f2a15UL,+      0x040c0804UL, 0xc75295c7UL, 0x23654623UL, 0xc35e9dc3UL,+      0x18283018UL, 0x96a13796UL, 0x050f0a05UL, 0x9ab52f9aUL,+      0x07090e07UL, 0x12362412UL, 0x809b1b80UL, 0xe23ddfe2UL,+      0xeb26cdebUL, 0x27694e27UL, 0xb2cd7fb2UL, 0x759fea75UL,+      0x091b1209UL, 0x839e1d83UL, 0x2c74582cUL, 0x1a2e341aUL,+      0x1b2d361bUL, 0x6eb2dc6eUL, 0x5aeeb45aUL, 0xa0fb5ba0UL,+      0x52f6a452UL, 0x3b4d763bUL, 0xd661b7d6UL, 0xb3ce7db3UL,+      0x297b5229UL, 0xe33edde3UL, 0x2f715e2fUL, 0x84971384UL,+      0x53f5a653UL, 0xd168b9d1UL, 0x00000000UL, 0xed2cc1edUL,+      0x20604020UL, 0xfc1fe3fcUL, 0xb1c879b1UL, 0x5bedb65bUL,+      0x6abed46aUL, 0xcb468dcbUL, 0xbed967beUL, 0x394b7239UL,+      0x4ade944aUL, 0x4cd4984cUL, 0x58e8b058UL, 0xcf4a85cfUL,+      0xd06bbbd0UL, 0xef2ac5efUL, 0xaae54faaUL, 0xfb16edfbUL,+      0x43c58643UL, 0x4dd79a4dUL, 0x33556633UL, 0x85941185UL,+      0x45cf8a45UL, 0xf910e9f9UL, 0x02060402UL, 0x7f81fe7fUL,+      0x50f0a050UL, 0x3c44783cUL, 0x9fba259fUL, 0xa8e34ba8UL,+      0x51f3a251UL, 0xa3fe5da3UL, 0x40c08040UL, 0x8f8a058fUL,+      0x92ad3f92UL, 0x9dbc219dUL, 0x38487038UL, 0xf504f1f5UL,+      0xbcdf63bcUL, 0xb6c177b6UL, 0xda75afdaUL, 0x21634221UL,+      0x10302010UL, 0xff1ae5ffUL, 0xf30efdf3UL, 0xd26dbfd2UL,+      0xcd4c81cdUL, 0x0c14180cUL, 0x13352613UL, 0xec2fc3ecUL,+      0x5fe1be5fUL, 0x97a23597UL, 0x44cc8844UL, 0x17392e17UL,+      0xc45793c4UL, 0xa7f255a7UL, 0x7e82fc7eUL, 0x3d477a3dUL,+      0x64acc864UL, 0x5de7ba5dUL, 0x192b3219UL, 0x7395e673UL,+      0x60a0c060UL, 0x81981981UL, 0x4fd19e4fUL, 0xdc7fa3dcUL,+      0x22664422UL, 0x2a7e542aUL, 0x90ab3b90UL, 0x88830b88UL,+      0x46ca8c46UL, 0xee29c7eeUL, 0xb8d36bb8UL, 0x143c2814UL,+      0xde79a7deUL, 0x5ee2bc5eUL, 0x0b1d160bUL, 0xdb76addbUL,+      0xe03bdbe0UL, 0x32566432UL, 0x3a4e743aUL, 0x0a1e140aUL,+      0x49db9249UL, 0x060a0c06UL, 0x246c4824UL, 0x5ce4b85cUL,+      0xc25d9fc2UL, 0xd36ebdd3UL, 0xacef43acUL, 0x62a6c462UL,+      0x91a83991UL, 0x95a43195UL, 0xe437d3e4UL, 0x798bf279UL,+      0xe732d5e7UL, 0xc8438bc8UL, 0x37596e37UL, 0x6db7da6dUL,+      0x8d8c018dUL, 0xd564b1d5UL, 0x4ed29c4eUL, 0xa9e049a9UL,+      0x6cb4d86cUL, 0x56faac56UL, 0xf407f3f4UL, 0xea25cfeaUL,+      0x65afca65UL, 0x7a8ef47aUL, 0xaee947aeUL, 0x08181008UL,+      0xbad56fbaUL, 0x7888f078UL, 0x256f4a25UL, 0x2e725c2eUL,+      0x1c24381cUL, 0xa6f157a6UL, 0xb4c773b4UL, 0xc65197c6UL,+      0xe823cbe8UL, 0xdd7ca1ddUL, 0x749ce874UL, 0x1f213e1fUL,+      0x4bdd964bUL, 0xbddc61bdUL, 0x8b860d8bUL, 0x8a850f8aUL,+      0x7090e070UL, 0x3e427c3eUL, 0xb5c471b5UL, 0x66aacc66UL,+      0x48d89048UL, 0x03050603UL, 0xf601f7f6UL, 0x0e121c0eUL,+      0x61a3c261UL, 0x355f6a35UL, 0x57f9ae57UL, 0xb9d069b9UL,+      0x86911786UL, 0xc15899c1UL, 0x1d273a1dUL, 0x9eb9279eUL,+      0xe138d9e1UL, 0xf813ebf8UL, 0x98b32b98UL, 0x11332211UL,+      0x69bbd269UL, 0xd970a9d9UL, 0x8e89078eUL, 0x94a73394UL,+      0x9bb62d9bUL, 0x1e223c1eUL, 0x87921587UL, 0xe920c9e9UL,+      0xce4987ceUL, 0x55ffaa55UL, 0x28785028UL, 0xdf7aa5dfUL,+      0x8c8f038cUL, 0xa1f859a1UL, 0x89800989UL, 0x0d171a0dUL,+      0xbfda65bfUL, 0xe631d7e6UL, 0x42c68442UL, 0x68b8d068UL,+      0x41c38241UL, 0x99b02999UL, 0x2d775a2dUL, 0x0f111e0fUL,+      0xb0cb7bb0UL, 0x54fca854UL, 0xbbd66dbbUL, 0x163a2c16UL+  };+  static const SWord32 table4[] = {+      0x6363a5c6UL, 0x7c7c84f8UL, 0x777799eeUL, 0x7b7b8df6UL,+      0xf2f20dffUL, 0x6b6bbdd6UL, 0x6f6fb1deUL, 0xc5c55491UL,+      0x30305060UL, 0x01010302UL, 0x6767a9ceUL, 0x2b2b7d56UL,+      0xfefe19e7UL, 0xd7d762b5UL, 0xababe64dUL, 0x76769aecUL,+      0xcaca458fUL, 0x82829d1fUL, 0xc9c94089UL, 0x7d7d87faUL,+      0xfafa15efUL, 0x5959ebb2UL, 0x4747c98eUL, 0xf0f00bfbUL,+      0xadadec41UL, 0xd4d467b3UL, 0xa2a2fd5fUL, 0xafafea45UL,+      0x9c9cbf23UL, 0xa4a4f753UL, 0x727296e4UL, 0xc0c05b9bUL,+      0xb7b7c275UL, 0xfdfd1ce1UL, 0x9393ae3dUL, 0x26266a4cUL,+      0x36365a6cUL, 0x3f3f417eUL, 0xf7f702f5UL, 0xcccc4f83UL,+      0x34345c68UL, 0xa5a5f451UL, 0xe5e534d1UL, 0xf1f108f9UL,+      0x717193e2UL, 0xd8d873abUL, 0x31315362UL, 0x15153f2aUL,+      0x04040c08UL, 0xc7c75295UL, 0x23236546UL, 0xc3c35e9dUL,+      0x18182830UL, 0x9696a137UL, 0x05050f0aUL, 0x9a9ab52fUL,+      0x0707090eUL, 0x12123624UL, 0x80809b1bUL, 0xe2e23ddfUL,+      0xebeb26cdUL, 0x2727694eUL, 0xb2b2cd7fUL, 0x75759feaUL,+      0x09091b12UL, 0x83839e1dUL, 0x2c2c7458UL, 0x1a1a2e34UL,+      0x1b1b2d36UL, 0x6e6eb2dcUL, 0x5a5aeeb4UL, 0xa0a0fb5bUL,+      0x5252f6a4UL, 0x3b3b4d76UL, 0xd6d661b7UL, 0xb3b3ce7dUL,+      0x29297b52UL, 0xe3e33eddUL, 0x2f2f715eUL, 0x84849713UL,+      0x5353f5a6UL, 0xd1d168b9UL, 0x00000000UL, 0xeded2cc1UL,+      0x20206040UL, 0xfcfc1fe3UL, 0xb1b1c879UL, 0x5b5bedb6UL,+      0x6a6abed4UL, 0xcbcb468dUL, 0xbebed967UL, 0x39394b72UL,+      0x4a4ade94UL, 0x4c4cd498UL, 0x5858e8b0UL, 0xcfcf4a85UL,+      0xd0d06bbbUL, 0xefef2ac5UL, 0xaaaae54fUL, 0xfbfb16edUL,+      0x4343c586UL, 0x4d4dd79aUL, 0x33335566UL, 0x85859411UL,+      0x4545cf8aUL, 0xf9f910e9UL, 0x02020604UL, 0x7f7f81feUL,+      0x5050f0a0UL, 0x3c3c4478UL, 0x9f9fba25UL, 0xa8a8e34bUL,+      0x5151f3a2UL, 0xa3a3fe5dUL, 0x4040c080UL, 0x8f8f8a05UL,+      0x9292ad3fUL, 0x9d9dbc21UL, 0x38384870UL, 0xf5f504f1UL,+      0xbcbcdf63UL, 0xb6b6c177UL, 0xdada75afUL, 0x21216342UL,+      0x10103020UL, 0xffff1ae5UL, 0xf3f30efdUL, 0xd2d26dbfUL,+      0xcdcd4c81UL, 0x0c0c1418UL, 0x13133526UL, 0xecec2fc3UL,+      0x5f5fe1beUL, 0x9797a235UL, 0x4444cc88UL, 0x1717392eUL,+      0xc4c45793UL, 0xa7a7f255UL, 0x7e7e82fcUL, 0x3d3d477aUL,+      0x6464acc8UL, 0x5d5de7baUL, 0x19192b32UL, 0x737395e6UL,+      0x6060a0c0UL, 0x81819819UL, 0x4f4fd19eUL, 0xdcdc7fa3UL,+      0x22226644UL, 0x2a2a7e54UL, 0x9090ab3bUL, 0x8888830bUL,+      0x4646ca8cUL, 0xeeee29c7UL, 0xb8b8d36bUL, 0x14143c28UL,+      0xdede79a7UL, 0x5e5ee2bcUL, 0x0b0b1d16UL, 0xdbdb76adUL,+      0xe0e03bdbUL, 0x32325664UL, 0x3a3a4e74UL, 0x0a0a1e14UL,+      0x4949db92UL, 0x06060a0cUL, 0x24246c48UL, 0x5c5ce4b8UL,+      0xc2c25d9fUL, 0xd3d36ebdUL, 0xacacef43UL, 0x6262a6c4UL,+      0x9191a839UL, 0x9595a431UL, 0xe4e437d3UL, 0x79798bf2UL,+      0xe7e732d5UL, 0xc8c8438bUL, 0x3737596eUL, 0x6d6db7daUL,+      0x8d8d8c01UL, 0xd5d564b1UL, 0x4e4ed29cUL, 0xa9a9e049UL,+      0x6c6cb4d8UL, 0x5656faacUL, 0xf4f407f3UL, 0xeaea25cfUL,+      0x6565afcaUL, 0x7a7a8ef4UL, 0xaeaee947UL, 0x08081810UL,+      0xbabad56fUL, 0x787888f0UL, 0x25256f4aUL, 0x2e2e725cUL,+      0x1c1c2438UL, 0xa6a6f157UL, 0xb4b4c773UL, 0xc6c65197UL,+      0xe8e823cbUL, 0xdddd7ca1UL, 0x74749ce8UL, 0x1f1f213eUL,+      0x4b4bdd96UL, 0xbdbddc61UL, 0x8b8b860dUL, 0x8a8a850fUL,+      0x707090e0UL, 0x3e3e427cUL, 0xb5b5c471UL, 0x6666aaccUL,+      0x4848d890UL, 0x03030506UL, 0xf6f601f7UL, 0x0e0e121cUL,+      0x6161a3c2UL, 0x35355f6aUL, 0x5757f9aeUL, 0xb9b9d069UL,+      0x86869117UL, 0xc1c15899UL, 0x1d1d273aUL, 0x9e9eb927UL,+      0xe1e138d9UL, 0xf8f813ebUL, 0x9898b32bUL, 0x11113322UL,+      0x6969bbd2UL, 0xd9d970a9UL, 0x8e8e8907UL, 0x9494a733UL,+      0x9b9bb62dUL, 0x1e1e223cUL, 0x87879215UL, 0xe9e920c9UL,+      0xcece4987UL, 0x5555ffaaUL, 0x28287850UL, 0xdfdf7aa5UL,+      0x8c8c8f03UL, 0xa1a1f859UL, 0x89898009UL, 0x0d0d171aUL,+      0xbfbfda65UL, 0xe6e631d7UL, 0x4242c684UL, 0x6868b8d0UL,+      0x4141c382UL, 0x9999b029UL, 0x2d2d775aUL, 0x0f0f111eUL,+      0xb0b0cb7bUL, 0x5454fca8UL, 0xbbbbd66dUL, 0x16163a2cUL+  };+  const SWord32 s520 = s0 ^ s4;+  const SWord16 s521 = (SWord16) (s520 >> 16);+  const SWord8  s522 = (SWord8) (s521 >> 8);+  const SWord32 s523 = table1[s522];+  const SWord32 s779 = s1 ^ s5;+  const SWord16 s780 = (SWord16) (s779 >> 16);+  const SWord8  s781 = (SWord8) s780;+  const SWord32 s782 = table2[s781];+  const SWord32 s783 = s523 ^ s782;+  const SWord32 s1039 = s2 ^ s6;+  const SWord16 s1040 = (SWord16) s1039;+  const SWord8  s1041 = (SWord8) (s1040 >> 8);+  const SWord32 s1042 = table3[s1041];+  const SWord32 s1043 = s783 ^ s1042;+  const SWord32 s1299 = s3 ^ s7;+  const SWord16 s1300 = (SWord16) s1299;+  const SWord8  s1301 = (SWord8) s1300;+  const SWord32 s1302 = table4[s1301];+  const SWord32 s1303 = s1043 ^ s1302;+  const SWord32 s1304 = (s7 << 8) | (s7 >> 24);+  const SWord16 s1305 = (SWord16) (s1304 >> 16);+  const SWord8  s1306 = (SWord8) (s1305 >> 8);+  const SWord8  s1307 = table0[s1306];+  const SWord8  s1308 = 1 ^ s1307;+  const SWord8  s1309 = (SWord8) s1305;+  const SWord8  s1310 = table0[s1309];+  const SWord16 s1311 = (((SWord16) s1308) << 8) | ((SWord16) s1310);+  const SWord16 s1312 = (SWord16) s1304;+  const SWord8  s1313 = (SWord8) (s1312 >> 8);+  const SWord8  s1314 = table0[s1313];+  const SWord8  s1315 = (SWord8) s1312;+  const SWord8  s1316 = table0[s1315];+  const SWord16 s1317 = (((SWord16) s1314) << 8) | ((SWord16) s1316);+  const SWord32 s1318 = (((SWord32) s1311) << 16) | ((SWord32) s1317);+  const SWord32 s1319 = s4 ^ s1318;+  const SWord32 s1320 = s1303 ^ s1319;+  const SWord16 s1321 = (SWord16) (s1320 >> 16);+  const SWord8  s1322 = (SWord8) (s1321 >> 8);+  const SWord32 s1323 = table1[s1322];+  const SWord8  s1324 = (SWord8) (s780 >> 8);+  const SWord32 s1325 = table1[s1324];+  const SWord16 s1326 = (SWord16) (s1039 >> 16);+  const SWord8  s1327 = (SWord8) s1326;+  const SWord32 s1328 = table2[s1327];+  const SWord32 s1329 = s1325 ^ s1328;+  const SWord8  s1330 = (SWord8) (s1300 >> 8);+  const SWord32 s1331 = table3[s1330];+  const SWord32 s1332 = s1329 ^ s1331;+  const SWord16 s1333 = (SWord16) s520;+  const SWord8  s1334 = (SWord8) s1333;+  const SWord32 s1335 = table4[s1334];+  const SWord32 s1336 = s1332 ^ s1335;+  const SWord32 s1337 = s5 ^ s1319;+  const SWord32 s1338 = s1336 ^ s1337;+  const SWord16 s1339 = (SWord16) (s1338 >> 16);+  const SWord8  s1340 = (SWord8) s1339;+  const SWord32 s1341 = table2[s1340];+  const SWord32 s1342 = s1323 ^ s1341;+  const SWord8  s1343 = (SWord8) (s1326 >> 8);+  const SWord32 s1344 = table1[s1343];+  const SWord16 s1345 = (SWord16) (s1299 >> 16);+  const SWord8  s1346 = (SWord8) s1345;+  const SWord32 s1347 = table2[s1346];+  const SWord32 s1348 = s1344 ^ s1347;+  const SWord8  s1349 = (SWord8) (s1333 >> 8);+  const SWord32 s1350 = table3[s1349];+  const SWord32 s1351 = s1348 ^ s1350;+  const SWord16 s1352 = (SWord16) s779;+  const SWord8  s1353 = (SWord8) s1352;+  const SWord32 s1354 = table4[s1353];+  const SWord32 s1355 = s1351 ^ s1354;+  const SWord32 s1356 = s6 ^ s1337;+  const SWord32 s1357 = s1355 ^ s1356;+  const SWord16 s1358 = (SWord16) s1357;+  const SWord8  s1359 = (SWord8) (s1358 >> 8);+  const SWord32 s1360 = table3[s1359];+  const SWord32 s1361 = s1342 ^ s1360;+  const SWord8  s1362 = (SWord8) (s1345 >> 8);+  const SWord32 s1363 = table1[s1362];+  const SWord8  s1364 = (SWord8) s521;+  const SWord32 s1365 = table2[s1364];+  const SWord32 s1366 = s1363 ^ s1365;+  const SWord8  s1367 = (SWord8) (s1352 >> 8);+  const SWord32 s1368 = table3[s1367];+  const SWord32 s1369 = s1366 ^ s1368;+  const SWord8  s1370 = (SWord8) s1040;+  const SWord32 s1371 = table4[s1370];+  const SWord32 s1372 = s1369 ^ s1371;+  const SWord32 s1373 = s7 ^ s1356;+  const SWord32 s1374 = s1372 ^ s1373;+  const SWord16 s1375 = (SWord16) s1374;+  const SWord8  s1376 = (SWord8) s1375;+  const SWord32 s1377 = table4[s1376];+  const SWord32 s1378 = s1361 ^ s1377;+  const SWord32 s1379 = (s1373 << 8) | (s1373 >> 24);+  const SWord16 s1380 = (SWord16) (s1379 >> 16);+  const SWord8  s1381 = (SWord8) (s1380 >> 8);+  const SWord8  s1382 = table0[s1381];+  const SWord8  s1383 = 2 ^ s1382;+  const SWord8  s1384 = (SWord8) s1380;+  const SWord8  s1385 = table0[s1384];+  const SWord16 s1386 = (((SWord16) s1383) << 8) | ((SWord16) s1385);+  const SWord16 s1387 = (SWord16) s1379;+  const SWord8  s1388 = (SWord8) (s1387 >> 8);+  const SWord8  s1389 = table0[s1388];+  const SWord8  s1390 = (SWord8) s1387;+  const SWord8  s1391 = table0[s1390];+  const SWord16 s1392 = (((SWord16) s1389) << 8) | ((SWord16) s1391);+  const SWord32 s1393 = (((SWord32) s1386) << 16) | ((SWord32) s1392);+  const SWord32 s1394 = s1319 ^ s1393;+  const SWord32 s1395 = s1378 ^ s1394;+  const SWord16 s1396 = (SWord16) (s1395 >> 16);+  const SWord8  s1397 = (SWord8) (s1396 >> 8);+  const SWord32 s1398 = table1[s1397];+  const SWord8  s1399 = (SWord8) (s1339 >> 8);+  const SWord32 s1400 = table1[s1399];+  const SWord16 s1401 = (SWord16) (s1357 >> 16);+  const SWord8  s1402 = (SWord8) s1401;+  const SWord32 s1403 = table2[s1402];+  const SWord32 s1404 = s1400 ^ s1403;+  const SWord8  s1405 = (SWord8) (s1375 >> 8);+  const SWord32 s1406 = table3[s1405];+  const SWord32 s1407 = s1404 ^ s1406;+  const SWord16 s1408 = (SWord16) s1320;+  const SWord8  s1409 = (SWord8) s1408;+  const SWord32 s1410 = table4[s1409];+  const SWord32 s1411 = s1407 ^ s1410;+  const SWord32 s1412 = s1337 ^ s1394;+  const SWord32 s1413 = s1411 ^ s1412;+  const SWord16 s1414 = (SWord16) (s1413 >> 16);+  const SWord8  s1415 = (SWord8) s1414;+  const SWord32 s1416 = table2[s1415];+  const SWord32 s1417 = s1398 ^ s1416;+  const SWord8  s1418 = (SWord8) (s1401 >> 8);+  const SWord32 s1419 = table1[s1418];+  const SWord16 s1420 = (SWord16) (s1374 >> 16);+  const SWord8  s1421 = (SWord8) s1420;+  const SWord32 s1422 = table2[s1421];+  const SWord32 s1423 = s1419 ^ s1422;+  const SWord8  s1424 = (SWord8) (s1408 >> 8);+  const SWord32 s1425 = table3[s1424];+  const SWord32 s1426 = s1423 ^ s1425;+  const SWord16 s1427 = (SWord16) s1338;+  const SWord8  s1428 = (SWord8) s1427;+  const SWord32 s1429 = table4[s1428];+  const SWord32 s1430 = s1426 ^ s1429;+  const SWord32 s1431 = s1356 ^ s1412;+  const SWord32 s1432 = s1430 ^ s1431;+  const SWord16 s1433 = (SWord16) s1432;+  const SWord8  s1434 = (SWord8) (s1433 >> 8);+  const SWord32 s1435 = table3[s1434];+  const SWord32 s1436 = s1417 ^ s1435;+  const SWord8  s1437 = (SWord8) (s1420 >> 8);+  const SWord32 s1438 = table1[s1437];+  const SWord8  s1439 = (SWord8) s1321;+  const SWord32 s1440 = table2[s1439];+  const SWord32 s1441 = s1438 ^ s1440;+  const SWord8  s1442 = (SWord8) (s1427 >> 8);+  const SWord32 s1443 = table3[s1442];+  const SWord32 s1444 = s1441 ^ s1443;+  const SWord8  s1445 = (SWord8) s1358;+  const SWord32 s1446 = table4[s1445];+  const SWord32 s1447 = s1444 ^ s1446;+  const SWord32 s1448 = s1373 ^ s1431;+  const SWord32 s1449 = s1447 ^ s1448;+  const SWord16 s1450 = (SWord16) s1449;+  const SWord8  s1451 = (SWord8) s1450;+  const SWord32 s1452 = table4[s1451];+  const SWord32 s1453 = s1436 ^ s1452;+  const SWord32 s1454 = (s1448 << 8) | (s1448 >> 24);+  const SWord16 s1455 = (SWord16) (s1454 >> 16);+  const SWord8  s1456 = (SWord8) (s1455 >> 8);+  const SWord8  s1457 = table0[s1456];+  const SWord8  s1458 = 4 ^ s1457;+  const SWord8  s1459 = (SWord8) s1455;+  const SWord8  s1460 = table0[s1459];+  const SWord16 s1461 = (((SWord16) s1458) << 8) | ((SWord16) s1460);+  const SWord16 s1462 = (SWord16) s1454;+  const SWord8  s1463 = (SWord8) (s1462 >> 8);+  const SWord8  s1464 = table0[s1463];+  const SWord8  s1465 = (SWord8) s1462;+  const SWord8  s1466 = table0[s1465];+  const SWord16 s1467 = (((SWord16) s1464) << 8) | ((SWord16) s1466);+  const SWord32 s1468 = (((SWord32) s1461) << 16) | ((SWord32) s1467);+  const SWord32 s1469 = s1394 ^ s1468;+  const SWord32 s1470 = s1453 ^ s1469;+  const SWord16 s1471 = (SWord16) (s1470 >> 16);+  const SWord8  s1472 = (SWord8) (s1471 >> 8);+  const SWord32 s1473 = table1[s1472];+  const SWord8  s1474 = (SWord8) (s1414 >> 8);+  const SWord32 s1475 = table1[s1474];+  const SWord16 s1476 = (SWord16) (s1432 >> 16);+  const SWord8  s1477 = (SWord8) s1476;+  const SWord32 s1478 = table2[s1477];+  const SWord32 s1479 = s1475 ^ s1478;+  const SWord8  s1480 = (SWord8) (s1450 >> 8);+  const SWord32 s1481 = table3[s1480];+  const SWord32 s1482 = s1479 ^ s1481;+  const SWord16 s1483 = (SWord16) s1395;+  const SWord8  s1484 = (SWord8) s1483;+  const SWord32 s1485 = table4[s1484];+  const SWord32 s1486 = s1482 ^ s1485;+  const SWord32 s1487 = s1412 ^ s1469;+  const SWord32 s1488 = s1486 ^ s1487;+  const SWord16 s1489 = (SWord16) (s1488 >> 16);+  const SWord8  s1490 = (SWord8) s1489;+  const SWord32 s1491 = table2[s1490];+  const SWord32 s1492 = s1473 ^ s1491;+  const SWord8  s1493 = (SWord8) (s1476 >> 8);+  const SWord32 s1494 = table1[s1493];+  const SWord16 s1495 = (SWord16) (s1449 >> 16);+  const SWord8  s1496 = (SWord8) s1495;+  const SWord32 s1497 = table2[s1496];+  const SWord32 s1498 = s1494 ^ s1497;+  const SWord8  s1499 = (SWord8) (s1483 >> 8);+  const SWord32 s1500 = table3[s1499];+  const SWord32 s1501 = s1498 ^ s1500;+  const SWord16 s1502 = (SWord16) s1413;+  const SWord8  s1503 = (SWord8) s1502;+  const SWord32 s1504 = table4[s1503];+  const SWord32 s1505 = s1501 ^ s1504;+  const SWord32 s1506 = s1431 ^ s1487;+  const SWord32 s1507 = s1505 ^ s1506;+  const SWord16 s1508 = (SWord16) s1507;+  const SWord8  s1509 = (SWord8) (s1508 >> 8);+  const SWord32 s1510 = table3[s1509];+  const SWord32 s1511 = s1492 ^ s1510;+  const SWord8  s1512 = (SWord8) (s1495 >> 8);+  const SWord32 s1513 = table1[s1512];+  const SWord8  s1514 = (SWord8) s1396;+  const SWord32 s1515 = table2[s1514];+  const SWord32 s1516 = s1513 ^ s1515;+  const SWord8  s1517 = (SWord8) (s1502 >> 8);+  const SWord32 s1518 = table3[s1517];+  const SWord32 s1519 = s1516 ^ s1518;+  const SWord8  s1520 = (SWord8) s1433;+  const SWord32 s1521 = table4[s1520];+  const SWord32 s1522 = s1519 ^ s1521;+  const SWord32 s1523 = s1448 ^ s1506;+  const SWord32 s1524 = s1522 ^ s1523;+  const SWord16 s1525 = (SWord16) s1524;+  const SWord8  s1526 = (SWord8) s1525;+  const SWord32 s1527 = table4[s1526];+  const SWord32 s1528 = s1511 ^ s1527;+  const SWord32 s1529 = (s1523 << 8) | (s1523 >> 24);+  const SWord16 s1530 = (SWord16) (s1529 >> 16);+  const SWord8  s1531 = (SWord8) (s1530 >> 8);+  const SWord8  s1532 = table0[s1531];+  const SWord8  s1533 = 8 ^ s1532;+  const SWord8  s1534 = (SWord8) s1530;+  const SWord8  s1535 = table0[s1534];+  const SWord16 s1536 = (((SWord16) s1533) << 8) | ((SWord16) s1535);+  const SWord16 s1537 = (SWord16) s1529;+  const SWord8  s1538 = (SWord8) (s1537 >> 8);+  const SWord8  s1539 = table0[s1538];+  const SWord8  s1540 = (SWord8) s1537;+  const SWord8  s1541 = table0[s1540];+  const SWord16 s1542 = (((SWord16) s1539) << 8) | ((SWord16) s1541);+  const SWord32 s1543 = (((SWord32) s1536) << 16) | ((SWord32) s1542);+  const SWord32 s1544 = s1469 ^ s1543;+  const SWord32 s1545 = s1528 ^ s1544;+  const SWord16 s1546 = (SWord16) (s1545 >> 16);+  const SWord8  s1547 = (SWord8) (s1546 >> 8);+  const SWord32 s1548 = table1[s1547];+  const SWord8  s1549 = (SWord8) (s1489 >> 8);+  const SWord32 s1550 = table1[s1549];+  const SWord16 s1551 = (SWord16) (s1507 >> 16);+  const SWord8  s1552 = (SWord8) s1551;+  const SWord32 s1553 = table2[s1552];+  const SWord32 s1554 = s1550 ^ s1553;+  const SWord8  s1555 = (SWord8) (s1525 >> 8);+  const SWord32 s1556 = table3[s1555];+  const SWord32 s1557 = s1554 ^ s1556;+  const SWord16 s1558 = (SWord16) s1470;+  const SWord8  s1559 = (SWord8) s1558;+  const SWord32 s1560 = table4[s1559];+  const SWord32 s1561 = s1557 ^ s1560;+  const SWord32 s1562 = s1487 ^ s1544;+  const SWord32 s1563 = s1561 ^ s1562;+  const SWord16 s1564 = (SWord16) (s1563 >> 16);+  const SWord8  s1565 = (SWord8) s1564;+  const SWord32 s1566 = table2[s1565];+  const SWord32 s1567 = s1548 ^ s1566;+  const SWord8  s1568 = (SWord8) (s1551 >> 8);+  const SWord32 s1569 = table1[s1568];+  const SWord16 s1570 = (SWord16) (s1524 >> 16);+  const SWord8  s1571 = (SWord8) s1570;+  const SWord32 s1572 = table2[s1571];+  const SWord32 s1573 = s1569 ^ s1572;+  const SWord8  s1574 = (SWord8) (s1558 >> 8);+  const SWord32 s1575 = table3[s1574];+  const SWord32 s1576 = s1573 ^ s1575;+  const SWord16 s1577 = (SWord16) s1488;+  const SWord8  s1578 = (SWord8) s1577;+  const SWord32 s1579 = table4[s1578];+  const SWord32 s1580 = s1576 ^ s1579;+  const SWord32 s1581 = s1506 ^ s1562;+  const SWord32 s1582 = s1580 ^ s1581;+  const SWord16 s1583 = (SWord16) s1582;+  const SWord8  s1584 = (SWord8) (s1583 >> 8);+  const SWord32 s1585 = table3[s1584];+  const SWord32 s1586 = s1567 ^ s1585;+  const SWord8  s1587 = (SWord8) (s1570 >> 8);+  const SWord32 s1588 = table1[s1587];+  const SWord8  s1589 = (SWord8) s1471;+  const SWord32 s1590 = table2[s1589];+  const SWord32 s1591 = s1588 ^ s1590;+  const SWord8  s1592 = (SWord8) (s1577 >> 8);+  const SWord32 s1593 = table3[s1592];+  const SWord32 s1594 = s1591 ^ s1593;+  const SWord8  s1595 = (SWord8) s1508;+  const SWord32 s1596 = table4[s1595];+  const SWord32 s1597 = s1594 ^ s1596;+  const SWord32 s1598 = s1523 ^ s1581;+  const SWord32 s1599 = s1597 ^ s1598;+  const SWord16 s1600 = (SWord16) s1599;+  const SWord8  s1601 = (SWord8) s1600;+  const SWord32 s1602 = table4[s1601];+  const SWord32 s1603 = s1586 ^ s1602;+  const SWord32 s1604 = (s1598 << 8) | (s1598 >> 24);+  const SWord16 s1605 = (SWord16) (s1604 >> 16);+  const SWord8  s1606 = (SWord8) (s1605 >> 8);+  const SWord8  s1607 = table0[s1606];+  const SWord8  s1608 = 16 ^ s1607;+  const SWord8  s1609 = (SWord8) s1605;+  const SWord8  s1610 = table0[s1609];+  const SWord16 s1611 = (((SWord16) s1608) << 8) | ((SWord16) s1610);+  const SWord16 s1612 = (SWord16) s1604;+  const SWord8  s1613 = (SWord8) (s1612 >> 8);+  const SWord8  s1614 = table0[s1613];+  const SWord8  s1615 = (SWord8) s1612;+  const SWord8  s1616 = table0[s1615];+  const SWord16 s1617 = (((SWord16) s1614) << 8) | ((SWord16) s1616);+  const SWord32 s1618 = (((SWord32) s1611) << 16) | ((SWord32) s1617);+  const SWord32 s1619 = s1544 ^ s1618;+  const SWord32 s1620 = s1603 ^ s1619;+  const SWord16 s1621 = (SWord16) (s1620 >> 16);+  const SWord8  s1622 = (SWord8) (s1621 >> 8);+  const SWord32 s1623 = table1[s1622];+  const SWord8  s1624 = (SWord8) (s1564 >> 8);+  const SWord32 s1625 = table1[s1624];+  const SWord16 s1626 = (SWord16) (s1582 >> 16);+  const SWord8  s1627 = (SWord8) s1626;+  const SWord32 s1628 = table2[s1627];+  const SWord32 s1629 = s1625 ^ s1628;+  const SWord8  s1630 = (SWord8) (s1600 >> 8);+  const SWord32 s1631 = table3[s1630];+  const SWord32 s1632 = s1629 ^ s1631;+  const SWord16 s1633 = (SWord16) s1545;+  const SWord8  s1634 = (SWord8) s1633;+  const SWord32 s1635 = table4[s1634];+  const SWord32 s1636 = s1632 ^ s1635;+  const SWord32 s1637 = s1562 ^ s1619;+  const SWord32 s1638 = s1636 ^ s1637;+  const SWord16 s1639 = (SWord16) (s1638 >> 16);+  const SWord8  s1640 = (SWord8) s1639;+  const SWord32 s1641 = table2[s1640];+  const SWord32 s1642 = s1623 ^ s1641;+  const SWord8  s1643 = (SWord8) (s1626 >> 8);+  const SWord32 s1644 = table1[s1643];+  const SWord16 s1645 = (SWord16) (s1599 >> 16);+  const SWord8  s1646 = (SWord8) s1645;+  const SWord32 s1647 = table2[s1646];+  const SWord32 s1648 = s1644 ^ s1647;+  const SWord8  s1649 = (SWord8) (s1633 >> 8);+  const SWord32 s1650 = table3[s1649];+  const SWord32 s1651 = s1648 ^ s1650;+  const SWord16 s1652 = (SWord16) s1563;+  const SWord8  s1653 = (SWord8) s1652;+  const SWord32 s1654 = table4[s1653];+  const SWord32 s1655 = s1651 ^ s1654;+  const SWord32 s1656 = s1581 ^ s1637;+  const SWord32 s1657 = s1655 ^ s1656;+  const SWord16 s1658 = (SWord16) s1657;+  const SWord8  s1659 = (SWord8) (s1658 >> 8);+  const SWord32 s1660 = table3[s1659];+  const SWord32 s1661 = s1642 ^ s1660;+  const SWord8  s1662 = (SWord8) (s1645 >> 8);+  const SWord32 s1663 = table1[s1662];+  const SWord8  s1664 = (SWord8) s1546;+  const SWord32 s1665 = table2[s1664];+  const SWord32 s1666 = s1663 ^ s1665;+  const SWord8  s1667 = (SWord8) (s1652 >> 8);+  const SWord32 s1668 = table3[s1667];+  const SWord32 s1669 = s1666 ^ s1668;+  const SWord8  s1670 = (SWord8) s1583;+  const SWord32 s1671 = table4[s1670];+  const SWord32 s1672 = s1669 ^ s1671;+  const SWord32 s1673 = s1598 ^ s1656;+  const SWord32 s1674 = s1672 ^ s1673;+  const SWord16 s1675 = (SWord16) s1674;+  const SWord8  s1676 = (SWord8) s1675;+  const SWord32 s1677 = table4[s1676];+  const SWord32 s1678 = s1661 ^ s1677;+  const SWord32 s1679 = (s1673 << 8) | (s1673 >> 24);+  const SWord16 s1680 = (SWord16) (s1679 >> 16);+  const SWord8  s1681 = (SWord8) (s1680 >> 8);+  const SWord8  s1682 = table0[s1681];+  const SWord8  s1683 = 32 ^ s1682;+  const SWord8  s1684 = (SWord8) s1680;+  const SWord8  s1685 = table0[s1684];+  const SWord16 s1686 = (((SWord16) s1683) << 8) | ((SWord16) s1685);+  const SWord16 s1687 = (SWord16) s1679;+  const SWord8  s1688 = (SWord8) (s1687 >> 8);+  const SWord8  s1689 = table0[s1688];+  const SWord8  s1690 = (SWord8) s1687;+  const SWord8  s1691 = table0[s1690];+  const SWord16 s1692 = (((SWord16) s1689) << 8) | ((SWord16) s1691);+  const SWord32 s1693 = (((SWord32) s1686) << 16) | ((SWord32) s1692);+  const SWord32 s1694 = s1619 ^ s1693;+  const SWord32 s1695 = s1678 ^ s1694;+  const SWord16 s1696 = (SWord16) (s1695 >> 16);+  const SWord8  s1697 = (SWord8) (s1696 >> 8);+  const SWord32 s1698 = table1[s1697];+  const SWord8  s1699 = (SWord8) (s1639 >> 8);+  const SWord32 s1700 = table1[s1699];+  const SWord16 s1701 = (SWord16) (s1657 >> 16);+  const SWord8  s1702 = (SWord8) s1701;+  const SWord32 s1703 = table2[s1702];+  const SWord32 s1704 = s1700 ^ s1703;+  const SWord8  s1705 = (SWord8) (s1675 >> 8);+  const SWord32 s1706 = table3[s1705];+  const SWord32 s1707 = s1704 ^ s1706;+  const SWord16 s1708 = (SWord16) s1620;+  const SWord8  s1709 = (SWord8) s1708;+  const SWord32 s1710 = table4[s1709];+  const SWord32 s1711 = s1707 ^ s1710;+  const SWord32 s1712 = s1637 ^ s1694;+  const SWord32 s1713 = s1711 ^ s1712;+  const SWord16 s1714 = (SWord16) (s1713 >> 16);+  const SWord8  s1715 = (SWord8) s1714;+  const SWord32 s1716 = table2[s1715];+  const SWord32 s1717 = s1698 ^ s1716;+  const SWord8  s1718 = (SWord8) (s1701 >> 8);+  const SWord32 s1719 = table1[s1718];+  const SWord16 s1720 = (SWord16) (s1674 >> 16);+  const SWord8  s1721 = (SWord8) s1720;+  const SWord32 s1722 = table2[s1721];+  const SWord32 s1723 = s1719 ^ s1722;+  const SWord8  s1724 = (SWord8) (s1708 >> 8);+  const SWord32 s1725 = table3[s1724];+  const SWord32 s1726 = s1723 ^ s1725;+  const SWord16 s1727 = (SWord16) s1638;+  const SWord8  s1728 = (SWord8) s1727;+  const SWord32 s1729 = table4[s1728];+  const SWord32 s1730 = s1726 ^ s1729;+  const SWord32 s1731 = s1656 ^ s1712;+  const SWord32 s1732 = s1730 ^ s1731;+  const SWord16 s1733 = (SWord16) s1732;+  const SWord8  s1734 = (SWord8) (s1733 >> 8);+  const SWord32 s1735 = table3[s1734];+  const SWord32 s1736 = s1717 ^ s1735;+  const SWord8  s1737 = (SWord8) (s1720 >> 8);+  const SWord32 s1738 = table1[s1737];+  const SWord8  s1739 = (SWord8) s1621;+  const SWord32 s1740 = table2[s1739];+  const SWord32 s1741 = s1738 ^ s1740;+  const SWord8  s1742 = (SWord8) (s1727 >> 8);+  const SWord32 s1743 = table3[s1742];+  const SWord32 s1744 = s1741 ^ s1743;+  const SWord8  s1745 = (SWord8) s1658;+  const SWord32 s1746 = table4[s1745];+  const SWord32 s1747 = s1744 ^ s1746;+  const SWord32 s1748 = s1673 ^ s1731;+  const SWord32 s1749 = s1747 ^ s1748;+  const SWord16 s1750 = (SWord16) s1749;+  const SWord8  s1751 = (SWord8) s1750;+  const SWord32 s1752 = table4[s1751];+  const SWord32 s1753 = s1736 ^ s1752;+  const SWord32 s1754 = (s1748 << 8) | (s1748 >> 24);+  const SWord16 s1755 = (SWord16) (s1754 >> 16);+  const SWord8  s1756 = (SWord8) (s1755 >> 8);+  const SWord8  s1757 = table0[s1756];+  const SWord8  s1758 = 64 ^ s1757;+  const SWord8  s1759 = (SWord8) s1755;+  const SWord8  s1760 = table0[s1759];+  const SWord16 s1761 = (((SWord16) s1758) << 8) | ((SWord16) s1760);+  const SWord16 s1762 = (SWord16) s1754;+  const SWord8  s1763 = (SWord8) (s1762 >> 8);+  const SWord8  s1764 = table0[s1763];+  const SWord8  s1765 = (SWord8) s1762;+  const SWord8  s1766 = table0[s1765];+  const SWord16 s1767 = (((SWord16) s1764) << 8) | ((SWord16) s1766);+  const SWord32 s1768 = (((SWord32) s1761) << 16) | ((SWord32) s1767);+  const SWord32 s1769 = s1694 ^ s1768;+  const SWord32 s1770 = s1753 ^ s1769;+  const SWord16 s1771 = (SWord16) (s1770 >> 16);+  const SWord8  s1772 = (SWord8) (s1771 >> 8);+  const SWord32 s1773 = table1[s1772];+  const SWord8  s1774 = (SWord8) (s1714 >> 8);+  const SWord32 s1775 = table1[s1774];+  const SWord16 s1776 = (SWord16) (s1732 >> 16);+  const SWord8  s1777 = (SWord8) s1776;+  const SWord32 s1778 = table2[s1777];+  const SWord32 s1779 = s1775 ^ s1778;+  const SWord8  s1780 = (SWord8) (s1750 >> 8);+  const SWord32 s1781 = table3[s1780];+  const SWord32 s1782 = s1779 ^ s1781;+  const SWord16 s1783 = (SWord16) s1695;+  const SWord8  s1784 = (SWord8) s1783;+  const SWord32 s1785 = table4[s1784];+  const SWord32 s1786 = s1782 ^ s1785;+  const SWord32 s1787 = s1712 ^ s1769;+  const SWord32 s1788 = s1786 ^ s1787;+  const SWord16 s1789 = (SWord16) (s1788 >> 16);+  const SWord8  s1790 = (SWord8) s1789;+  const SWord32 s1791 = table2[s1790];+  const SWord32 s1792 = s1773 ^ s1791;+  const SWord8  s1793 = (SWord8) (s1776 >> 8);+  const SWord32 s1794 = table1[s1793];+  const SWord16 s1795 = (SWord16) (s1749 >> 16);+  const SWord8  s1796 = (SWord8) s1795;+  const SWord32 s1797 = table2[s1796];+  const SWord32 s1798 = s1794 ^ s1797;+  const SWord8  s1799 = (SWord8) (s1783 >> 8);+  const SWord32 s1800 = table3[s1799];+  const SWord32 s1801 = s1798 ^ s1800;+  const SWord16 s1802 = (SWord16) s1713;+  const SWord8  s1803 = (SWord8) s1802;+  const SWord32 s1804 = table4[s1803];+  const SWord32 s1805 = s1801 ^ s1804;+  const SWord32 s1806 = s1731 ^ s1787;+  const SWord32 s1807 = s1805 ^ s1806;+  const SWord16 s1808 = (SWord16) s1807;+  const SWord8  s1809 = (SWord8) (s1808 >> 8);+  const SWord32 s1810 = table3[s1809];+  const SWord32 s1811 = s1792 ^ s1810;+  const SWord8  s1812 = (SWord8) (s1795 >> 8);+  const SWord32 s1813 = table1[s1812];+  const SWord8  s1814 = (SWord8) s1696;+  const SWord32 s1815 = table2[s1814];+  const SWord32 s1816 = s1813 ^ s1815;+  const SWord8  s1817 = (SWord8) (s1802 >> 8);+  const SWord32 s1818 = table3[s1817];+  const SWord32 s1819 = s1816 ^ s1818;+  const SWord8  s1820 = (SWord8) s1733;+  const SWord32 s1821 = table4[s1820];+  const SWord32 s1822 = s1819 ^ s1821;+  const SWord32 s1823 = s1748 ^ s1806;+  const SWord32 s1824 = s1822 ^ s1823;+  const SWord16 s1825 = (SWord16) s1824;+  const SWord8  s1826 = (SWord8) s1825;+  const SWord32 s1827 = table4[s1826];+  const SWord32 s1828 = s1811 ^ s1827;+  const SWord32 s1829 = (s1823 << 8) | (s1823 >> 24);+  const SWord16 s1830 = (SWord16) (s1829 >> 16);+  const SWord8  s1831 = (SWord8) (s1830 >> 8);+  const SWord8  s1832 = table0[s1831];+  const SWord8  s1833 = 128 ^ s1832;+  const SWord8  s1834 = (SWord8) s1830;+  const SWord8  s1835 = table0[s1834];+  const SWord16 s1836 = (((SWord16) s1833) << 8) | ((SWord16) s1835);+  const SWord16 s1837 = (SWord16) s1829;+  const SWord8  s1838 = (SWord8) (s1837 >> 8);+  const SWord8  s1839 = table0[s1838];+  const SWord8  s1840 = (SWord8) s1837;+  const SWord8  s1841 = table0[s1840];+  const SWord16 s1842 = (((SWord16) s1839) << 8) | ((SWord16) s1841);+  const SWord32 s1843 = (((SWord32) s1836) << 16) | ((SWord32) s1842);+  const SWord32 s1844 = s1769 ^ s1843;+  const SWord32 s1845 = s1828 ^ s1844;+  const SWord16 s1846 = (SWord16) (s1845 >> 16);+  const SWord8  s1847 = (SWord8) (s1846 >> 8);+  const SWord32 s1848 = table1[s1847];+  const SWord8  s1849 = (SWord8) (s1789 >> 8);+  const SWord32 s1850 = table1[s1849];+  const SWord16 s1851 = (SWord16) (s1807 >> 16);+  const SWord8  s1852 = (SWord8) s1851;+  const SWord32 s1853 = table2[s1852];+  const SWord32 s1854 = s1850 ^ s1853;+  const SWord8  s1855 = (SWord8) (s1825 >> 8);+  const SWord32 s1856 = table3[s1855];+  const SWord32 s1857 = s1854 ^ s1856;+  const SWord16 s1858 = (SWord16) s1770;+  const SWord8  s1859 = (SWord8) s1858;+  const SWord32 s1860 = table4[s1859];+  const SWord32 s1861 = s1857 ^ s1860;+  const SWord32 s1862 = s1787 ^ s1844;+  const SWord32 s1863 = s1861 ^ s1862;+  const SWord16 s1864 = (SWord16) (s1863 >> 16);+  const SWord8  s1865 = (SWord8) s1864;+  const SWord32 s1866 = table2[s1865];+  const SWord32 s1867 = s1848 ^ s1866;+  const SWord8  s1868 = (SWord8) (s1851 >> 8);+  const SWord32 s1869 = table1[s1868];+  const SWord16 s1870 = (SWord16) (s1824 >> 16);+  const SWord8  s1871 = (SWord8) s1870;+  const SWord32 s1872 = table2[s1871];+  const SWord32 s1873 = s1869 ^ s1872;+  const SWord8  s1874 = (SWord8) (s1858 >> 8);+  const SWord32 s1875 = table3[s1874];+  const SWord32 s1876 = s1873 ^ s1875;+  const SWord16 s1877 = (SWord16) s1788;+  const SWord8  s1878 = (SWord8) s1877;+  const SWord32 s1879 = table4[s1878];+  const SWord32 s1880 = s1876 ^ s1879;+  const SWord32 s1881 = s1806 ^ s1862;+  const SWord32 s1882 = s1880 ^ s1881;+  const SWord16 s1883 = (SWord16) s1882;+  const SWord8  s1884 = (SWord8) (s1883 >> 8);+  const SWord32 s1885 = table3[s1884];+  const SWord32 s1886 = s1867 ^ s1885;+  const SWord8  s1887 = (SWord8) (s1870 >> 8);+  const SWord32 s1888 = table1[s1887];+  const SWord8  s1889 = (SWord8) s1771;+  const SWord32 s1890 = table2[s1889];+  const SWord32 s1891 = s1888 ^ s1890;+  const SWord8  s1892 = (SWord8) (s1877 >> 8);+  const SWord32 s1893 = table3[s1892];+  const SWord32 s1894 = s1891 ^ s1893;+  const SWord8  s1895 = (SWord8) s1808;+  const SWord32 s1896 = table4[s1895];+  const SWord32 s1897 = s1894 ^ s1896;+  const SWord32 s1898 = s1823 ^ s1881;+  const SWord32 s1899 = s1897 ^ s1898;+  const SWord16 s1900 = (SWord16) s1899;+  const SWord8  s1901 = (SWord8) s1900;+  const SWord32 s1902 = table4[s1901];+  const SWord32 s1903 = s1886 ^ s1902;+  const SWord32 s1904 = (s1898 << 8) | (s1898 >> 24);+  const SWord16 s1905 = (SWord16) (s1904 >> 16);+  const SWord8  s1906 = (SWord8) (s1905 >> 8);+  const SWord8  s1907 = table0[s1906];+  const SWord8  s1908 = 27 ^ s1907;+  const SWord8  s1909 = (SWord8) s1905;+  const SWord8  s1910 = table0[s1909];+  const SWord16 s1911 = (((SWord16) s1908) << 8) | ((SWord16) s1910);+  const SWord16 s1912 = (SWord16) s1904;+  const SWord8  s1913 = (SWord8) (s1912 >> 8);+  const SWord8  s1914 = table0[s1913];+  const SWord8  s1915 = (SWord8) s1912;+  const SWord8  s1916 = table0[s1915];+  const SWord16 s1917 = (((SWord16) s1914) << 8) | ((SWord16) s1916);+  const SWord32 s1918 = (((SWord32) s1911) << 16) | ((SWord32) s1917);+  const SWord32 s1919 = s1844 ^ s1918;+  const SWord32 s1920 = s1903 ^ s1919;+  const SWord16 s1921 = (SWord16) (s1920 >> 16);+  const SWord8  s1922 = (SWord8) (s1921 >> 8);+  const SWord8  s1923 = table0[s1922];+  const SWord8  s1924 = (SWord8) (s1864 >> 8);+  const SWord32 s1925 = table1[s1924];+  const SWord16 s1926 = (SWord16) (s1882 >> 16);+  const SWord8  s1927 = (SWord8) s1926;+  const SWord32 s1928 = table2[s1927];+  const SWord32 s1929 = s1925 ^ s1928;+  const SWord8  s1930 = (SWord8) (s1900 >> 8);+  const SWord32 s1931 = table3[s1930];+  const SWord32 s1932 = s1929 ^ s1931;+  const SWord16 s1933 = (SWord16) s1845;+  const SWord8  s1934 = (SWord8) s1933;+  const SWord32 s1935 = table4[s1934];+  const SWord32 s1936 = s1932 ^ s1935;+  const SWord32 s1937 = s1862 ^ s1919;+  const SWord32 s1938 = s1936 ^ s1937;+  const SWord16 s1939 = (SWord16) (s1938 >> 16);+  const SWord8  s1940 = (SWord8) s1939;+  const SWord8  s1941 = table0[s1940];+  const SWord16 s1942 = (((SWord16) s1923) << 8) | ((SWord16) s1941);+  const SWord8  s1943 = (SWord8) (s1926 >> 8);+  const SWord32 s1944 = table1[s1943];+  const SWord16 s1945 = (SWord16) (s1899 >> 16);+  const SWord8  s1946 = (SWord8) s1945;+  const SWord32 s1947 = table2[s1946];+  const SWord32 s1948 = s1944 ^ s1947;+  const SWord8  s1949 = (SWord8) (s1933 >> 8);+  const SWord32 s1950 = table3[s1949];+  const SWord32 s1951 = s1948 ^ s1950;+  const SWord16 s1952 = (SWord16) s1863;+  const SWord8  s1953 = (SWord8) s1952;+  const SWord32 s1954 = table4[s1953];+  const SWord32 s1955 = s1951 ^ s1954;+  const SWord32 s1956 = s1881 ^ s1937;+  const SWord32 s1957 = s1955 ^ s1956;+  const SWord16 s1958 = (SWord16) s1957;+  const SWord8  s1959 = (SWord8) (s1958 >> 8);+  const SWord8  s1960 = table0[s1959];+  const SWord8  s1961 = (SWord8) (s1945 >> 8);+  const SWord32 s1962 = table1[s1961];+  const SWord8  s1963 = (SWord8) s1846;+  const SWord32 s1964 = table2[s1963];+  const SWord32 s1965 = s1962 ^ s1964;+  const SWord8  s1966 = (SWord8) (s1952 >> 8);+  const SWord32 s1967 = table3[s1966];+  const SWord32 s1968 = s1965 ^ s1967;+  const SWord8  s1969 = (SWord8) s1883;+  const SWord32 s1970 = table4[s1969];+  const SWord32 s1971 = s1968 ^ s1970;+  const SWord32 s1972 = s1898 ^ s1956;+  const SWord32 s1973 = s1971 ^ s1972;+  const SWord16 s1974 = (SWord16) s1973;+  const SWord8  s1975 = (SWord8) s1974;+  const SWord8  s1976 = table0[s1975];+  const SWord16 s1977 = (((SWord16) s1960) << 8) | ((SWord16) s1976);+  const SWord32 s1978 = (((SWord32) s1942) << 16) | ((SWord32) s1977);+  const SWord32 s1979 = (s1972 << 8) | (s1972 >> 24);+  const SWord16 s1980 = (SWord16) (s1979 >> 16);+  const SWord8  s1981 = (SWord8) (s1980 >> 8);+  const SWord8  s1982 = table0[s1981];+  const SWord8  s1983 = 54 ^ s1982;+  const SWord8  s1984 = (SWord8) s1980;+  const SWord8  s1985 = table0[s1984];+  const SWord16 s1986 = (((SWord16) s1983) << 8) | ((SWord16) s1985);+  const SWord16 s1987 = (SWord16) s1979;+  const SWord8  s1988 = (SWord8) (s1987 >> 8);+  const SWord8  s1989 = table0[s1988];+  const SWord8  s1990 = (SWord8) s1987;+  const SWord8  s1991 = table0[s1990];+  const SWord16 s1992 = (((SWord16) s1989) << 8) | ((SWord16) s1991);+  const SWord32 s1993 = (((SWord32) s1986) << 16) | ((SWord32) s1992);+  const SWord32 s1994 = s1919 ^ s1993;+  const SWord32 s1995 = s1978 ^ s1994;+  const SWord8  s1996 = (SWord8) (s1939 >> 8);+  const SWord8  s1997 = table0[s1996];+  const SWord16 s1998 = (SWord16) (s1957 >> 16);+  const SWord8  s1999 = (SWord8) s1998;+  const SWord8  s2000 = table0[s1999];+  const SWord16 s2001 = (((SWord16) s1997) << 8) | ((SWord16) s2000);+  const SWord8  s2002 = (SWord8) (s1974 >> 8);+  const SWord8  s2003 = table0[s2002];+  const SWord16 s2004 = (SWord16) s1920;+  const SWord8  s2005 = (SWord8) s2004;+  const SWord8  s2006 = table0[s2005];+  const SWord16 s2007 = (((SWord16) s2003) << 8) | ((SWord16) s2006);+  const SWord32 s2008 = (((SWord32) s2001) << 16) | ((SWord32) s2007);+  const SWord32 s2009 = s1937 ^ s1994;+  const SWord32 s2010 = s2008 ^ s2009;+  const SWord8  s2011 = (SWord8) (s1998 >> 8);+  const SWord8  s2012 = table0[s2011];+  const SWord16 s2013 = (SWord16) (s1973 >> 16);+  const SWord8  s2014 = (SWord8) s2013;+  const SWord8  s2015 = table0[s2014];+  const SWord16 s2016 = (((SWord16) s2012) << 8) | ((SWord16) s2015);+  const SWord8  s2017 = (SWord8) (s2004 >> 8);+  const SWord8  s2018 = table0[s2017];+  const SWord16 s2019 = (SWord16) s1938;+  const SWord8  s2020 = (SWord8) s2019;+  const SWord8  s2021 = table0[s2020];+  const SWord16 s2022 = (((SWord16) s2018) << 8) | ((SWord16) s2021);+  const SWord32 s2023 = (((SWord32) s2016) << 16) | ((SWord32) s2022);+  const SWord32 s2024 = s1956 ^ s2009;+  const SWord32 s2025 = s2023 ^ s2024;+  const SWord8  s2026 = (SWord8) (s2013 >> 8);+  const SWord8  s2027 = table0[s2026];+  const SWord8  s2028 = (SWord8) s1921;+  const SWord8  s2029 = table0[s2028];+  const SWord16 s2030 = (((SWord16) s2027) << 8) | ((SWord16) s2029);+  const SWord8  s2031 = (SWord8) (s2019 >> 8);+  const SWord8  s2032 = table0[s2031];+  const SWord8  s2033 = (SWord8) s1958;+  const SWord8  s2034 = table0[s2033];+  const SWord16 s2035 = (((SWord16) s2032) << 8) | ((SWord16) s2034);+  const SWord32 s2036 = (((SWord32) s2030) << 16) | ((SWord32) s2035);+  const SWord32 s2037 = s1972 ^ s2024;+  const SWord32 s2038 = s2036 ^ s2037;++  ct[0] = s1995;+  ct[1] = s2010;+  ct[2] = s2025;+  ct[3] = s2038;+}+== END: "aes128Enc.c" ==================
+ SBVTestSuite/GoldFiles/aes128Lib.gold view
@@ -0,0 +1,3772 @@+== BEGIN: "aes128KeySchedule.c" ================+/* File: "aes128KeySchedule.c". Automatically generated by SBV. Do not edit! */++#include "aes128Lib.h"++void aes128KeySchedule(const SWord32 *key, SWord32 *encKS,+                       SWord32 *decKS)+{+  const SWord32 s0 = key[0];+  const SWord32 s1 = key[1];+  const SWord32 s2 = key[2];+  const SWord32 s3 = key[3];+  static const SWord8 table0[] = {+       99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254,+      215, 171, 118, 202, 130, 201, 125, 250,  89,  71, 240, 173, 212,+      162, 175, 156, 164, 114, 192, 183, 253, 147,  38,  54,  63, 247,+      204,  52, 165, 229, 241, 113, 216,  49,  21,   4, 199,  35, 195,+       24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,   9,+      131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,+       47, 132,  83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,+       57,  74,  76,  88, 207, 208, 239, 170, 251,  67,  77,  51, 133,+       69, 249,   2, 127,  80,  60, 159, 168,  81, 163,  64, 143, 146,+      157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210, 205,  12,+       19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25,+      115,  96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20,+      222,  94,  11, 219, 224,  50,  58,  10,  73,   6,  36,  92, 194,+      211, 172,  98, 145, 149, 228, 121, 231, 200,  55, 109, 141, 213,+       78, 169, 108,  86, 244, 234, 101, 122, 174,   8, 186, 120,  37,+       46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,+      112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134,+      193,  29, 158, 225, 248, 152,  17, 105, 217, 142, 148, 155,  30,+      135, 233, 206,  85,  40, 223, 140, 161, 137,  13, 191, 230,  66,+      104,  65, 153,  45,  15, 176,  84, 187,  22+  };+  static const SWord8 table1[] = {+        0,  14,  28,  18,  56,  54,  36,  42, 112, 126, 108,  98,  72,+       70,  84,  90, 224, 238, 252, 242, 216, 214, 196, 202, 144, 158,+      140, 130, 168, 166, 180, 186, 219, 213, 199, 201, 227, 237, 255,+      241, 171, 165, 183, 185, 147, 157, 143, 129,  59,  53,  39,  41,+        3,  13,  31,  17,  75,  69,  87,  89, 115, 125, 111,  97, 173,+      163, 177, 191, 149, 155, 137, 135, 221, 211, 193, 207, 229, 235,+      249, 247,  77,  67,  81,  95, 117, 123, 105, 103,  61,  51,  33,+       47,   5,  11,  25,  23, 118, 120, 106, 100,  78,  64,  82,  92,+        6,   8,  26,  20,  62,  48,  34,  44, 150, 152, 138, 132, 174,+      160, 178, 188, 230, 232, 250, 244, 222, 208, 194, 204,  65,  79,+       93,  83, 121, 119, 101, 107,  49,  63,  45,  35,   9,   7,  21,+       27, 161, 175, 189, 179, 153, 151, 133, 139, 209, 223, 205, 195,+      233, 231, 245, 251, 154, 148, 134, 136, 162, 172, 190, 176, 234,+      228, 246, 248, 210, 220, 206, 192, 122, 116, 102, 104,  66,  76,+       94,  80,  10,   4,  22,  24,  50,  60,  46,  32, 236, 226, 240,+      254, 212, 218, 200, 198, 156, 146, 128, 142, 164, 170, 184, 182,+       12,   2,  16,  30,  52,  58,  40,  38, 124, 114,  96, 110,  68,+       74,  88,  86,  55,  57,  43,  37,  15,   1,  19,  29,  71,  73,+       91,  85, 127, 113,  99, 109, 215, 217, 203, 197, 239, 225, 243,+      253, 167, 169, 187, 181, 159, 145, 131, 141+  };+  static const SWord8 table2[] = {+        0,  11,  22,  29,  44,  39,  58,  49,  88,  83,  78,  69, 116,+      127,  98, 105, 176, 187, 166, 173, 156, 151, 138, 129, 232, 227,+      254, 245, 196, 207, 210, 217, 123, 112, 109, 102,  87,  92,  65,+       74,  35,  40,  53,  62,  15,   4,  25,  18, 203, 192, 221, 214,+      231, 236, 241, 250, 147, 152, 133, 142, 191, 180, 169, 162, 246,+      253, 224, 235, 218, 209, 204, 199, 174, 165, 184, 179, 130, 137,+      148, 159,  70,  77,  80,  91, 106,  97, 124, 119,  30,  21,   8,+        3,  50,  57,  36,  47, 141, 134, 155, 144, 161, 170, 183, 188,+      213, 222, 195, 200, 249, 242, 239, 228,  61,  54,  43,  32,  17,+       26,   7,  12, 101, 110, 115, 120,  73,  66,  95,  84, 247, 252,+      225, 234, 219, 208, 205, 198, 175, 164, 185, 178, 131, 136, 149,+      158,  71,  76,  81,  90, 107,  96, 125, 118,  31,  20,   9,   2,+       51,  56,  37,  46, 140, 135, 154, 145, 160, 171, 182, 189, 212,+      223, 194, 201, 248, 243, 238, 229,  60,  55,  42,  33,  16,  27,+        6,  13, 100, 111, 114, 121,  72,  67,  94,  85,   1,  10,  23,+       28,  45,  38,  59,  48,  89,  82,  79,  68, 117, 126,  99, 104,+      177, 186, 167, 172, 157, 150, 139, 128, 233, 226, 255, 244, 197,+      206, 211, 216, 122, 113, 108, 103,  86,  93,  64,  75,  34,  41,+       52,  63,  14,   5,  24,  19, 202, 193, 220, 215, 230, 237, 240,+      251, 146, 153, 132, 143, 190, 181, 168, 163+  };+  static const SWord8 table3[] = {+        0,  13,  26,  23,  52,  57,  46,  35, 104, 101, 114, 127,  92,+       81,  70,  75, 208, 221, 202, 199, 228, 233, 254, 243, 184, 181,+      162, 175, 140, 129, 150, 155, 187, 182, 161, 172, 143, 130, 149,+      152, 211, 222, 201, 196, 231, 234, 253, 240, 107, 102, 113, 124,+       95,  82,  69,  72,   3,  14,  25,  20,  55,  58,  45,  32, 109,+       96, 119, 122,  89,  84,  67,  78,   5,   8,  31,  18,  49,  60,+       43,  38, 189, 176, 167, 170, 137, 132, 147, 158, 213, 216, 207,+      194, 225, 236, 251, 246, 214, 219, 204, 193, 226, 239, 248, 245,+      190, 179, 164, 169, 138, 135, 144, 157,   6,  11,  28,  17,  50,+       63,  40,  37, 110,  99, 116, 121,  90,  87,  64,  77, 218, 215,+      192, 205, 238, 227, 244, 249, 178, 191, 168, 165, 134, 139, 156,+      145,  10,   7,  16,  29,  62,  51,  36,  41,  98, 111, 120, 117,+       86,  91,  76,  65,  97, 108, 123, 118,  85,  88,  79,  66,   9,+        4,  19,  30,  61,  48,  39,  42, 177, 188, 171, 166, 133, 136,+      159, 146, 217, 212, 195, 206, 237, 224, 247, 250, 183, 186, 173,+      160, 131, 142, 153, 148, 223, 210, 197, 200, 235, 230, 241, 252,+      103, 106, 125, 112,  83,  94,  73,  68,  15,   2,  21,  24,  59,+       54,  33,  44,  12,   1,  22,  27,  56,  53,  34,  47, 100, 105,+      126, 115,  80,  93,  74,  71, 220, 209, 198, 203, 232, 229, 242,+      255, 180, 185, 174, 163, 128, 141, 154, 151+  };+  static const SWord8 table4[] = {+        0,   9,  18,  27,  36,  45,  54,  63,  72,  65,  90,  83, 108,+      101, 126, 119, 144, 153, 130, 139, 180, 189, 166, 175, 216, 209,+      202, 195, 252, 245, 238, 231,  59,  50,  41,  32,  31,  22,  13,+        4, 115, 122,  97, 104,  87,  94,  69,  76, 171, 162, 185, 176,+      143, 134, 157, 148, 227, 234, 241, 248, 199, 206, 213, 220, 118,+      127, 100, 109,  82,  91,  64,  73,  62,  55,  44,  37,  26,  19,+        8,   1, 230, 239, 244, 253, 194, 203, 208, 217, 174, 167, 188,+      181, 138, 131, 152, 145,  77,  68,  95,  86, 105,  96, 123, 114,+        5,  12,  23,  30,  33,  40,  51,  58, 221, 212, 207, 198, 249,+      240, 235, 226, 149, 156, 135, 142, 177, 184, 163, 170, 236, 229,+      254, 247, 200, 193, 218, 211, 164, 173, 182, 191, 128, 137, 146,+      155, 124, 117, 110, 103,  88,  81,  74,  67,  52,  61,  38,  47,+       16,  25,   2,  11, 215, 222, 197, 204, 243, 250, 225, 232, 159,+      150, 141, 132, 187, 178, 169, 160,  71,  78,  85,  92,  99, 106,+      113, 120,  15,   6,  29,  20,  43,  34,  57,  48, 154, 147, 136,+      129, 190, 183, 172, 165, 210, 219, 192, 201, 246, 255, 228, 237,+       10,   3,  24,  17,  46,  39,  60,  53,  66,  75,  80,  89, 102,+      111, 116, 125, 161, 168, 179, 186, 133, 140, 151, 158, 233, 224,+      251, 242, 205, 196, 223, 214,  49,  56,  35,  42,  21,  28,   7,+       14, 121, 112, 107,  98,  93,  84,  79,  70+  };+  const SWord32 s260 = (s3 << 8) | (s3 >> 24);+  const SWord16 s261 = (SWord16) (s260 >> 16);+  const SWord8  s262 = (SWord8) (s261 >> 8);+  const SWord8  s263 = table0[s262];+  const SWord8  s264 = 1 ^ s263;+  const SWord8  s265 = (SWord8) s261;+  const SWord8  s266 = table0[s265];+  const SWord16 s267 = (((SWord16) s264) << 8) | ((SWord16) s266);+  const SWord16 s268 = (SWord16) s260;+  const SWord8  s269 = (SWord8) (s268 >> 8);+  const SWord8  s270 = table0[s269];+  const SWord8  s271 = (SWord8) s268;+  const SWord8  s272 = table0[s271];+  const SWord16 s273 = (((SWord16) s270) << 8) | ((SWord16) s272);+  const SWord32 s274 = (((SWord32) s267) << 16) | ((SWord32) s273);+  const SWord32 s275 = s0 ^ s274;+  const SWord32 s276 = s1 ^ s275;+  const SWord32 s277 = s2 ^ s276;+  const SWord32 s278 = s3 ^ s277;+  const SWord32 s279 = (s278 << 8) | (s278 >> 24);+  const SWord16 s280 = (SWord16) (s279 >> 16);+  const SWord8  s281 = (SWord8) (s280 >> 8);+  const SWord8  s282 = table0[s281];+  const SWord8  s283 = 2 ^ s282;+  const SWord8  s284 = (SWord8) s280;+  const SWord8  s285 = table0[s284];+  const SWord16 s286 = (((SWord16) s283) << 8) | ((SWord16) s285);+  const SWord16 s287 = (SWord16) s279;+  const SWord8  s288 = (SWord8) (s287 >> 8);+  const SWord8  s289 = table0[s288];+  const SWord8  s290 = (SWord8) s287;+  const SWord8  s291 = table0[s290];+  const SWord16 s292 = (((SWord16) s289) << 8) | ((SWord16) s291);+  const SWord32 s293 = (((SWord32) s286) << 16) | ((SWord32) s292);+  const SWord32 s294 = s275 ^ s293;+  const SWord32 s295 = s276 ^ s294;+  const SWord32 s296 = s277 ^ s295;+  const SWord32 s297 = s278 ^ s296;+  const SWord32 s298 = (s297 << 8) | (s297 >> 24);+  const SWord16 s299 = (SWord16) (s298 >> 16);+  const SWord8  s300 = (SWord8) (s299 >> 8);+  const SWord8  s301 = table0[s300];+  const SWord8  s302 = 4 ^ s301;+  const SWord8  s303 = (SWord8) s299;+  const SWord8  s304 = table0[s303];+  const SWord16 s305 = (((SWord16) s302) << 8) | ((SWord16) s304);+  const SWord16 s306 = (SWord16) s298;+  const SWord8  s307 = (SWord8) (s306 >> 8);+  const SWord8  s308 = table0[s307];+  const SWord8  s309 = (SWord8) s306;+  const SWord8  s310 = table0[s309];+  const SWord16 s311 = (((SWord16) s308) << 8) | ((SWord16) s310);+  const SWord32 s312 = (((SWord32) s305) << 16) | ((SWord32) s311);+  const SWord32 s313 = s294 ^ s312;+  const SWord32 s314 = s295 ^ s313;+  const SWord32 s315 = s296 ^ s314;+  const SWord32 s316 = s297 ^ s315;+  const SWord32 s317 = (s316 << 8) | (s316 >> 24);+  const SWord16 s318 = (SWord16) (s317 >> 16);+  const SWord8  s319 = (SWord8) (s318 >> 8);+  const SWord8  s320 = table0[s319];+  const SWord8  s321 = 8 ^ s320;+  const SWord8  s322 = (SWord8) s318;+  const SWord8  s323 = table0[s322];+  const SWord16 s324 = (((SWord16) s321) << 8) | ((SWord16) s323);+  const SWord16 s325 = (SWord16) s317;+  const SWord8  s326 = (SWord8) (s325 >> 8);+  const SWord8  s327 = table0[s326];+  const SWord8  s328 = (SWord8) s325;+  const SWord8  s329 = table0[s328];+  const SWord16 s330 = (((SWord16) s327) << 8) | ((SWord16) s329);+  const SWord32 s331 = (((SWord32) s324) << 16) | ((SWord32) s330);+  const SWord32 s332 = s313 ^ s331;+  const SWord32 s333 = s314 ^ s332;+  const SWord32 s334 = s315 ^ s333;+  const SWord32 s335 = s316 ^ s334;+  const SWord32 s336 = (s335 << 8) | (s335 >> 24);+  const SWord16 s337 = (SWord16) (s336 >> 16);+  const SWord8  s338 = (SWord8) (s337 >> 8);+  const SWord8  s339 = table0[s338];+  const SWord8  s340 = 16 ^ s339;+  const SWord8  s341 = (SWord8) s337;+  const SWord8  s342 = table0[s341];+  const SWord16 s343 = (((SWord16) s340) << 8) | ((SWord16) s342);+  const SWord16 s344 = (SWord16) s336;+  const SWord8  s345 = (SWord8) (s344 >> 8);+  const SWord8  s346 = table0[s345];+  const SWord8  s347 = (SWord8) s344;+  const SWord8  s348 = table0[s347];+  const SWord16 s349 = (((SWord16) s346) << 8) | ((SWord16) s348);+  const SWord32 s350 = (((SWord32) s343) << 16) | ((SWord32) s349);+  const SWord32 s351 = s332 ^ s350;+  const SWord32 s352 = s333 ^ s351;+  const SWord32 s353 = s334 ^ s352;+  const SWord32 s354 = s335 ^ s353;+  const SWord32 s355 = (s354 << 8) | (s354 >> 24);+  const SWord16 s356 = (SWord16) (s355 >> 16);+  const SWord8  s357 = (SWord8) (s356 >> 8);+  const SWord8  s358 = table0[s357];+  const SWord8  s359 = 32 ^ s358;+  const SWord8  s360 = (SWord8) s356;+  const SWord8  s361 = table0[s360];+  const SWord16 s362 = (((SWord16) s359) << 8) | ((SWord16) s361);+  const SWord16 s363 = (SWord16) s355;+  const SWord8  s364 = (SWord8) (s363 >> 8);+  const SWord8  s365 = table0[s364];+  const SWord8  s366 = (SWord8) s363;+  const SWord8  s367 = table0[s366];+  const SWord16 s368 = (((SWord16) s365) << 8) | ((SWord16) s367);+  const SWord32 s369 = (((SWord32) s362) << 16) | ((SWord32) s368);+  const SWord32 s370 = s351 ^ s369;+  const SWord32 s371 = s352 ^ s370;+  const SWord32 s372 = s353 ^ s371;+  const SWord32 s373 = s354 ^ s372;+  const SWord32 s374 = (s373 << 8) | (s373 >> 24);+  const SWord16 s375 = (SWord16) (s374 >> 16);+  const SWord8  s376 = (SWord8) (s375 >> 8);+  const SWord8  s377 = table0[s376];+  const SWord8  s378 = 64 ^ s377;+  const SWord8  s379 = (SWord8) s375;+  const SWord8  s380 = table0[s379];+  const SWord16 s381 = (((SWord16) s378) << 8) | ((SWord16) s380);+  const SWord16 s382 = (SWord16) s374;+  const SWord8  s383 = (SWord8) (s382 >> 8);+  const SWord8  s384 = table0[s383];+  const SWord8  s385 = (SWord8) s382;+  const SWord8  s386 = table0[s385];+  const SWord16 s387 = (((SWord16) s384) << 8) | ((SWord16) s386);+  const SWord32 s388 = (((SWord32) s381) << 16) | ((SWord32) s387);+  const SWord32 s389 = s370 ^ s388;+  const SWord32 s390 = s371 ^ s389;+  const SWord32 s391 = s372 ^ s390;+  const SWord32 s392 = s373 ^ s391;+  const SWord32 s393 = (s392 << 8) | (s392 >> 24);+  const SWord16 s394 = (SWord16) (s393 >> 16);+  const SWord8  s395 = (SWord8) (s394 >> 8);+  const SWord8  s396 = table0[s395];+  const SWord8  s397 = 128 ^ s396;+  const SWord8  s398 = (SWord8) s394;+  const SWord8  s399 = table0[s398];+  const SWord16 s400 = (((SWord16) s397) << 8) | ((SWord16) s399);+  const SWord16 s401 = (SWord16) s393;+  const SWord8  s402 = (SWord8) (s401 >> 8);+  const SWord8  s403 = table0[s402];+  const SWord8  s404 = (SWord8) s401;+  const SWord8  s405 = table0[s404];+  const SWord16 s406 = (((SWord16) s403) << 8) | ((SWord16) s405);+  const SWord32 s407 = (((SWord32) s400) << 16) | ((SWord32) s406);+  const SWord32 s408 = s389 ^ s407;+  const SWord32 s409 = s390 ^ s408;+  const SWord32 s410 = s391 ^ s409;+  const SWord32 s411 = s392 ^ s410;+  const SWord32 s412 = (s411 << 8) | (s411 >> 24);+  const SWord16 s413 = (SWord16) (s412 >> 16);+  const SWord8  s414 = (SWord8) (s413 >> 8);+  const SWord8  s415 = table0[s414];+  const SWord8  s416 = 27 ^ s415;+  const SWord8  s417 = (SWord8) s413;+  const SWord8  s418 = table0[s417];+  const SWord16 s419 = (((SWord16) s416) << 8) | ((SWord16) s418);+  const SWord16 s420 = (SWord16) s412;+  const SWord8  s421 = (SWord8) (s420 >> 8);+  const SWord8  s422 = table0[s421];+  const SWord8  s423 = (SWord8) s420;+  const SWord8  s424 = table0[s423];+  const SWord16 s425 = (((SWord16) s422) << 8) | ((SWord16) s424);+  const SWord32 s426 = (((SWord32) s419) << 16) | ((SWord32) s425);+  const SWord32 s427 = s408 ^ s426;+  const SWord32 s428 = s409 ^ s427;+  const SWord32 s429 = s410 ^ s428;+  const SWord32 s430 = s411 ^ s429;+  const SWord32 s431 = (s430 << 8) | (s430 >> 24);+  const SWord16 s432 = (SWord16) (s431 >> 16);+  const SWord8  s433 = (SWord8) (s432 >> 8);+  const SWord8  s434 = table0[s433];+  const SWord8  s435 = 54 ^ s434;+  const SWord8  s436 = (SWord8) s432;+  const SWord8  s437 = table0[s436];+  const SWord16 s438 = (((SWord16) s435) << 8) | ((SWord16) s437);+  const SWord16 s439 = (SWord16) s431;+  const SWord8  s440 = (SWord8) (s439 >> 8);+  const SWord8  s441 = table0[s440];+  const SWord8  s442 = (SWord8) s439;+  const SWord8  s443 = table0[s442];+  const SWord16 s444 = (((SWord16) s441) << 8) | ((SWord16) s443);+  const SWord32 s445 = (((SWord32) s438) << 16) | ((SWord32) s444);+  const SWord32 s446 = s427 ^ s445;+  const SWord32 s447 = s428 ^ s446;+  const SWord32 s448 = s429 ^ s447;+  const SWord32 s449 = s430 ^ s448;+  const SWord16 s450 = (SWord16) (s427 >> 16);+  const SWord8  s451 = (SWord8) (s450 >> 8);+  const SWord8  s452 = table1[s451];+  const SWord8  s453 = (SWord8) s450;+  const SWord8  s454 = table2[s453];+  const SWord16 s455 = (SWord16) s427;+  const SWord8  s456 = (SWord8) (s455 >> 8);+  const SWord8  s457 = table3[s456];+  const SWord8  s458 = (SWord8) s455;+  const SWord8  s459 = table4[s458];+  const SWord8  s460 = s457 ^ s459;+  const SWord8  s461 = s454 ^ s460;+  const SWord8  s462 = s452 ^ s461;+  const SWord8  s463 = table4[s451];+  const SWord8  s464 = table1[s453];+  const SWord8  s465 = table2[s456];+  const SWord8  s466 = table3[s458];+  const SWord8  s467 = s465 ^ s466;+  const SWord8  s468 = s464 ^ s467;+  const SWord8  s469 = s463 ^ s468;+  const SWord16 s470 = (((SWord16) s462) << 8) | ((SWord16) s469);+  const SWord8  s471 = table3[s451];+  const SWord8  s472 = table4[s453];+  const SWord8  s473 = table1[s456];+  const SWord8  s474 = table2[s458];+  const SWord8  s475 = s473 ^ s474;+  const SWord8  s476 = s472 ^ s475;+  const SWord8  s477 = s471 ^ s476;+  const SWord8  s478 = table2[s451];+  const SWord8  s479 = table3[s453];+  const SWord8  s480 = table4[s456];+  const SWord8  s481 = table1[s458];+  const SWord8  s482 = s480 ^ s481;+  const SWord8  s483 = s479 ^ s482;+  const SWord8  s484 = s478 ^ s483;+  const SWord16 s485 = (((SWord16) s477) << 8) | ((SWord16) s484);+  const SWord32 s486 = (((SWord32) s470) << 16) | ((SWord32) s485);+  const SWord16 s487 = (SWord16) (s428 >> 16);+  const SWord8  s488 = (SWord8) (s487 >> 8);+  const SWord8  s489 = table1[s488];+  const SWord8  s490 = (SWord8) s487;+  const SWord8  s491 = table2[s490];+  const SWord16 s492 = (SWord16) s428;+  const SWord8  s493 = (SWord8) (s492 >> 8);+  const SWord8  s494 = table3[s493];+  const SWord8  s495 = (SWord8) s492;+  const SWord8  s496 = table4[s495];+  const SWord8  s497 = s494 ^ s496;+  const SWord8  s498 = s491 ^ s497;+  const SWord8  s499 = s489 ^ s498;+  const SWord8  s500 = table4[s488];+  const SWord8  s501 = table1[s490];+  const SWord8  s502 = table2[s493];+  const SWord8  s503 = table3[s495];+  const SWord8  s504 = s502 ^ s503;+  const SWord8  s505 = s501 ^ s504;+  const SWord8  s506 = s500 ^ s505;+  const SWord16 s507 = (((SWord16) s499) << 8) | ((SWord16) s506);+  const SWord8  s508 = table3[s488];+  const SWord8  s509 = table4[s490];+  const SWord8  s510 = table1[s493];+  const SWord8  s511 = table2[s495];+  const SWord8  s512 = s510 ^ s511;+  const SWord8  s513 = s509 ^ s512;+  const SWord8  s514 = s508 ^ s513;+  const SWord8  s515 = table2[s488];+  const SWord8  s516 = table3[s490];+  const SWord8  s517 = table4[s493];+  const SWord8  s518 = table1[s495];+  const SWord8  s519 = s517 ^ s518;+  const SWord8  s520 = s516 ^ s519;+  const SWord8  s521 = s515 ^ s520;+  const SWord16 s522 = (((SWord16) s514) << 8) | ((SWord16) s521);+  const SWord32 s523 = (((SWord32) s507) << 16) | ((SWord32) s522);+  const SWord16 s524 = (SWord16) (s429 >> 16);+  const SWord8  s525 = (SWord8) (s524 >> 8);+  const SWord8  s526 = table1[s525];+  const SWord8  s527 = (SWord8) s524;+  const SWord8  s528 = table2[s527];+  const SWord16 s529 = (SWord16) s429;+  const SWord8  s530 = (SWord8) (s529 >> 8);+  const SWord8  s531 = table3[s530];+  const SWord8  s532 = (SWord8) s529;+  const SWord8  s533 = table4[s532];+  const SWord8  s534 = s531 ^ s533;+  const SWord8  s535 = s528 ^ s534;+  const SWord8  s536 = s526 ^ s535;+  const SWord8  s537 = table4[s525];+  const SWord8  s538 = table1[s527];+  const SWord8  s539 = table2[s530];+  const SWord8  s540 = table3[s532];+  const SWord8  s541 = s539 ^ s540;+  const SWord8  s542 = s538 ^ s541;+  const SWord8  s543 = s537 ^ s542;+  const SWord16 s544 = (((SWord16) s536) << 8) | ((SWord16) s543);+  const SWord8  s545 = table3[s525];+  const SWord8  s546 = table4[s527];+  const SWord8  s547 = table1[s530];+  const SWord8  s548 = table2[s532];+  const SWord8  s549 = s547 ^ s548;+  const SWord8  s550 = s546 ^ s549;+  const SWord8  s551 = s545 ^ s550;+  const SWord8  s552 = table2[s525];+  const SWord8  s553 = table3[s527];+  const SWord8  s554 = table4[s530];+  const SWord8  s555 = table1[s532];+  const SWord8  s556 = s554 ^ s555;+  const SWord8  s557 = s553 ^ s556;+  const SWord8  s558 = s552 ^ s557;+  const SWord16 s559 = (((SWord16) s551) << 8) | ((SWord16) s558);+  const SWord32 s560 = (((SWord32) s544) << 16) | ((SWord32) s559);+  const SWord16 s561 = (SWord16) (s430 >> 16);+  const SWord8  s562 = (SWord8) (s561 >> 8);+  const SWord8  s563 = table1[s562];+  const SWord8  s564 = (SWord8) s561;+  const SWord8  s565 = table2[s564];+  const SWord16 s566 = (SWord16) s430;+  const SWord8  s567 = (SWord8) (s566 >> 8);+  const SWord8  s568 = table3[s567];+  const SWord8  s569 = (SWord8) s566;+  const SWord8  s570 = table4[s569];+  const SWord8  s571 = s568 ^ s570;+  const SWord8  s572 = s565 ^ s571;+  const SWord8  s573 = s563 ^ s572;+  const SWord8  s574 = table4[s562];+  const SWord8  s575 = table1[s564];+  const SWord8  s576 = table2[s567];+  const SWord8  s577 = table3[s569];+  const SWord8  s578 = s576 ^ s577;+  const SWord8  s579 = s575 ^ s578;+  const SWord8  s580 = s574 ^ s579;+  const SWord16 s581 = (((SWord16) s573) << 8) | ((SWord16) s580);+  const SWord8  s582 = table3[s562];+  const SWord8  s583 = table4[s564];+  const SWord8  s584 = table1[s567];+  const SWord8  s585 = table2[s569];+  const SWord8  s586 = s584 ^ s585;+  const SWord8  s587 = s583 ^ s586;+  const SWord8  s588 = s582 ^ s587;+  const SWord8  s589 = table2[s562];+  const SWord8  s590 = table3[s564];+  const SWord8  s591 = table4[s567];+  const SWord8  s592 = table1[s569];+  const SWord8  s593 = s591 ^ s592;+  const SWord8  s594 = s590 ^ s593;+  const SWord8  s595 = s589 ^ s594;+  const SWord16 s596 = (((SWord16) s588) << 8) | ((SWord16) s595);+  const SWord32 s597 = (((SWord32) s581) << 16) | ((SWord32) s596);+  const SWord16 s598 = (SWord16) (s408 >> 16);+  const SWord8  s599 = (SWord8) (s598 >> 8);+  const SWord8  s600 = table1[s599];+  const SWord8  s601 = (SWord8) s598;+  const SWord8  s602 = table2[s601];+  const SWord16 s603 = (SWord16) s408;+  const SWord8  s604 = (SWord8) (s603 >> 8);+  const SWord8  s605 = table3[s604];+  const SWord8  s606 = (SWord8) s603;+  const SWord8  s607 = table4[s606];+  const SWord8  s608 = s605 ^ s607;+  const SWord8  s609 = s602 ^ s608;+  const SWord8  s610 = s600 ^ s609;+  const SWord8  s611 = table4[s599];+  const SWord8  s612 = table1[s601];+  const SWord8  s613 = table2[s604];+  const SWord8  s614 = table3[s606];+  const SWord8  s615 = s613 ^ s614;+  const SWord8  s616 = s612 ^ s615;+  const SWord8  s617 = s611 ^ s616;+  const SWord16 s618 = (((SWord16) s610) << 8) | ((SWord16) s617);+  const SWord8  s619 = table3[s599];+  const SWord8  s620 = table4[s601];+  const SWord8  s621 = table1[s604];+  const SWord8  s622 = table2[s606];+  const SWord8  s623 = s621 ^ s622;+  const SWord8  s624 = s620 ^ s623;+  const SWord8  s625 = s619 ^ s624;+  const SWord8  s626 = table2[s599];+  const SWord8  s627 = table3[s601];+  const SWord8  s628 = table4[s604];+  const SWord8  s629 = table1[s606];+  const SWord8  s630 = s628 ^ s629;+  const SWord8  s631 = s627 ^ s630;+  const SWord8  s632 = s626 ^ s631;+  const SWord16 s633 = (((SWord16) s625) << 8) | ((SWord16) s632);+  const SWord32 s634 = (((SWord32) s618) << 16) | ((SWord32) s633);+  const SWord16 s635 = (SWord16) (s409 >> 16);+  const SWord8  s636 = (SWord8) (s635 >> 8);+  const SWord8  s637 = table1[s636];+  const SWord8  s638 = (SWord8) s635;+  const SWord8  s639 = table2[s638];+  const SWord16 s640 = (SWord16) s409;+  const SWord8  s641 = (SWord8) (s640 >> 8);+  const SWord8  s642 = table3[s641];+  const SWord8  s643 = (SWord8) s640;+  const SWord8  s644 = table4[s643];+  const SWord8  s645 = s642 ^ s644;+  const SWord8  s646 = s639 ^ s645;+  const SWord8  s647 = s637 ^ s646;+  const SWord8  s648 = table4[s636];+  const SWord8  s649 = table1[s638];+  const SWord8  s650 = table2[s641];+  const SWord8  s651 = table3[s643];+  const SWord8  s652 = s650 ^ s651;+  const SWord8  s653 = s649 ^ s652;+  const SWord8  s654 = s648 ^ s653;+  const SWord16 s655 = (((SWord16) s647) << 8) | ((SWord16) s654);+  const SWord8  s656 = table3[s636];+  const SWord8  s657 = table4[s638];+  const SWord8  s658 = table1[s641];+  const SWord8  s659 = table2[s643];+  const SWord8  s660 = s658 ^ s659;+  const SWord8  s661 = s657 ^ s660;+  const SWord8  s662 = s656 ^ s661;+  const SWord8  s663 = table2[s636];+  const SWord8  s664 = table3[s638];+  const SWord8  s665 = table4[s641];+  const SWord8  s666 = table1[s643];+  const SWord8  s667 = s665 ^ s666;+  const SWord8  s668 = s664 ^ s667;+  const SWord8  s669 = s663 ^ s668;+  const SWord16 s670 = (((SWord16) s662) << 8) | ((SWord16) s669);+  const SWord32 s671 = (((SWord32) s655) << 16) | ((SWord32) s670);+  const SWord16 s672 = (SWord16) (s410 >> 16);+  const SWord8  s673 = (SWord8) (s672 >> 8);+  const SWord8  s674 = table1[s673];+  const SWord8  s675 = (SWord8) s672;+  const SWord8  s676 = table2[s675];+  const SWord16 s677 = (SWord16) s410;+  const SWord8  s678 = (SWord8) (s677 >> 8);+  const SWord8  s679 = table3[s678];+  const SWord8  s680 = (SWord8) s677;+  const SWord8  s681 = table4[s680];+  const SWord8  s682 = s679 ^ s681;+  const SWord8  s683 = s676 ^ s682;+  const SWord8  s684 = s674 ^ s683;+  const SWord8  s685 = table4[s673];+  const SWord8  s686 = table1[s675];+  const SWord8  s687 = table2[s678];+  const SWord8  s688 = table3[s680];+  const SWord8  s689 = s687 ^ s688;+  const SWord8  s690 = s686 ^ s689;+  const SWord8  s691 = s685 ^ s690;+  const SWord16 s692 = (((SWord16) s684) << 8) | ((SWord16) s691);+  const SWord8  s693 = table3[s673];+  const SWord8  s694 = table4[s675];+  const SWord8  s695 = table1[s678];+  const SWord8  s696 = table2[s680];+  const SWord8  s697 = s695 ^ s696;+  const SWord8  s698 = s694 ^ s697;+  const SWord8  s699 = s693 ^ s698;+  const SWord8  s700 = table2[s673];+  const SWord8  s701 = table3[s675];+  const SWord8  s702 = table4[s678];+  const SWord8  s703 = table1[s680];+  const SWord8  s704 = s702 ^ s703;+  const SWord8  s705 = s701 ^ s704;+  const SWord8  s706 = s700 ^ s705;+  const SWord16 s707 = (((SWord16) s699) << 8) | ((SWord16) s706);+  const SWord32 s708 = (((SWord32) s692) << 16) | ((SWord32) s707);+  const SWord16 s709 = (SWord16) (s411 >> 16);+  const SWord8  s710 = (SWord8) (s709 >> 8);+  const SWord8  s711 = table1[s710];+  const SWord8  s712 = (SWord8) s709;+  const SWord8  s713 = table2[s712];+  const SWord16 s714 = (SWord16) s411;+  const SWord8  s715 = (SWord8) (s714 >> 8);+  const SWord8  s716 = table3[s715];+  const SWord8  s717 = (SWord8) s714;+  const SWord8  s718 = table4[s717];+  const SWord8  s719 = s716 ^ s718;+  const SWord8  s720 = s713 ^ s719;+  const SWord8  s721 = s711 ^ s720;+  const SWord8  s722 = table4[s710];+  const SWord8  s723 = table1[s712];+  const SWord8  s724 = table2[s715];+  const SWord8  s725 = table3[s717];+  const SWord8  s726 = s724 ^ s725;+  const SWord8  s727 = s723 ^ s726;+  const SWord8  s728 = s722 ^ s727;+  const SWord16 s729 = (((SWord16) s721) << 8) | ((SWord16) s728);+  const SWord8  s730 = table3[s710];+  const SWord8  s731 = table4[s712];+  const SWord8  s732 = table1[s715];+  const SWord8  s733 = table2[s717];+  const SWord8  s734 = s732 ^ s733;+  const SWord8  s735 = s731 ^ s734;+  const SWord8  s736 = s730 ^ s735;+  const SWord8  s737 = table2[s710];+  const SWord8  s738 = table3[s712];+  const SWord8  s739 = table4[s715];+  const SWord8  s740 = table1[s717];+  const SWord8  s741 = s739 ^ s740;+  const SWord8  s742 = s738 ^ s741;+  const SWord8  s743 = s737 ^ s742;+  const SWord16 s744 = (((SWord16) s736) << 8) | ((SWord16) s743);+  const SWord32 s745 = (((SWord32) s729) << 16) | ((SWord32) s744);+  const SWord16 s746 = (SWord16) (s389 >> 16);+  const SWord8  s747 = (SWord8) (s746 >> 8);+  const SWord8  s748 = table1[s747];+  const SWord8  s749 = (SWord8) s746;+  const SWord8  s750 = table2[s749];+  const SWord16 s751 = (SWord16) s389;+  const SWord8  s752 = (SWord8) (s751 >> 8);+  const SWord8  s753 = table3[s752];+  const SWord8  s754 = (SWord8) s751;+  const SWord8  s755 = table4[s754];+  const SWord8  s756 = s753 ^ s755;+  const SWord8  s757 = s750 ^ s756;+  const SWord8  s758 = s748 ^ s757;+  const SWord8  s759 = table4[s747];+  const SWord8  s760 = table1[s749];+  const SWord8  s761 = table2[s752];+  const SWord8  s762 = table3[s754];+  const SWord8  s763 = s761 ^ s762;+  const SWord8  s764 = s760 ^ s763;+  const SWord8  s765 = s759 ^ s764;+  const SWord16 s766 = (((SWord16) s758) << 8) | ((SWord16) s765);+  const SWord8  s767 = table3[s747];+  const SWord8  s768 = table4[s749];+  const SWord8  s769 = table1[s752];+  const SWord8  s770 = table2[s754];+  const SWord8  s771 = s769 ^ s770;+  const SWord8  s772 = s768 ^ s771;+  const SWord8  s773 = s767 ^ s772;+  const SWord8  s774 = table2[s747];+  const SWord8  s775 = table3[s749];+  const SWord8  s776 = table4[s752];+  const SWord8  s777 = table1[s754];+  const SWord8  s778 = s776 ^ s777;+  const SWord8  s779 = s775 ^ s778;+  const SWord8  s780 = s774 ^ s779;+  const SWord16 s781 = (((SWord16) s773) << 8) | ((SWord16) s780);+  const SWord32 s782 = (((SWord32) s766) << 16) | ((SWord32) s781);+  const SWord16 s783 = (SWord16) (s390 >> 16);+  const SWord8  s784 = (SWord8) (s783 >> 8);+  const SWord8  s785 = table1[s784];+  const SWord8  s786 = (SWord8) s783;+  const SWord8  s787 = table2[s786];+  const SWord16 s788 = (SWord16) s390;+  const SWord8  s789 = (SWord8) (s788 >> 8);+  const SWord8  s790 = table3[s789];+  const SWord8  s791 = (SWord8) s788;+  const SWord8  s792 = table4[s791];+  const SWord8  s793 = s790 ^ s792;+  const SWord8  s794 = s787 ^ s793;+  const SWord8  s795 = s785 ^ s794;+  const SWord8  s796 = table4[s784];+  const SWord8  s797 = table1[s786];+  const SWord8  s798 = table2[s789];+  const SWord8  s799 = table3[s791];+  const SWord8  s800 = s798 ^ s799;+  const SWord8  s801 = s797 ^ s800;+  const SWord8  s802 = s796 ^ s801;+  const SWord16 s803 = (((SWord16) s795) << 8) | ((SWord16) s802);+  const SWord8  s804 = table3[s784];+  const SWord8  s805 = table4[s786];+  const SWord8  s806 = table1[s789];+  const SWord8  s807 = table2[s791];+  const SWord8  s808 = s806 ^ s807;+  const SWord8  s809 = s805 ^ s808;+  const SWord8  s810 = s804 ^ s809;+  const SWord8  s811 = table2[s784];+  const SWord8  s812 = table3[s786];+  const SWord8  s813 = table4[s789];+  const SWord8  s814 = table1[s791];+  const SWord8  s815 = s813 ^ s814;+  const SWord8  s816 = s812 ^ s815;+  const SWord8  s817 = s811 ^ s816;+  const SWord16 s818 = (((SWord16) s810) << 8) | ((SWord16) s817);+  const SWord32 s819 = (((SWord32) s803) << 16) | ((SWord32) s818);+  const SWord16 s820 = (SWord16) (s391 >> 16);+  const SWord8  s821 = (SWord8) (s820 >> 8);+  const SWord8  s822 = table1[s821];+  const SWord8  s823 = (SWord8) s820;+  const SWord8  s824 = table2[s823];+  const SWord16 s825 = (SWord16) s391;+  const SWord8  s826 = (SWord8) (s825 >> 8);+  const SWord8  s827 = table3[s826];+  const SWord8  s828 = (SWord8) s825;+  const SWord8  s829 = table4[s828];+  const SWord8  s830 = s827 ^ s829;+  const SWord8  s831 = s824 ^ s830;+  const SWord8  s832 = s822 ^ s831;+  const SWord8  s833 = table4[s821];+  const SWord8  s834 = table1[s823];+  const SWord8  s835 = table2[s826];+  const SWord8  s836 = table3[s828];+  const SWord8  s837 = s835 ^ s836;+  const SWord8  s838 = s834 ^ s837;+  const SWord8  s839 = s833 ^ s838;+  const SWord16 s840 = (((SWord16) s832) << 8) | ((SWord16) s839);+  const SWord8  s841 = table3[s821];+  const SWord8  s842 = table4[s823];+  const SWord8  s843 = table1[s826];+  const SWord8  s844 = table2[s828];+  const SWord8  s845 = s843 ^ s844;+  const SWord8  s846 = s842 ^ s845;+  const SWord8  s847 = s841 ^ s846;+  const SWord8  s848 = table2[s821];+  const SWord8  s849 = table3[s823];+  const SWord8  s850 = table4[s826];+  const SWord8  s851 = table1[s828];+  const SWord8  s852 = s850 ^ s851;+  const SWord8  s853 = s849 ^ s852;+  const SWord8  s854 = s848 ^ s853;+  const SWord16 s855 = (((SWord16) s847) << 8) | ((SWord16) s854);+  const SWord32 s856 = (((SWord32) s840) << 16) | ((SWord32) s855);+  const SWord16 s857 = (SWord16) (s392 >> 16);+  const SWord8  s858 = (SWord8) (s857 >> 8);+  const SWord8  s859 = table1[s858];+  const SWord8  s860 = (SWord8) s857;+  const SWord8  s861 = table2[s860];+  const SWord16 s862 = (SWord16) s392;+  const SWord8  s863 = (SWord8) (s862 >> 8);+  const SWord8  s864 = table3[s863];+  const SWord8  s865 = (SWord8) s862;+  const SWord8  s866 = table4[s865];+  const SWord8  s867 = s864 ^ s866;+  const SWord8  s868 = s861 ^ s867;+  const SWord8  s869 = s859 ^ s868;+  const SWord8  s870 = table4[s858];+  const SWord8  s871 = table1[s860];+  const SWord8  s872 = table2[s863];+  const SWord8  s873 = table3[s865];+  const SWord8  s874 = s872 ^ s873;+  const SWord8  s875 = s871 ^ s874;+  const SWord8  s876 = s870 ^ s875;+  const SWord16 s877 = (((SWord16) s869) << 8) | ((SWord16) s876);+  const SWord8  s878 = table3[s858];+  const SWord8  s879 = table4[s860];+  const SWord8  s880 = table1[s863];+  const SWord8  s881 = table2[s865];+  const SWord8  s882 = s880 ^ s881;+  const SWord8  s883 = s879 ^ s882;+  const SWord8  s884 = s878 ^ s883;+  const SWord8  s885 = table2[s858];+  const SWord8  s886 = table3[s860];+  const SWord8  s887 = table4[s863];+  const SWord8  s888 = table1[s865];+  const SWord8  s889 = s887 ^ s888;+  const SWord8  s890 = s886 ^ s889;+  const SWord8  s891 = s885 ^ s890;+  const SWord16 s892 = (((SWord16) s884) << 8) | ((SWord16) s891);+  const SWord32 s893 = (((SWord32) s877) << 16) | ((SWord32) s892);+  const SWord16 s894 = (SWord16) (s370 >> 16);+  const SWord8  s895 = (SWord8) (s894 >> 8);+  const SWord8  s896 = table1[s895];+  const SWord8  s897 = (SWord8) s894;+  const SWord8  s898 = table2[s897];+  const SWord16 s899 = (SWord16) s370;+  const SWord8  s900 = (SWord8) (s899 >> 8);+  const SWord8  s901 = table3[s900];+  const SWord8  s902 = (SWord8) s899;+  const SWord8  s903 = table4[s902];+  const SWord8  s904 = s901 ^ s903;+  const SWord8  s905 = s898 ^ s904;+  const SWord8  s906 = s896 ^ s905;+  const SWord8  s907 = table4[s895];+  const SWord8  s908 = table1[s897];+  const SWord8  s909 = table2[s900];+  const SWord8  s910 = table3[s902];+  const SWord8  s911 = s909 ^ s910;+  const SWord8  s912 = s908 ^ s911;+  const SWord8  s913 = s907 ^ s912;+  const SWord16 s914 = (((SWord16) s906) << 8) | ((SWord16) s913);+  const SWord8  s915 = table3[s895];+  const SWord8  s916 = table4[s897];+  const SWord8  s917 = table1[s900];+  const SWord8  s918 = table2[s902];+  const SWord8  s919 = s917 ^ s918;+  const SWord8  s920 = s916 ^ s919;+  const SWord8  s921 = s915 ^ s920;+  const SWord8  s922 = table2[s895];+  const SWord8  s923 = table3[s897];+  const SWord8  s924 = table4[s900];+  const SWord8  s925 = table1[s902];+  const SWord8  s926 = s924 ^ s925;+  const SWord8  s927 = s923 ^ s926;+  const SWord8  s928 = s922 ^ s927;+  const SWord16 s929 = (((SWord16) s921) << 8) | ((SWord16) s928);+  const SWord32 s930 = (((SWord32) s914) << 16) | ((SWord32) s929);+  const SWord16 s931 = (SWord16) (s371 >> 16);+  const SWord8  s932 = (SWord8) (s931 >> 8);+  const SWord8  s933 = table1[s932];+  const SWord8  s934 = (SWord8) s931;+  const SWord8  s935 = table2[s934];+  const SWord16 s936 = (SWord16) s371;+  const SWord8  s937 = (SWord8) (s936 >> 8);+  const SWord8  s938 = table3[s937];+  const SWord8  s939 = (SWord8) s936;+  const SWord8  s940 = table4[s939];+  const SWord8  s941 = s938 ^ s940;+  const SWord8  s942 = s935 ^ s941;+  const SWord8  s943 = s933 ^ s942;+  const SWord8  s944 = table4[s932];+  const SWord8  s945 = table1[s934];+  const SWord8  s946 = table2[s937];+  const SWord8  s947 = table3[s939];+  const SWord8  s948 = s946 ^ s947;+  const SWord8  s949 = s945 ^ s948;+  const SWord8  s950 = s944 ^ s949;+  const SWord16 s951 = (((SWord16) s943) << 8) | ((SWord16) s950);+  const SWord8  s952 = table3[s932];+  const SWord8  s953 = table4[s934];+  const SWord8  s954 = table1[s937];+  const SWord8  s955 = table2[s939];+  const SWord8  s956 = s954 ^ s955;+  const SWord8  s957 = s953 ^ s956;+  const SWord8  s958 = s952 ^ s957;+  const SWord8  s959 = table2[s932];+  const SWord8  s960 = table3[s934];+  const SWord8  s961 = table4[s937];+  const SWord8  s962 = table1[s939];+  const SWord8  s963 = s961 ^ s962;+  const SWord8  s964 = s960 ^ s963;+  const SWord8  s965 = s959 ^ s964;+  const SWord16 s966 = (((SWord16) s958) << 8) | ((SWord16) s965);+  const SWord32 s967 = (((SWord32) s951) << 16) | ((SWord32) s966);+  const SWord16 s968 = (SWord16) (s372 >> 16);+  const SWord8  s969 = (SWord8) (s968 >> 8);+  const SWord8  s970 = table1[s969];+  const SWord8  s971 = (SWord8) s968;+  const SWord8  s972 = table2[s971];+  const SWord16 s973 = (SWord16) s372;+  const SWord8  s974 = (SWord8) (s973 >> 8);+  const SWord8  s975 = table3[s974];+  const SWord8  s976 = (SWord8) s973;+  const SWord8  s977 = table4[s976];+  const SWord8  s978 = s975 ^ s977;+  const SWord8  s979 = s972 ^ s978;+  const SWord8  s980 = s970 ^ s979;+  const SWord8  s981 = table4[s969];+  const SWord8  s982 = table1[s971];+  const SWord8  s983 = table2[s974];+  const SWord8  s984 = table3[s976];+  const SWord8  s985 = s983 ^ s984;+  const SWord8  s986 = s982 ^ s985;+  const SWord8  s987 = s981 ^ s986;+  const SWord16 s988 = (((SWord16) s980) << 8) | ((SWord16) s987);+  const SWord8  s989 = table3[s969];+  const SWord8  s990 = table4[s971];+  const SWord8  s991 = table1[s974];+  const SWord8  s992 = table2[s976];+  const SWord8  s993 = s991 ^ s992;+  const SWord8  s994 = s990 ^ s993;+  const SWord8  s995 = s989 ^ s994;+  const SWord8  s996 = table2[s969];+  const SWord8  s997 = table3[s971];+  const SWord8  s998 = table4[s974];+  const SWord8  s999 = table1[s976];+  const SWord8  s1000 = s998 ^ s999;+  const SWord8  s1001 = s997 ^ s1000;+  const SWord8  s1002 = s996 ^ s1001;+  const SWord16 s1003 = (((SWord16) s995) << 8) | ((SWord16) s1002);+  const SWord32 s1004 = (((SWord32) s988) << 16) | ((SWord32) s1003);+  const SWord16 s1005 = (SWord16) (s373 >> 16);+  const SWord8  s1006 = (SWord8) (s1005 >> 8);+  const SWord8  s1007 = table1[s1006];+  const SWord8  s1008 = (SWord8) s1005;+  const SWord8  s1009 = table2[s1008];+  const SWord16 s1010 = (SWord16) s373;+  const SWord8  s1011 = (SWord8) (s1010 >> 8);+  const SWord8  s1012 = table3[s1011];+  const SWord8  s1013 = (SWord8) s1010;+  const SWord8  s1014 = table4[s1013];+  const SWord8  s1015 = s1012 ^ s1014;+  const SWord8  s1016 = s1009 ^ s1015;+  const SWord8  s1017 = s1007 ^ s1016;+  const SWord8  s1018 = table4[s1006];+  const SWord8  s1019 = table1[s1008];+  const SWord8  s1020 = table2[s1011];+  const SWord8  s1021 = table3[s1013];+  const SWord8  s1022 = s1020 ^ s1021;+  const SWord8  s1023 = s1019 ^ s1022;+  const SWord8  s1024 = s1018 ^ s1023;+  const SWord16 s1025 = (((SWord16) s1017) << 8) | ((SWord16) s1024);+  const SWord8  s1026 = table3[s1006];+  const SWord8  s1027 = table4[s1008];+  const SWord8  s1028 = table1[s1011];+  const SWord8  s1029 = table2[s1013];+  const SWord8  s1030 = s1028 ^ s1029;+  const SWord8  s1031 = s1027 ^ s1030;+  const SWord8  s1032 = s1026 ^ s1031;+  const SWord8  s1033 = table2[s1006];+  const SWord8  s1034 = table3[s1008];+  const SWord8  s1035 = table4[s1011];+  const SWord8  s1036 = table1[s1013];+  const SWord8  s1037 = s1035 ^ s1036;+  const SWord8  s1038 = s1034 ^ s1037;+  const SWord8  s1039 = s1033 ^ s1038;+  const SWord16 s1040 = (((SWord16) s1032) << 8) | ((SWord16) s1039);+  const SWord32 s1041 = (((SWord32) s1025) << 16) | ((SWord32) s1040);+  const SWord16 s1042 = (SWord16) (s351 >> 16);+  const SWord8  s1043 = (SWord8) (s1042 >> 8);+  const SWord8  s1044 = table1[s1043];+  const SWord8  s1045 = (SWord8) s1042;+  const SWord8  s1046 = table2[s1045];+  const SWord16 s1047 = (SWord16) s351;+  const SWord8  s1048 = (SWord8) (s1047 >> 8);+  const SWord8  s1049 = table3[s1048];+  const SWord8  s1050 = (SWord8) s1047;+  const SWord8  s1051 = table4[s1050];+  const SWord8  s1052 = s1049 ^ s1051;+  const SWord8  s1053 = s1046 ^ s1052;+  const SWord8  s1054 = s1044 ^ s1053;+  const SWord8  s1055 = table4[s1043];+  const SWord8  s1056 = table1[s1045];+  const SWord8  s1057 = table2[s1048];+  const SWord8  s1058 = table3[s1050];+  const SWord8  s1059 = s1057 ^ s1058;+  const SWord8  s1060 = s1056 ^ s1059;+  const SWord8  s1061 = s1055 ^ s1060;+  const SWord16 s1062 = (((SWord16) s1054) << 8) | ((SWord16) s1061);+  const SWord8  s1063 = table3[s1043];+  const SWord8  s1064 = table4[s1045];+  const SWord8  s1065 = table1[s1048];+  const SWord8  s1066 = table2[s1050];+  const SWord8  s1067 = s1065 ^ s1066;+  const SWord8  s1068 = s1064 ^ s1067;+  const SWord8  s1069 = s1063 ^ s1068;+  const SWord8  s1070 = table2[s1043];+  const SWord8  s1071 = table3[s1045];+  const SWord8  s1072 = table4[s1048];+  const SWord8  s1073 = table1[s1050];+  const SWord8  s1074 = s1072 ^ s1073;+  const SWord8  s1075 = s1071 ^ s1074;+  const SWord8  s1076 = s1070 ^ s1075;+  const SWord16 s1077 = (((SWord16) s1069) << 8) | ((SWord16) s1076);+  const SWord32 s1078 = (((SWord32) s1062) << 16) | ((SWord32) s1077);+  const SWord16 s1079 = (SWord16) (s352 >> 16);+  const SWord8  s1080 = (SWord8) (s1079 >> 8);+  const SWord8  s1081 = table1[s1080];+  const SWord8  s1082 = (SWord8) s1079;+  const SWord8  s1083 = table2[s1082];+  const SWord16 s1084 = (SWord16) s352;+  const SWord8  s1085 = (SWord8) (s1084 >> 8);+  const SWord8  s1086 = table3[s1085];+  const SWord8  s1087 = (SWord8) s1084;+  const SWord8  s1088 = table4[s1087];+  const SWord8  s1089 = s1086 ^ s1088;+  const SWord8  s1090 = s1083 ^ s1089;+  const SWord8  s1091 = s1081 ^ s1090;+  const SWord8  s1092 = table4[s1080];+  const SWord8  s1093 = table1[s1082];+  const SWord8  s1094 = table2[s1085];+  const SWord8  s1095 = table3[s1087];+  const SWord8  s1096 = s1094 ^ s1095;+  const SWord8  s1097 = s1093 ^ s1096;+  const SWord8  s1098 = s1092 ^ s1097;+  const SWord16 s1099 = (((SWord16) s1091) << 8) | ((SWord16) s1098);+  const SWord8  s1100 = table3[s1080];+  const SWord8  s1101 = table4[s1082];+  const SWord8  s1102 = table1[s1085];+  const SWord8  s1103 = table2[s1087];+  const SWord8  s1104 = s1102 ^ s1103;+  const SWord8  s1105 = s1101 ^ s1104;+  const SWord8  s1106 = s1100 ^ s1105;+  const SWord8  s1107 = table2[s1080];+  const SWord8  s1108 = table3[s1082];+  const SWord8  s1109 = table4[s1085];+  const SWord8  s1110 = table1[s1087];+  const SWord8  s1111 = s1109 ^ s1110;+  const SWord8  s1112 = s1108 ^ s1111;+  const SWord8  s1113 = s1107 ^ s1112;+  const SWord16 s1114 = (((SWord16) s1106) << 8) | ((SWord16) s1113);+  const SWord32 s1115 = (((SWord32) s1099) << 16) | ((SWord32) s1114);+  const SWord16 s1116 = (SWord16) (s353 >> 16);+  const SWord8  s1117 = (SWord8) (s1116 >> 8);+  const SWord8  s1118 = table1[s1117];+  const SWord8  s1119 = (SWord8) s1116;+  const SWord8  s1120 = table2[s1119];+  const SWord16 s1121 = (SWord16) s353;+  const SWord8  s1122 = (SWord8) (s1121 >> 8);+  const SWord8  s1123 = table3[s1122];+  const SWord8  s1124 = (SWord8) s1121;+  const SWord8  s1125 = table4[s1124];+  const SWord8  s1126 = s1123 ^ s1125;+  const SWord8  s1127 = s1120 ^ s1126;+  const SWord8  s1128 = s1118 ^ s1127;+  const SWord8  s1129 = table4[s1117];+  const SWord8  s1130 = table1[s1119];+  const SWord8  s1131 = table2[s1122];+  const SWord8  s1132 = table3[s1124];+  const SWord8  s1133 = s1131 ^ s1132;+  const SWord8  s1134 = s1130 ^ s1133;+  const SWord8  s1135 = s1129 ^ s1134;+  const SWord16 s1136 = (((SWord16) s1128) << 8) | ((SWord16) s1135);+  const SWord8  s1137 = table3[s1117];+  const SWord8  s1138 = table4[s1119];+  const SWord8  s1139 = table1[s1122];+  const SWord8  s1140 = table2[s1124];+  const SWord8  s1141 = s1139 ^ s1140;+  const SWord8  s1142 = s1138 ^ s1141;+  const SWord8  s1143 = s1137 ^ s1142;+  const SWord8  s1144 = table2[s1117];+  const SWord8  s1145 = table3[s1119];+  const SWord8  s1146 = table4[s1122];+  const SWord8  s1147 = table1[s1124];+  const SWord8  s1148 = s1146 ^ s1147;+  const SWord8  s1149 = s1145 ^ s1148;+  const SWord8  s1150 = s1144 ^ s1149;+  const SWord16 s1151 = (((SWord16) s1143) << 8) | ((SWord16) s1150);+  const SWord32 s1152 = (((SWord32) s1136) << 16) | ((SWord32) s1151);+  const SWord16 s1153 = (SWord16) (s354 >> 16);+  const SWord8  s1154 = (SWord8) (s1153 >> 8);+  const SWord8  s1155 = table1[s1154];+  const SWord8  s1156 = (SWord8) s1153;+  const SWord8  s1157 = table2[s1156];+  const SWord16 s1158 = (SWord16) s354;+  const SWord8  s1159 = (SWord8) (s1158 >> 8);+  const SWord8  s1160 = table3[s1159];+  const SWord8  s1161 = (SWord8) s1158;+  const SWord8  s1162 = table4[s1161];+  const SWord8  s1163 = s1160 ^ s1162;+  const SWord8  s1164 = s1157 ^ s1163;+  const SWord8  s1165 = s1155 ^ s1164;+  const SWord8  s1166 = table4[s1154];+  const SWord8  s1167 = table1[s1156];+  const SWord8  s1168 = table2[s1159];+  const SWord8  s1169 = table3[s1161];+  const SWord8  s1170 = s1168 ^ s1169;+  const SWord8  s1171 = s1167 ^ s1170;+  const SWord8  s1172 = s1166 ^ s1171;+  const SWord16 s1173 = (((SWord16) s1165) << 8) | ((SWord16) s1172);+  const SWord8  s1174 = table3[s1154];+  const SWord8  s1175 = table4[s1156];+  const SWord8  s1176 = table1[s1159];+  const SWord8  s1177 = table2[s1161];+  const SWord8  s1178 = s1176 ^ s1177;+  const SWord8  s1179 = s1175 ^ s1178;+  const SWord8  s1180 = s1174 ^ s1179;+  const SWord8  s1181 = table2[s1154];+  const SWord8  s1182 = table3[s1156];+  const SWord8  s1183 = table4[s1159];+  const SWord8  s1184 = table1[s1161];+  const SWord8  s1185 = s1183 ^ s1184;+  const SWord8  s1186 = s1182 ^ s1185;+  const SWord8  s1187 = s1181 ^ s1186;+  const SWord16 s1188 = (((SWord16) s1180) << 8) | ((SWord16) s1187);+  const SWord32 s1189 = (((SWord32) s1173) << 16) | ((SWord32) s1188);+  const SWord16 s1190 = (SWord16) (s332 >> 16);+  const SWord8  s1191 = (SWord8) (s1190 >> 8);+  const SWord8  s1192 = table1[s1191];+  const SWord8  s1193 = (SWord8) s1190;+  const SWord8  s1194 = table2[s1193];+  const SWord16 s1195 = (SWord16) s332;+  const SWord8  s1196 = (SWord8) (s1195 >> 8);+  const SWord8  s1197 = table3[s1196];+  const SWord8  s1198 = (SWord8) s1195;+  const SWord8  s1199 = table4[s1198];+  const SWord8  s1200 = s1197 ^ s1199;+  const SWord8  s1201 = s1194 ^ s1200;+  const SWord8  s1202 = s1192 ^ s1201;+  const SWord8  s1203 = table4[s1191];+  const SWord8  s1204 = table1[s1193];+  const SWord8  s1205 = table2[s1196];+  const SWord8  s1206 = table3[s1198];+  const SWord8  s1207 = s1205 ^ s1206;+  const SWord8  s1208 = s1204 ^ s1207;+  const SWord8  s1209 = s1203 ^ s1208;+  const SWord16 s1210 = (((SWord16) s1202) << 8) | ((SWord16) s1209);+  const SWord8  s1211 = table3[s1191];+  const SWord8  s1212 = table4[s1193];+  const SWord8  s1213 = table1[s1196];+  const SWord8  s1214 = table2[s1198];+  const SWord8  s1215 = s1213 ^ s1214;+  const SWord8  s1216 = s1212 ^ s1215;+  const SWord8  s1217 = s1211 ^ s1216;+  const SWord8  s1218 = table2[s1191];+  const SWord8  s1219 = table3[s1193];+  const SWord8  s1220 = table4[s1196];+  const SWord8  s1221 = table1[s1198];+  const SWord8  s1222 = s1220 ^ s1221;+  const SWord8  s1223 = s1219 ^ s1222;+  const SWord8  s1224 = s1218 ^ s1223;+  const SWord16 s1225 = (((SWord16) s1217) << 8) | ((SWord16) s1224);+  const SWord32 s1226 = (((SWord32) s1210) << 16) | ((SWord32) s1225);+  const SWord16 s1227 = (SWord16) (s333 >> 16);+  const SWord8  s1228 = (SWord8) (s1227 >> 8);+  const SWord8  s1229 = table1[s1228];+  const SWord8  s1230 = (SWord8) s1227;+  const SWord8  s1231 = table2[s1230];+  const SWord16 s1232 = (SWord16) s333;+  const SWord8  s1233 = (SWord8) (s1232 >> 8);+  const SWord8  s1234 = table3[s1233];+  const SWord8  s1235 = (SWord8) s1232;+  const SWord8  s1236 = table4[s1235];+  const SWord8  s1237 = s1234 ^ s1236;+  const SWord8  s1238 = s1231 ^ s1237;+  const SWord8  s1239 = s1229 ^ s1238;+  const SWord8  s1240 = table4[s1228];+  const SWord8  s1241 = table1[s1230];+  const SWord8  s1242 = table2[s1233];+  const SWord8  s1243 = table3[s1235];+  const SWord8  s1244 = s1242 ^ s1243;+  const SWord8  s1245 = s1241 ^ s1244;+  const SWord8  s1246 = s1240 ^ s1245;+  const SWord16 s1247 = (((SWord16) s1239) << 8) | ((SWord16) s1246);+  const SWord8  s1248 = table3[s1228];+  const SWord8  s1249 = table4[s1230];+  const SWord8  s1250 = table1[s1233];+  const SWord8  s1251 = table2[s1235];+  const SWord8  s1252 = s1250 ^ s1251;+  const SWord8  s1253 = s1249 ^ s1252;+  const SWord8  s1254 = s1248 ^ s1253;+  const SWord8  s1255 = table2[s1228];+  const SWord8  s1256 = table3[s1230];+  const SWord8  s1257 = table4[s1233];+  const SWord8  s1258 = table1[s1235];+  const SWord8  s1259 = s1257 ^ s1258;+  const SWord8  s1260 = s1256 ^ s1259;+  const SWord8  s1261 = s1255 ^ s1260;+  const SWord16 s1262 = (((SWord16) s1254) << 8) | ((SWord16) s1261);+  const SWord32 s1263 = (((SWord32) s1247) << 16) | ((SWord32) s1262);+  const SWord16 s1264 = (SWord16) (s334 >> 16);+  const SWord8  s1265 = (SWord8) (s1264 >> 8);+  const SWord8  s1266 = table1[s1265];+  const SWord8  s1267 = (SWord8) s1264;+  const SWord8  s1268 = table2[s1267];+  const SWord16 s1269 = (SWord16) s334;+  const SWord8  s1270 = (SWord8) (s1269 >> 8);+  const SWord8  s1271 = table3[s1270];+  const SWord8  s1272 = (SWord8) s1269;+  const SWord8  s1273 = table4[s1272];+  const SWord8  s1274 = s1271 ^ s1273;+  const SWord8  s1275 = s1268 ^ s1274;+  const SWord8  s1276 = s1266 ^ s1275;+  const SWord8  s1277 = table4[s1265];+  const SWord8  s1278 = table1[s1267];+  const SWord8  s1279 = table2[s1270];+  const SWord8  s1280 = table3[s1272];+  const SWord8  s1281 = s1279 ^ s1280;+  const SWord8  s1282 = s1278 ^ s1281;+  const SWord8  s1283 = s1277 ^ s1282;+  const SWord16 s1284 = (((SWord16) s1276) << 8) | ((SWord16) s1283);+  const SWord8  s1285 = table3[s1265];+  const SWord8  s1286 = table4[s1267];+  const SWord8  s1287 = table1[s1270];+  const SWord8  s1288 = table2[s1272];+  const SWord8  s1289 = s1287 ^ s1288;+  const SWord8  s1290 = s1286 ^ s1289;+  const SWord8  s1291 = s1285 ^ s1290;+  const SWord8  s1292 = table2[s1265];+  const SWord8  s1293 = table3[s1267];+  const SWord8  s1294 = table4[s1270];+  const SWord8  s1295 = table1[s1272];+  const SWord8  s1296 = s1294 ^ s1295;+  const SWord8  s1297 = s1293 ^ s1296;+  const SWord8  s1298 = s1292 ^ s1297;+  const SWord16 s1299 = (((SWord16) s1291) << 8) | ((SWord16) s1298);+  const SWord32 s1300 = (((SWord32) s1284) << 16) | ((SWord32) s1299);+  const SWord16 s1301 = (SWord16) (s335 >> 16);+  const SWord8  s1302 = (SWord8) (s1301 >> 8);+  const SWord8  s1303 = table1[s1302];+  const SWord8  s1304 = (SWord8) s1301;+  const SWord8  s1305 = table2[s1304];+  const SWord16 s1306 = (SWord16) s335;+  const SWord8  s1307 = (SWord8) (s1306 >> 8);+  const SWord8  s1308 = table3[s1307];+  const SWord8  s1309 = (SWord8) s1306;+  const SWord8  s1310 = table4[s1309];+  const SWord8  s1311 = s1308 ^ s1310;+  const SWord8  s1312 = s1305 ^ s1311;+  const SWord8  s1313 = s1303 ^ s1312;+  const SWord8  s1314 = table4[s1302];+  const SWord8  s1315 = table1[s1304];+  const SWord8  s1316 = table2[s1307];+  const SWord8  s1317 = table3[s1309];+  const SWord8  s1318 = s1316 ^ s1317;+  const SWord8  s1319 = s1315 ^ s1318;+  const SWord8  s1320 = s1314 ^ s1319;+  const SWord16 s1321 = (((SWord16) s1313) << 8) | ((SWord16) s1320);+  const SWord8  s1322 = table3[s1302];+  const SWord8  s1323 = table4[s1304];+  const SWord8  s1324 = table1[s1307];+  const SWord8  s1325 = table2[s1309];+  const SWord8  s1326 = s1324 ^ s1325;+  const SWord8  s1327 = s1323 ^ s1326;+  const SWord8  s1328 = s1322 ^ s1327;+  const SWord8  s1329 = table2[s1302];+  const SWord8  s1330 = table3[s1304];+  const SWord8  s1331 = table4[s1307];+  const SWord8  s1332 = table1[s1309];+  const SWord8  s1333 = s1331 ^ s1332;+  const SWord8  s1334 = s1330 ^ s1333;+  const SWord8  s1335 = s1329 ^ s1334;+  const SWord16 s1336 = (((SWord16) s1328) << 8) | ((SWord16) s1335);+  const SWord32 s1337 = (((SWord32) s1321) << 16) | ((SWord32) s1336);+  const SWord16 s1338 = (SWord16) (s313 >> 16);+  const SWord8  s1339 = (SWord8) (s1338 >> 8);+  const SWord8  s1340 = table1[s1339];+  const SWord8  s1341 = (SWord8) s1338;+  const SWord8  s1342 = table2[s1341];+  const SWord16 s1343 = (SWord16) s313;+  const SWord8  s1344 = (SWord8) (s1343 >> 8);+  const SWord8  s1345 = table3[s1344];+  const SWord8  s1346 = (SWord8) s1343;+  const SWord8  s1347 = table4[s1346];+  const SWord8  s1348 = s1345 ^ s1347;+  const SWord8  s1349 = s1342 ^ s1348;+  const SWord8  s1350 = s1340 ^ s1349;+  const SWord8  s1351 = table4[s1339];+  const SWord8  s1352 = table1[s1341];+  const SWord8  s1353 = table2[s1344];+  const SWord8  s1354 = table3[s1346];+  const SWord8  s1355 = s1353 ^ s1354;+  const SWord8  s1356 = s1352 ^ s1355;+  const SWord8  s1357 = s1351 ^ s1356;+  const SWord16 s1358 = (((SWord16) s1350) << 8) | ((SWord16) s1357);+  const SWord8  s1359 = table3[s1339];+  const SWord8  s1360 = table4[s1341];+  const SWord8  s1361 = table1[s1344];+  const SWord8  s1362 = table2[s1346];+  const SWord8  s1363 = s1361 ^ s1362;+  const SWord8  s1364 = s1360 ^ s1363;+  const SWord8  s1365 = s1359 ^ s1364;+  const SWord8  s1366 = table2[s1339];+  const SWord8  s1367 = table3[s1341];+  const SWord8  s1368 = table4[s1344];+  const SWord8  s1369 = table1[s1346];+  const SWord8  s1370 = s1368 ^ s1369;+  const SWord8  s1371 = s1367 ^ s1370;+  const SWord8  s1372 = s1366 ^ s1371;+  const SWord16 s1373 = (((SWord16) s1365) << 8) | ((SWord16) s1372);+  const SWord32 s1374 = (((SWord32) s1358) << 16) | ((SWord32) s1373);+  const SWord16 s1375 = (SWord16) (s314 >> 16);+  const SWord8  s1376 = (SWord8) (s1375 >> 8);+  const SWord8  s1377 = table1[s1376];+  const SWord8  s1378 = (SWord8) s1375;+  const SWord8  s1379 = table2[s1378];+  const SWord16 s1380 = (SWord16) s314;+  const SWord8  s1381 = (SWord8) (s1380 >> 8);+  const SWord8  s1382 = table3[s1381];+  const SWord8  s1383 = (SWord8) s1380;+  const SWord8  s1384 = table4[s1383];+  const SWord8  s1385 = s1382 ^ s1384;+  const SWord8  s1386 = s1379 ^ s1385;+  const SWord8  s1387 = s1377 ^ s1386;+  const SWord8  s1388 = table4[s1376];+  const SWord8  s1389 = table1[s1378];+  const SWord8  s1390 = table2[s1381];+  const SWord8  s1391 = table3[s1383];+  const SWord8  s1392 = s1390 ^ s1391;+  const SWord8  s1393 = s1389 ^ s1392;+  const SWord8  s1394 = s1388 ^ s1393;+  const SWord16 s1395 = (((SWord16) s1387) << 8) | ((SWord16) s1394);+  const SWord8  s1396 = table3[s1376];+  const SWord8  s1397 = table4[s1378];+  const SWord8  s1398 = table1[s1381];+  const SWord8  s1399 = table2[s1383];+  const SWord8  s1400 = s1398 ^ s1399;+  const SWord8  s1401 = s1397 ^ s1400;+  const SWord8  s1402 = s1396 ^ s1401;+  const SWord8  s1403 = table2[s1376];+  const SWord8  s1404 = table3[s1378];+  const SWord8  s1405 = table4[s1381];+  const SWord8  s1406 = table1[s1383];+  const SWord8  s1407 = s1405 ^ s1406;+  const SWord8  s1408 = s1404 ^ s1407;+  const SWord8  s1409 = s1403 ^ s1408;+  const SWord16 s1410 = (((SWord16) s1402) << 8) | ((SWord16) s1409);+  const SWord32 s1411 = (((SWord32) s1395) << 16) | ((SWord32) s1410);+  const SWord16 s1412 = (SWord16) (s315 >> 16);+  const SWord8  s1413 = (SWord8) (s1412 >> 8);+  const SWord8  s1414 = table1[s1413];+  const SWord8  s1415 = (SWord8) s1412;+  const SWord8  s1416 = table2[s1415];+  const SWord16 s1417 = (SWord16) s315;+  const SWord8  s1418 = (SWord8) (s1417 >> 8);+  const SWord8  s1419 = table3[s1418];+  const SWord8  s1420 = (SWord8) s1417;+  const SWord8  s1421 = table4[s1420];+  const SWord8  s1422 = s1419 ^ s1421;+  const SWord8  s1423 = s1416 ^ s1422;+  const SWord8  s1424 = s1414 ^ s1423;+  const SWord8  s1425 = table4[s1413];+  const SWord8  s1426 = table1[s1415];+  const SWord8  s1427 = table2[s1418];+  const SWord8  s1428 = table3[s1420];+  const SWord8  s1429 = s1427 ^ s1428;+  const SWord8  s1430 = s1426 ^ s1429;+  const SWord8  s1431 = s1425 ^ s1430;+  const SWord16 s1432 = (((SWord16) s1424) << 8) | ((SWord16) s1431);+  const SWord8  s1433 = table3[s1413];+  const SWord8  s1434 = table4[s1415];+  const SWord8  s1435 = table1[s1418];+  const SWord8  s1436 = table2[s1420];+  const SWord8  s1437 = s1435 ^ s1436;+  const SWord8  s1438 = s1434 ^ s1437;+  const SWord8  s1439 = s1433 ^ s1438;+  const SWord8  s1440 = table2[s1413];+  const SWord8  s1441 = table3[s1415];+  const SWord8  s1442 = table4[s1418];+  const SWord8  s1443 = table1[s1420];+  const SWord8  s1444 = s1442 ^ s1443;+  const SWord8  s1445 = s1441 ^ s1444;+  const SWord8  s1446 = s1440 ^ s1445;+  const SWord16 s1447 = (((SWord16) s1439) << 8) | ((SWord16) s1446);+  const SWord32 s1448 = (((SWord32) s1432) << 16) | ((SWord32) s1447);+  const SWord16 s1449 = (SWord16) (s316 >> 16);+  const SWord8  s1450 = (SWord8) (s1449 >> 8);+  const SWord8  s1451 = table1[s1450];+  const SWord8  s1452 = (SWord8) s1449;+  const SWord8  s1453 = table2[s1452];+  const SWord16 s1454 = (SWord16) s316;+  const SWord8  s1455 = (SWord8) (s1454 >> 8);+  const SWord8  s1456 = table3[s1455];+  const SWord8  s1457 = (SWord8) s1454;+  const SWord8  s1458 = table4[s1457];+  const SWord8  s1459 = s1456 ^ s1458;+  const SWord8  s1460 = s1453 ^ s1459;+  const SWord8  s1461 = s1451 ^ s1460;+  const SWord8  s1462 = table4[s1450];+  const SWord8  s1463 = table1[s1452];+  const SWord8  s1464 = table2[s1455];+  const SWord8  s1465 = table3[s1457];+  const SWord8  s1466 = s1464 ^ s1465;+  const SWord8  s1467 = s1463 ^ s1466;+  const SWord8  s1468 = s1462 ^ s1467;+  const SWord16 s1469 = (((SWord16) s1461) << 8) | ((SWord16) s1468);+  const SWord8  s1470 = table3[s1450];+  const SWord8  s1471 = table4[s1452];+  const SWord8  s1472 = table1[s1455];+  const SWord8  s1473 = table2[s1457];+  const SWord8  s1474 = s1472 ^ s1473;+  const SWord8  s1475 = s1471 ^ s1474;+  const SWord8  s1476 = s1470 ^ s1475;+  const SWord8  s1477 = table2[s1450];+  const SWord8  s1478 = table3[s1452];+  const SWord8  s1479 = table4[s1455];+  const SWord8  s1480 = table1[s1457];+  const SWord8  s1481 = s1479 ^ s1480;+  const SWord8  s1482 = s1478 ^ s1481;+  const SWord8  s1483 = s1477 ^ s1482;+  const SWord16 s1484 = (((SWord16) s1476) << 8) | ((SWord16) s1483);+  const SWord32 s1485 = (((SWord32) s1469) << 16) | ((SWord32) s1484);+  const SWord16 s1486 = (SWord16) (s294 >> 16);+  const SWord8  s1487 = (SWord8) (s1486 >> 8);+  const SWord8  s1488 = table1[s1487];+  const SWord8  s1489 = (SWord8) s1486;+  const SWord8  s1490 = table2[s1489];+  const SWord16 s1491 = (SWord16) s294;+  const SWord8  s1492 = (SWord8) (s1491 >> 8);+  const SWord8  s1493 = table3[s1492];+  const SWord8  s1494 = (SWord8) s1491;+  const SWord8  s1495 = table4[s1494];+  const SWord8  s1496 = s1493 ^ s1495;+  const SWord8  s1497 = s1490 ^ s1496;+  const SWord8  s1498 = s1488 ^ s1497;+  const SWord8  s1499 = table4[s1487];+  const SWord8  s1500 = table1[s1489];+  const SWord8  s1501 = table2[s1492];+  const SWord8  s1502 = table3[s1494];+  const SWord8  s1503 = s1501 ^ s1502;+  const SWord8  s1504 = s1500 ^ s1503;+  const SWord8  s1505 = s1499 ^ s1504;+  const SWord16 s1506 = (((SWord16) s1498) << 8) | ((SWord16) s1505);+  const SWord8  s1507 = table3[s1487];+  const SWord8  s1508 = table4[s1489];+  const SWord8  s1509 = table1[s1492];+  const SWord8  s1510 = table2[s1494];+  const SWord8  s1511 = s1509 ^ s1510;+  const SWord8  s1512 = s1508 ^ s1511;+  const SWord8  s1513 = s1507 ^ s1512;+  const SWord8  s1514 = table2[s1487];+  const SWord8  s1515 = table3[s1489];+  const SWord8  s1516 = table4[s1492];+  const SWord8  s1517 = table1[s1494];+  const SWord8  s1518 = s1516 ^ s1517;+  const SWord8  s1519 = s1515 ^ s1518;+  const SWord8  s1520 = s1514 ^ s1519;+  const SWord16 s1521 = (((SWord16) s1513) << 8) | ((SWord16) s1520);+  const SWord32 s1522 = (((SWord32) s1506) << 16) | ((SWord32) s1521);+  const SWord16 s1523 = (SWord16) (s295 >> 16);+  const SWord8  s1524 = (SWord8) (s1523 >> 8);+  const SWord8  s1525 = table1[s1524];+  const SWord8  s1526 = (SWord8) s1523;+  const SWord8  s1527 = table2[s1526];+  const SWord16 s1528 = (SWord16) s295;+  const SWord8  s1529 = (SWord8) (s1528 >> 8);+  const SWord8  s1530 = table3[s1529];+  const SWord8  s1531 = (SWord8) s1528;+  const SWord8  s1532 = table4[s1531];+  const SWord8  s1533 = s1530 ^ s1532;+  const SWord8  s1534 = s1527 ^ s1533;+  const SWord8  s1535 = s1525 ^ s1534;+  const SWord8  s1536 = table4[s1524];+  const SWord8  s1537 = table1[s1526];+  const SWord8  s1538 = table2[s1529];+  const SWord8  s1539 = table3[s1531];+  const SWord8  s1540 = s1538 ^ s1539;+  const SWord8  s1541 = s1537 ^ s1540;+  const SWord8  s1542 = s1536 ^ s1541;+  const SWord16 s1543 = (((SWord16) s1535) << 8) | ((SWord16) s1542);+  const SWord8  s1544 = table3[s1524];+  const SWord8  s1545 = table4[s1526];+  const SWord8  s1546 = table1[s1529];+  const SWord8  s1547 = table2[s1531];+  const SWord8  s1548 = s1546 ^ s1547;+  const SWord8  s1549 = s1545 ^ s1548;+  const SWord8  s1550 = s1544 ^ s1549;+  const SWord8  s1551 = table2[s1524];+  const SWord8  s1552 = table3[s1526];+  const SWord8  s1553 = table4[s1529];+  const SWord8  s1554 = table1[s1531];+  const SWord8  s1555 = s1553 ^ s1554;+  const SWord8  s1556 = s1552 ^ s1555;+  const SWord8  s1557 = s1551 ^ s1556;+  const SWord16 s1558 = (((SWord16) s1550) << 8) | ((SWord16) s1557);+  const SWord32 s1559 = (((SWord32) s1543) << 16) | ((SWord32) s1558);+  const SWord16 s1560 = (SWord16) (s296 >> 16);+  const SWord8  s1561 = (SWord8) (s1560 >> 8);+  const SWord8  s1562 = table1[s1561];+  const SWord8  s1563 = (SWord8) s1560;+  const SWord8  s1564 = table2[s1563];+  const SWord16 s1565 = (SWord16) s296;+  const SWord8  s1566 = (SWord8) (s1565 >> 8);+  const SWord8  s1567 = table3[s1566];+  const SWord8  s1568 = (SWord8) s1565;+  const SWord8  s1569 = table4[s1568];+  const SWord8  s1570 = s1567 ^ s1569;+  const SWord8  s1571 = s1564 ^ s1570;+  const SWord8  s1572 = s1562 ^ s1571;+  const SWord8  s1573 = table4[s1561];+  const SWord8  s1574 = table1[s1563];+  const SWord8  s1575 = table2[s1566];+  const SWord8  s1576 = table3[s1568];+  const SWord8  s1577 = s1575 ^ s1576;+  const SWord8  s1578 = s1574 ^ s1577;+  const SWord8  s1579 = s1573 ^ s1578;+  const SWord16 s1580 = (((SWord16) s1572) << 8) | ((SWord16) s1579);+  const SWord8  s1581 = table3[s1561];+  const SWord8  s1582 = table4[s1563];+  const SWord8  s1583 = table1[s1566];+  const SWord8  s1584 = table2[s1568];+  const SWord8  s1585 = s1583 ^ s1584;+  const SWord8  s1586 = s1582 ^ s1585;+  const SWord8  s1587 = s1581 ^ s1586;+  const SWord8  s1588 = table2[s1561];+  const SWord8  s1589 = table3[s1563];+  const SWord8  s1590 = table4[s1566];+  const SWord8  s1591 = table1[s1568];+  const SWord8  s1592 = s1590 ^ s1591;+  const SWord8  s1593 = s1589 ^ s1592;+  const SWord8  s1594 = s1588 ^ s1593;+  const SWord16 s1595 = (((SWord16) s1587) << 8) | ((SWord16) s1594);+  const SWord32 s1596 = (((SWord32) s1580) << 16) | ((SWord32) s1595);+  const SWord16 s1597 = (SWord16) (s297 >> 16);+  const SWord8  s1598 = (SWord8) (s1597 >> 8);+  const SWord8  s1599 = table1[s1598];+  const SWord8  s1600 = (SWord8) s1597;+  const SWord8  s1601 = table2[s1600];+  const SWord16 s1602 = (SWord16) s297;+  const SWord8  s1603 = (SWord8) (s1602 >> 8);+  const SWord8  s1604 = table3[s1603];+  const SWord8  s1605 = (SWord8) s1602;+  const SWord8  s1606 = table4[s1605];+  const SWord8  s1607 = s1604 ^ s1606;+  const SWord8  s1608 = s1601 ^ s1607;+  const SWord8  s1609 = s1599 ^ s1608;+  const SWord8  s1610 = table4[s1598];+  const SWord8  s1611 = table1[s1600];+  const SWord8  s1612 = table2[s1603];+  const SWord8  s1613 = table3[s1605];+  const SWord8  s1614 = s1612 ^ s1613;+  const SWord8  s1615 = s1611 ^ s1614;+  const SWord8  s1616 = s1610 ^ s1615;+  const SWord16 s1617 = (((SWord16) s1609) << 8) | ((SWord16) s1616);+  const SWord8  s1618 = table3[s1598];+  const SWord8  s1619 = table4[s1600];+  const SWord8  s1620 = table1[s1603];+  const SWord8  s1621 = table2[s1605];+  const SWord8  s1622 = s1620 ^ s1621;+  const SWord8  s1623 = s1619 ^ s1622;+  const SWord8  s1624 = s1618 ^ s1623;+  const SWord8  s1625 = table2[s1598];+  const SWord8  s1626 = table3[s1600];+  const SWord8  s1627 = table4[s1603];+  const SWord8  s1628 = table1[s1605];+  const SWord8  s1629 = s1627 ^ s1628;+  const SWord8  s1630 = s1626 ^ s1629;+  const SWord8  s1631 = s1625 ^ s1630;+  const SWord16 s1632 = (((SWord16) s1624) << 8) | ((SWord16) s1631);+  const SWord32 s1633 = (((SWord32) s1617) << 16) | ((SWord32) s1632);+  const SWord16 s1634 = (SWord16) (s275 >> 16);+  const SWord8  s1635 = (SWord8) (s1634 >> 8);+  const SWord8  s1636 = table1[s1635];+  const SWord8  s1637 = (SWord8) s1634;+  const SWord8  s1638 = table2[s1637];+  const SWord16 s1639 = (SWord16) s275;+  const SWord8  s1640 = (SWord8) (s1639 >> 8);+  const SWord8  s1641 = table3[s1640];+  const SWord8  s1642 = (SWord8) s1639;+  const SWord8  s1643 = table4[s1642];+  const SWord8  s1644 = s1641 ^ s1643;+  const SWord8  s1645 = s1638 ^ s1644;+  const SWord8  s1646 = s1636 ^ s1645;+  const SWord8  s1647 = table4[s1635];+  const SWord8  s1648 = table1[s1637];+  const SWord8  s1649 = table2[s1640];+  const SWord8  s1650 = table3[s1642];+  const SWord8  s1651 = s1649 ^ s1650;+  const SWord8  s1652 = s1648 ^ s1651;+  const SWord8  s1653 = s1647 ^ s1652;+  const SWord16 s1654 = (((SWord16) s1646) << 8) | ((SWord16) s1653);+  const SWord8  s1655 = table3[s1635];+  const SWord8  s1656 = table4[s1637];+  const SWord8  s1657 = table1[s1640];+  const SWord8  s1658 = table2[s1642];+  const SWord8  s1659 = s1657 ^ s1658;+  const SWord8  s1660 = s1656 ^ s1659;+  const SWord8  s1661 = s1655 ^ s1660;+  const SWord8  s1662 = table2[s1635];+  const SWord8  s1663 = table3[s1637];+  const SWord8  s1664 = table4[s1640];+  const SWord8  s1665 = table1[s1642];+  const SWord8  s1666 = s1664 ^ s1665;+  const SWord8  s1667 = s1663 ^ s1666;+  const SWord8  s1668 = s1662 ^ s1667;+  const SWord16 s1669 = (((SWord16) s1661) << 8) | ((SWord16) s1668);+  const SWord32 s1670 = (((SWord32) s1654) << 16) | ((SWord32) s1669);+  const SWord16 s1671 = (SWord16) (s276 >> 16);+  const SWord8  s1672 = (SWord8) (s1671 >> 8);+  const SWord8  s1673 = table1[s1672];+  const SWord8  s1674 = (SWord8) s1671;+  const SWord8  s1675 = table2[s1674];+  const SWord16 s1676 = (SWord16) s276;+  const SWord8  s1677 = (SWord8) (s1676 >> 8);+  const SWord8  s1678 = table3[s1677];+  const SWord8  s1679 = (SWord8) s1676;+  const SWord8  s1680 = table4[s1679];+  const SWord8  s1681 = s1678 ^ s1680;+  const SWord8  s1682 = s1675 ^ s1681;+  const SWord8  s1683 = s1673 ^ s1682;+  const SWord8  s1684 = table4[s1672];+  const SWord8  s1685 = table1[s1674];+  const SWord8  s1686 = table2[s1677];+  const SWord8  s1687 = table3[s1679];+  const SWord8  s1688 = s1686 ^ s1687;+  const SWord8  s1689 = s1685 ^ s1688;+  const SWord8  s1690 = s1684 ^ s1689;+  const SWord16 s1691 = (((SWord16) s1683) << 8) | ((SWord16) s1690);+  const SWord8  s1692 = table3[s1672];+  const SWord8  s1693 = table4[s1674];+  const SWord8  s1694 = table1[s1677];+  const SWord8  s1695 = table2[s1679];+  const SWord8  s1696 = s1694 ^ s1695;+  const SWord8  s1697 = s1693 ^ s1696;+  const SWord8  s1698 = s1692 ^ s1697;+  const SWord8  s1699 = table2[s1672];+  const SWord8  s1700 = table3[s1674];+  const SWord8  s1701 = table4[s1677];+  const SWord8  s1702 = table1[s1679];+  const SWord8  s1703 = s1701 ^ s1702;+  const SWord8  s1704 = s1700 ^ s1703;+  const SWord8  s1705 = s1699 ^ s1704;+  const SWord16 s1706 = (((SWord16) s1698) << 8) | ((SWord16) s1705);+  const SWord32 s1707 = (((SWord32) s1691) << 16) | ((SWord32) s1706);+  const SWord16 s1708 = (SWord16) (s277 >> 16);+  const SWord8  s1709 = (SWord8) (s1708 >> 8);+  const SWord8  s1710 = table1[s1709];+  const SWord8  s1711 = (SWord8) s1708;+  const SWord8  s1712 = table2[s1711];+  const SWord16 s1713 = (SWord16) s277;+  const SWord8  s1714 = (SWord8) (s1713 >> 8);+  const SWord8  s1715 = table3[s1714];+  const SWord8  s1716 = (SWord8) s1713;+  const SWord8  s1717 = table4[s1716];+  const SWord8  s1718 = s1715 ^ s1717;+  const SWord8  s1719 = s1712 ^ s1718;+  const SWord8  s1720 = s1710 ^ s1719;+  const SWord8  s1721 = table4[s1709];+  const SWord8  s1722 = table1[s1711];+  const SWord8  s1723 = table2[s1714];+  const SWord8  s1724 = table3[s1716];+  const SWord8  s1725 = s1723 ^ s1724;+  const SWord8  s1726 = s1722 ^ s1725;+  const SWord8  s1727 = s1721 ^ s1726;+  const SWord16 s1728 = (((SWord16) s1720) << 8) | ((SWord16) s1727);+  const SWord8  s1729 = table3[s1709];+  const SWord8  s1730 = table4[s1711];+  const SWord8  s1731 = table1[s1714];+  const SWord8  s1732 = table2[s1716];+  const SWord8  s1733 = s1731 ^ s1732;+  const SWord8  s1734 = s1730 ^ s1733;+  const SWord8  s1735 = s1729 ^ s1734;+  const SWord8  s1736 = table2[s1709];+  const SWord8  s1737 = table3[s1711];+  const SWord8  s1738 = table4[s1714];+  const SWord8  s1739 = table1[s1716];+  const SWord8  s1740 = s1738 ^ s1739;+  const SWord8  s1741 = s1737 ^ s1740;+  const SWord8  s1742 = s1736 ^ s1741;+  const SWord16 s1743 = (((SWord16) s1735) << 8) | ((SWord16) s1742);+  const SWord32 s1744 = (((SWord32) s1728) << 16) | ((SWord32) s1743);+  const SWord16 s1745 = (SWord16) (s278 >> 16);+  const SWord8  s1746 = (SWord8) (s1745 >> 8);+  const SWord8  s1747 = table1[s1746];+  const SWord8  s1748 = (SWord8) s1745;+  const SWord8  s1749 = table2[s1748];+  const SWord16 s1750 = (SWord16) s278;+  const SWord8  s1751 = (SWord8) (s1750 >> 8);+  const SWord8  s1752 = table3[s1751];+  const SWord8  s1753 = (SWord8) s1750;+  const SWord8  s1754 = table4[s1753];+  const SWord8  s1755 = s1752 ^ s1754;+  const SWord8  s1756 = s1749 ^ s1755;+  const SWord8  s1757 = s1747 ^ s1756;+  const SWord8  s1758 = table4[s1746];+  const SWord8  s1759 = table1[s1748];+  const SWord8  s1760 = table2[s1751];+  const SWord8  s1761 = table3[s1753];+  const SWord8  s1762 = s1760 ^ s1761;+  const SWord8  s1763 = s1759 ^ s1762;+  const SWord8  s1764 = s1758 ^ s1763;+  const SWord16 s1765 = (((SWord16) s1757) << 8) | ((SWord16) s1764);+  const SWord8  s1766 = table3[s1746];+  const SWord8  s1767 = table4[s1748];+  const SWord8  s1768 = table1[s1751];+  const SWord8  s1769 = table2[s1753];+  const SWord8  s1770 = s1768 ^ s1769;+  const SWord8  s1771 = s1767 ^ s1770;+  const SWord8  s1772 = s1766 ^ s1771;+  const SWord8  s1773 = table2[s1746];+  const SWord8  s1774 = table3[s1748];+  const SWord8  s1775 = table4[s1751];+  const SWord8  s1776 = table1[s1753];+  const SWord8  s1777 = s1775 ^ s1776;+  const SWord8  s1778 = s1774 ^ s1777;+  const SWord8  s1779 = s1773 ^ s1778;+  const SWord16 s1780 = (((SWord16) s1772) << 8) | ((SWord16) s1779);+  const SWord32 s1781 = (((SWord32) s1765) << 16) | ((SWord32) s1780);++  encKS[0] = s0;+  encKS[1] = s1;+  encKS[2] = s2;+  encKS[3] = s3;+  encKS[4] = s275;+  encKS[5] = s276;+  encKS[6] = s277;+  encKS[7] = s278;+  encKS[8] = s294;+  encKS[9] = s295;+  encKS[10] = s296;+  encKS[11] = s297;+  encKS[12] = s313;+  encKS[13] = s314;+  encKS[14] = s315;+  encKS[15] = s316;+  encKS[16] = s332;+  encKS[17] = s333;+  encKS[18] = s334;+  encKS[19] = s335;+  encKS[20] = s351;+  encKS[21] = s352;+  encKS[22] = s353;+  encKS[23] = s354;+  encKS[24] = s370;+  encKS[25] = s371;+  encKS[26] = s372;+  encKS[27] = s373;+  encKS[28] = s389;+  encKS[29] = s390;+  encKS[30] = s391;+  encKS[31] = s392;+  encKS[32] = s408;+  encKS[33] = s409;+  encKS[34] = s410;+  encKS[35] = s411;+  encKS[36] = s427;+  encKS[37] = s428;+  encKS[38] = s429;+  encKS[39] = s430;+  encKS[40] = s446;+  encKS[41] = s447;+  encKS[42] = s448;+  encKS[43] = s449;+  decKS[0] = s446;+  decKS[1] = s447;+  decKS[2] = s448;+  decKS[3] = s449;+  decKS[4] = s486;+  decKS[5] = s523;+  decKS[6] = s560;+  decKS[7] = s597;+  decKS[8] = s634;+  decKS[9] = s671;+  decKS[10] = s708;+  decKS[11] = s745;+  decKS[12] = s782;+  decKS[13] = s819;+  decKS[14] = s856;+  decKS[15] = s893;+  decKS[16] = s930;+  decKS[17] = s967;+  decKS[18] = s1004;+  decKS[19] = s1041;+  decKS[20] = s1078;+  decKS[21] = s1115;+  decKS[22] = s1152;+  decKS[23] = s1189;+  decKS[24] = s1226;+  decKS[25] = s1263;+  decKS[26] = s1300;+  decKS[27] = s1337;+  decKS[28] = s1374;+  decKS[29] = s1411;+  decKS[30] = s1448;+  decKS[31] = s1485;+  decKS[32] = s1522;+  decKS[33] = s1559;+  decKS[34] = s1596;+  decKS[35] = s1633;+  decKS[36] = s1670;+  decKS[37] = s1707;+  decKS[38] = s1744;+  decKS[39] = s1781;+  decKS[40] = s0;+  decKS[41] = s1;+  decKS[42] = s2;+  decKS[43] = s3;+}+== END: "aes128KeySchedule.c" ==================+== BEGIN: "aes128BlockEncrypt.c" ================+/* File: "aes128BlockEncrypt.c". Automatically generated by SBV. Do not edit! */++#include "aes128Lib.h"++void aes128BlockEncrypt(const SWord32 *pt, const SWord32 *xkey,+                        SWord32 *ct)+{+  const SWord32 s0 = pt[0];+  const SWord32 s1 = pt[1];+  const SWord32 s2 = pt[2];+  const SWord32 s3 = pt[3];+  const SWord32 s4 = xkey[0];+  const SWord32 s5 = xkey[1];+  const SWord32 s6 = xkey[2];+  const SWord32 s7 = xkey[3];+  const SWord32 s8 = xkey[4];+  const SWord32 s9 = xkey[5];+  const SWord32 s10 = xkey[6];+  const SWord32 s11 = xkey[7];+  const SWord32 s12 = xkey[8];+  const SWord32 s13 = xkey[9];+  const SWord32 s14 = xkey[10];+  const SWord32 s15 = xkey[11];+  const SWord32 s16 = xkey[12];+  const SWord32 s17 = xkey[13];+  const SWord32 s18 = xkey[14];+  const SWord32 s19 = xkey[15];+  const SWord32 s20 = xkey[16];+  const SWord32 s21 = xkey[17];+  const SWord32 s22 = xkey[18];+  const SWord32 s23 = xkey[19];+  const SWord32 s24 = xkey[20];+  const SWord32 s25 = xkey[21];+  const SWord32 s26 = xkey[22];+  const SWord32 s27 = xkey[23];+  const SWord32 s28 = xkey[24];+  const SWord32 s29 = xkey[25];+  const SWord32 s30 = xkey[26];+  const SWord32 s31 = xkey[27];+  const SWord32 s32 = xkey[28];+  const SWord32 s33 = xkey[29];+  const SWord32 s34 = xkey[30];+  const SWord32 s35 = xkey[31];+  const SWord32 s36 = xkey[32];+  const SWord32 s37 = xkey[33];+  const SWord32 s38 = xkey[34];+  const SWord32 s39 = xkey[35];+  const SWord32 s40 = xkey[36];+  const SWord32 s41 = xkey[37];+  const SWord32 s42 = xkey[38];+  const SWord32 s43 = xkey[39];+  const SWord32 s44 = xkey[40];+  const SWord32 s45 = xkey[41];+  const SWord32 s46 = xkey[42];+  const SWord32 s47 = xkey[43];+  static const SWord8 table0[] = {+       99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254,+      215, 171, 118, 202, 130, 201, 125, 250,  89,  71, 240, 173, 212,+      162, 175, 156, 164, 114, 192, 183, 253, 147,  38,  54,  63, 247,+      204,  52, 165, 229, 241, 113, 216,  49,  21,   4, 199,  35, 195,+       24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,   9,+      131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,+       47, 132,  83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,+       57,  74,  76,  88, 207, 208, 239, 170, 251,  67,  77,  51, 133,+       69, 249,   2, 127,  80,  60, 159, 168,  81, 163,  64, 143, 146,+      157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210, 205,  12,+       19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25,+      115,  96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20,+      222,  94,  11, 219, 224,  50,  58,  10,  73,   6,  36,  92, 194,+      211, 172,  98, 145, 149, 228, 121, 231, 200,  55, 109, 141, 213,+       78, 169, 108,  86, 244, 234, 101, 122, 174,   8, 186, 120,  37,+       46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,+      112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134,+      193,  29, 158, 225, 248, 152,  17, 105, 217, 142, 148, 155,  30,+      135, 233, 206,  85,  40, 223, 140, 161, 137,  13, 191, 230,  66,+      104,  65, 153,  45,  15, 176,  84, 187,  22+  };+  static const SWord32 table1[] = {+      0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL,+      0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL,+      0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL,+      0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL,+      0x8fcaca45UL, 0x1f82829dUL, 0x89c9c940UL, 0xfa7d7d87UL,+      0xeffafa15UL, 0xb25959ebUL, 0x8e4747c9UL, 0xfbf0f00bUL,+      0x41adadecUL, 0xb3d4d467UL, 0x5fa2a2fdUL, 0x45afafeaUL,+      0x239c9cbfUL, 0x53a4a4f7UL, 0xe4727296UL, 0x9bc0c05bUL,+      0x75b7b7c2UL, 0xe1fdfd1cUL, 0x3d9393aeUL, 0x4c26266aUL,+      0x6c36365aUL, 0x7e3f3f41UL, 0xf5f7f702UL, 0x83cccc4fUL,+      0x6834345cUL, 0x51a5a5f4UL, 0xd1e5e534UL, 0xf9f1f108UL,+      0xe2717193UL, 0xabd8d873UL, 0x62313153UL, 0x2a15153fUL,+      0x0804040cUL, 0x95c7c752UL, 0x46232365UL, 0x9dc3c35eUL,+      0x30181828UL, 0x379696a1UL, 0x0a05050fUL, 0x2f9a9ab5UL,+      0x0e070709UL, 0x24121236UL, 0x1b80809bUL, 0xdfe2e23dUL,+      0xcdebeb26UL, 0x4e272769UL, 0x7fb2b2cdUL, 0xea75759fUL,+      0x1209091bUL, 0x1d83839eUL, 0x582c2c74UL, 0x341a1a2eUL,+      0x361b1b2dUL, 0xdc6e6eb2UL, 0xb45a5aeeUL, 0x5ba0a0fbUL,+      0xa45252f6UL, 0x763b3b4dUL, 0xb7d6d661UL, 0x7db3b3ceUL,+      0x5229297bUL, 0xdde3e33eUL, 0x5e2f2f71UL, 0x13848497UL,+      0xa65353f5UL, 0xb9d1d168UL, 0x00000000UL, 0xc1eded2cUL,+      0x40202060UL, 0xe3fcfc1fUL, 0x79b1b1c8UL, 0xb65b5bedUL,+      0xd46a6abeUL, 0x8dcbcb46UL, 0x67bebed9UL, 0x7239394bUL,+      0x944a4adeUL, 0x984c4cd4UL, 0xb05858e8UL, 0x85cfcf4aUL,+      0xbbd0d06bUL, 0xc5efef2aUL, 0x4faaaae5UL, 0xedfbfb16UL,+      0x864343c5UL, 0x9a4d4dd7UL, 0x66333355UL, 0x11858594UL,+      0x8a4545cfUL, 0xe9f9f910UL, 0x04020206UL, 0xfe7f7f81UL,+      0xa05050f0UL, 0x783c3c44UL, 0x259f9fbaUL, 0x4ba8a8e3UL,+      0xa25151f3UL, 0x5da3a3feUL, 0x804040c0UL, 0x058f8f8aUL,+      0x3f9292adUL, 0x219d9dbcUL, 0x70383848UL, 0xf1f5f504UL,+      0x63bcbcdfUL, 0x77b6b6c1UL, 0xafdada75UL, 0x42212163UL,+      0x20101030UL, 0xe5ffff1aUL, 0xfdf3f30eUL, 0xbfd2d26dUL,+      0x81cdcd4cUL, 0x180c0c14UL, 0x26131335UL, 0xc3ecec2fUL,+      0xbe5f5fe1UL, 0x359797a2UL, 0x884444ccUL, 0x2e171739UL,+      0x93c4c457UL, 0x55a7a7f2UL, 0xfc7e7e82UL, 0x7a3d3d47UL,+      0xc86464acUL, 0xba5d5de7UL, 0x3219192bUL, 0xe6737395UL,+      0xc06060a0UL, 0x19818198UL, 0x9e4f4fd1UL, 0xa3dcdc7fUL,+      0x44222266UL, 0x542a2a7eUL, 0x3b9090abUL, 0x0b888883UL,+      0x8c4646caUL, 0xc7eeee29UL, 0x6bb8b8d3UL, 0x2814143cUL,+      0xa7dede79UL, 0xbc5e5ee2UL, 0x160b0b1dUL, 0xaddbdb76UL,+      0xdbe0e03bUL, 0x64323256UL, 0x743a3a4eUL, 0x140a0a1eUL,+      0x924949dbUL, 0x0c06060aUL, 0x4824246cUL, 0xb85c5ce4UL,+      0x9fc2c25dUL, 0xbdd3d36eUL, 0x43acacefUL, 0xc46262a6UL,+      0x399191a8UL, 0x319595a4UL, 0xd3e4e437UL, 0xf279798bUL,+      0xd5e7e732UL, 0x8bc8c843UL, 0x6e373759UL, 0xda6d6db7UL,+      0x018d8d8cUL, 0xb1d5d564UL, 0x9c4e4ed2UL, 0x49a9a9e0UL,+      0xd86c6cb4UL, 0xac5656faUL, 0xf3f4f407UL, 0xcfeaea25UL,+      0xca6565afUL, 0xf47a7a8eUL, 0x47aeaee9UL, 0x10080818UL,+      0x6fbabad5UL, 0xf0787888UL, 0x4a25256fUL, 0x5c2e2e72UL,+      0x381c1c24UL, 0x57a6a6f1UL, 0x73b4b4c7UL, 0x97c6c651UL,+      0xcbe8e823UL, 0xa1dddd7cUL, 0xe874749cUL, 0x3e1f1f21UL,+      0x964b4bddUL, 0x61bdbddcUL, 0x0d8b8b86UL, 0x0f8a8a85UL,+      0xe0707090UL, 0x7c3e3e42UL, 0x71b5b5c4UL, 0xcc6666aaUL,+      0x904848d8UL, 0x06030305UL, 0xf7f6f601UL, 0x1c0e0e12UL,+      0xc26161a3UL, 0x6a35355fUL, 0xae5757f9UL, 0x69b9b9d0UL,+      0x17868691UL, 0x99c1c158UL, 0x3a1d1d27UL, 0x279e9eb9UL,+      0xd9e1e138UL, 0xebf8f813UL, 0x2b9898b3UL, 0x22111133UL,+      0xd26969bbUL, 0xa9d9d970UL, 0x078e8e89UL, 0x339494a7UL,+      0x2d9b9bb6UL, 0x3c1e1e22UL, 0x15878792UL, 0xc9e9e920UL,+      0x87cece49UL, 0xaa5555ffUL, 0x50282878UL, 0xa5dfdf7aUL,+      0x038c8c8fUL, 0x59a1a1f8UL, 0x09898980UL, 0x1a0d0d17UL,+      0x65bfbfdaUL, 0xd7e6e631UL, 0x844242c6UL, 0xd06868b8UL,+      0x824141c3UL, 0x299999b0UL, 0x5a2d2d77UL, 0x1e0f0f11UL,+      0x7bb0b0cbUL, 0xa85454fcUL, 0x6dbbbbd6UL, 0x2c16163aUL+  };+  static const SWord32 table2[] = {+      0xa5c66363UL, 0x84f87c7cUL, 0x99ee7777UL, 0x8df67b7bUL,+      0x0dfff2f2UL, 0xbdd66b6bUL, 0xb1de6f6fUL, 0x5491c5c5UL,+      0x50603030UL, 0x03020101UL, 0xa9ce6767UL, 0x7d562b2bUL,+      0x19e7fefeUL, 0x62b5d7d7UL, 0xe64dababUL, 0x9aec7676UL,+      0x458fcacaUL, 0x9d1f8282UL, 0x4089c9c9UL, 0x87fa7d7dUL,+      0x15effafaUL, 0xebb25959UL, 0xc98e4747UL, 0x0bfbf0f0UL,+      0xec41adadUL, 0x67b3d4d4UL, 0xfd5fa2a2UL, 0xea45afafUL,+      0xbf239c9cUL, 0xf753a4a4UL, 0x96e47272UL, 0x5b9bc0c0UL,+      0xc275b7b7UL, 0x1ce1fdfdUL, 0xae3d9393UL, 0x6a4c2626UL,+      0x5a6c3636UL, 0x417e3f3fUL, 0x02f5f7f7UL, 0x4f83ccccUL,+      0x5c683434UL, 0xf451a5a5UL, 0x34d1e5e5UL, 0x08f9f1f1UL,+      0x93e27171UL, 0x73abd8d8UL, 0x53623131UL, 0x3f2a1515UL,+      0x0c080404UL, 0x5295c7c7UL, 0x65462323UL, 0x5e9dc3c3UL,+      0x28301818UL, 0xa1379696UL, 0x0f0a0505UL, 0xb52f9a9aUL,+      0x090e0707UL, 0x36241212UL, 0x9b1b8080UL, 0x3ddfe2e2UL,+      0x26cdebebUL, 0x694e2727UL, 0xcd7fb2b2UL, 0x9fea7575UL,+      0x1b120909UL, 0x9e1d8383UL, 0x74582c2cUL, 0x2e341a1aUL,+      0x2d361b1bUL, 0xb2dc6e6eUL, 0xeeb45a5aUL, 0xfb5ba0a0UL,+      0xf6a45252UL, 0x4d763b3bUL, 0x61b7d6d6UL, 0xce7db3b3UL,+      0x7b522929UL, 0x3edde3e3UL, 0x715e2f2fUL, 0x97138484UL,+      0xf5a65353UL, 0x68b9d1d1UL, 0x00000000UL, 0x2cc1ededUL,+      0x60402020UL, 0x1fe3fcfcUL, 0xc879b1b1UL, 0xedb65b5bUL,+      0xbed46a6aUL, 0x468dcbcbUL, 0xd967bebeUL, 0x4b723939UL,+      0xde944a4aUL, 0xd4984c4cUL, 0xe8b05858UL, 0x4a85cfcfUL,+      0x6bbbd0d0UL, 0x2ac5efefUL, 0xe54faaaaUL, 0x16edfbfbUL,+      0xc5864343UL, 0xd79a4d4dUL, 0x55663333UL, 0x94118585UL,+      0xcf8a4545UL, 0x10e9f9f9UL, 0x06040202UL, 0x81fe7f7fUL,+      0xf0a05050UL, 0x44783c3cUL, 0xba259f9fUL, 0xe34ba8a8UL,+      0xf3a25151UL, 0xfe5da3a3UL, 0xc0804040UL, 0x8a058f8fUL,+      0xad3f9292UL, 0xbc219d9dUL, 0x48703838UL, 0x04f1f5f5UL,+      0xdf63bcbcUL, 0xc177b6b6UL, 0x75afdadaUL, 0x63422121UL,+      0x30201010UL, 0x1ae5ffffUL, 0x0efdf3f3UL, 0x6dbfd2d2UL,+      0x4c81cdcdUL, 0x14180c0cUL, 0x35261313UL, 0x2fc3ececUL,+      0xe1be5f5fUL, 0xa2359797UL, 0xcc884444UL, 0x392e1717UL,+      0x5793c4c4UL, 0xf255a7a7UL, 0x82fc7e7eUL, 0x477a3d3dUL,+      0xacc86464UL, 0xe7ba5d5dUL, 0x2b321919UL, 0x95e67373UL,+      0xa0c06060UL, 0x98198181UL, 0xd19e4f4fUL, 0x7fa3dcdcUL,+      0x66442222UL, 0x7e542a2aUL, 0xab3b9090UL, 0x830b8888UL,+      0xca8c4646UL, 0x29c7eeeeUL, 0xd36bb8b8UL, 0x3c281414UL,+      0x79a7dedeUL, 0xe2bc5e5eUL, 0x1d160b0bUL, 0x76addbdbUL,+      0x3bdbe0e0UL, 0x56643232UL, 0x4e743a3aUL, 0x1e140a0aUL,+      0xdb924949UL, 0x0a0c0606UL, 0x6c482424UL, 0xe4b85c5cUL,+      0x5d9fc2c2UL, 0x6ebdd3d3UL, 0xef43acacUL, 0xa6c46262UL,+      0xa8399191UL, 0xa4319595UL, 0x37d3e4e4UL, 0x8bf27979UL,+      0x32d5e7e7UL, 0x438bc8c8UL, 0x596e3737UL, 0xb7da6d6dUL,+      0x8c018d8dUL, 0x64b1d5d5UL, 0xd29c4e4eUL, 0xe049a9a9UL,+      0xb4d86c6cUL, 0xfaac5656UL, 0x07f3f4f4UL, 0x25cfeaeaUL,+      0xafca6565UL, 0x8ef47a7aUL, 0xe947aeaeUL, 0x18100808UL,+      0xd56fbabaUL, 0x88f07878UL, 0x6f4a2525UL, 0x725c2e2eUL,+      0x24381c1cUL, 0xf157a6a6UL, 0xc773b4b4UL, 0x5197c6c6UL,+      0x23cbe8e8UL, 0x7ca1ddddUL, 0x9ce87474UL, 0x213e1f1fUL,+      0xdd964b4bUL, 0xdc61bdbdUL, 0x860d8b8bUL, 0x850f8a8aUL,+      0x90e07070UL, 0x427c3e3eUL, 0xc471b5b5UL, 0xaacc6666UL,+      0xd8904848UL, 0x05060303UL, 0x01f7f6f6UL, 0x121c0e0eUL,+      0xa3c26161UL, 0x5f6a3535UL, 0xf9ae5757UL, 0xd069b9b9UL,+      0x91178686UL, 0x5899c1c1UL, 0x273a1d1dUL, 0xb9279e9eUL,+      0x38d9e1e1UL, 0x13ebf8f8UL, 0xb32b9898UL, 0x33221111UL,+      0xbbd26969UL, 0x70a9d9d9UL, 0x89078e8eUL, 0xa7339494UL,+      0xb62d9b9bUL, 0x223c1e1eUL, 0x92158787UL, 0x20c9e9e9UL,+      0x4987ceceUL, 0xffaa5555UL, 0x78502828UL, 0x7aa5dfdfUL,+      0x8f038c8cUL, 0xf859a1a1UL, 0x80098989UL, 0x171a0d0dUL,+      0xda65bfbfUL, 0x31d7e6e6UL, 0xc6844242UL, 0xb8d06868UL,+      0xc3824141UL, 0xb0299999UL, 0x775a2d2dUL, 0x111e0f0fUL,+      0xcb7bb0b0UL, 0xfca85454UL, 0xd66dbbbbUL, 0x3a2c1616UL+  };+  static const SWord32 table3[] = {+      0x63a5c663UL, 0x7c84f87cUL, 0x7799ee77UL, 0x7b8df67bUL,+      0xf20dfff2UL, 0x6bbdd66bUL, 0x6fb1de6fUL, 0xc55491c5UL,+      0x30506030UL, 0x01030201UL, 0x67a9ce67UL, 0x2b7d562bUL,+      0xfe19e7feUL, 0xd762b5d7UL, 0xabe64dabUL, 0x769aec76UL,+      0xca458fcaUL, 0x829d1f82UL, 0xc94089c9UL, 0x7d87fa7dUL,+      0xfa15effaUL, 0x59ebb259UL, 0x47c98e47UL, 0xf00bfbf0UL,+      0xadec41adUL, 0xd467b3d4UL, 0xa2fd5fa2UL, 0xafea45afUL,+      0x9cbf239cUL, 0xa4f753a4UL, 0x7296e472UL, 0xc05b9bc0UL,+      0xb7c275b7UL, 0xfd1ce1fdUL, 0x93ae3d93UL, 0x266a4c26UL,+      0x365a6c36UL, 0x3f417e3fUL, 0xf702f5f7UL, 0xcc4f83ccUL,+      0x345c6834UL, 0xa5f451a5UL, 0xe534d1e5UL, 0xf108f9f1UL,+      0x7193e271UL, 0xd873abd8UL, 0x31536231UL, 0x153f2a15UL,+      0x040c0804UL, 0xc75295c7UL, 0x23654623UL, 0xc35e9dc3UL,+      0x18283018UL, 0x96a13796UL, 0x050f0a05UL, 0x9ab52f9aUL,+      0x07090e07UL, 0x12362412UL, 0x809b1b80UL, 0xe23ddfe2UL,+      0xeb26cdebUL, 0x27694e27UL, 0xb2cd7fb2UL, 0x759fea75UL,+      0x091b1209UL, 0x839e1d83UL, 0x2c74582cUL, 0x1a2e341aUL,+      0x1b2d361bUL, 0x6eb2dc6eUL, 0x5aeeb45aUL, 0xa0fb5ba0UL,+      0x52f6a452UL, 0x3b4d763bUL, 0xd661b7d6UL, 0xb3ce7db3UL,+      0x297b5229UL, 0xe33edde3UL, 0x2f715e2fUL, 0x84971384UL,+      0x53f5a653UL, 0xd168b9d1UL, 0x00000000UL, 0xed2cc1edUL,+      0x20604020UL, 0xfc1fe3fcUL, 0xb1c879b1UL, 0x5bedb65bUL,+      0x6abed46aUL, 0xcb468dcbUL, 0xbed967beUL, 0x394b7239UL,+      0x4ade944aUL, 0x4cd4984cUL, 0x58e8b058UL, 0xcf4a85cfUL,+      0xd06bbbd0UL, 0xef2ac5efUL, 0xaae54faaUL, 0xfb16edfbUL,+      0x43c58643UL, 0x4dd79a4dUL, 0x33556633UL, 0x85941185UL,+      0x45cf8a45UL, 0xf910e9f9UL, 0x02060402UL, 0x7f81fe7fUL,+      0x50f0a050UL, 0x3c44783cUL, 0x9fba259fUL, 0xa8e34ba8UL,+      0x51f3a251UL, 0xa3fe5da3UL, 0x40c08040UL, 0x8f8a058fUL,+      0x92ad3f92UL, 0x9dbc219dUL, 0x38487038UL, 0xf504f1f5UL,+      0xbcdf63bcUL, 0xb6c177b6UL, 0xda75afdaUL, 0x21634221UL,+      0x10302010UL, 0xff1ae5ffUL, 0xf30efdf3UL, 0xd26dbfd2UL,+      0xcd4c81cdUL, 0x0c14180cUL, 0x13352613UL, 0xec2fc3ecUL,+      0x5fe1be5fUL, 0x97a23597UL, 0x44cc8844UL, 0x17392e17UL,+      0xc45793c4UL, 0xa7f255a7UL, 0x7e82fc7eUL, 0x3d477a3dUL,+      0x64acc864UL, 0x5de7ba5dUL, 0x192b3219UL, 0x7395e673UL,+      0x60a0c060UL, 0x81981981UL, 0x4fd19e4fUL, 0xdc7fa3dcUL,+      0x22664422UL, 0x2a7e542aUL, 0x90ab3b90UL, 0x88830b88UL,+      0x46ca8c46UL, 0xee29c7eeUL, 0xb8d36bb8UL, 0x143c2814UL,+      0xde79a7deUL, 0x5ee2bc5eUL, 0x0b1d160bUL, 0xdb76addbUL,+      0xe03bdbe0UL, 0x32566432UL, 0x3a4e743aUL, 0x0a1e140aUL,+      0x49db9249UL, 0x060a0c06UL, 0x246c4824UL, 0x5ce4b85cUL,+      0xc25d9fc2UL, 0xd36ebdd3UL, 0xacef43acUL, 0x62a6c462UL,+      0x91a83991UL, 0x95a43195UL, 0xe437d3e4UL, 0x798bf279UL,+      0xe732d5e7UL, 0xc8438bc8UL, 0x37596e37UL, 0x6db7da6dUL,+      0x8d8c018dUL, 0xd564b1d5UL, 0x4ed29c4eUL, 0xa9e049a9UL,+      0x6cb4d86cUL, 0x56faac56UL, 0xf407f3f4UL, 0xea25cfeaUL,+      0x65afca65UL, 0x7a8ef47aUL, 0xaee947aeUL, 0x08181008UL,+      0xbad56fbaUL, 0x7888f078UL, 0x256f4a25UL, 0x2e725c2eUL,+      0x1c24381cUL, 0xa6f157a6UL, 0xb4c773b4UL, 0xc65197c6UL,+      0xe823cbe8UL, 0xdd7ca1ddUL, 0x749ce874UL, 0x1f213e1fUL,+      0x4bdd964bUL, 0xbddc61bdUL, 0x8b860d8bUL, 0x8a850f8aUL,+      0x7090e070UL, 0x3e427c3eUL, 0xb5c471b5UL, 0x66aacc66UL,+      0x48d89048UL, 0x03050603UL, 0xf601f7f6UL, 0x0e121c0eUL,+      0x61a3c261UL, 0x355f6a35UL, 0x57f9ae57UL, 0xb9d069b9UL,+      0x86911786UL, 0xc15899c1UL, 0x1d273a1dUL, 0x9eb9279eUL,+      0xe138d9e1UL, 0xf813ebf8UL, 0x98b32b98UL, 0x11332211UL,+      0x69bbd269UL, 0xd970a9d9UL, 0x8e89078eUL, 0x94a73394UL,+      0x9bb62d9bUL, 0x1e223c1eUL, 0x87921587UL, 0xe920c9e9UL,+      0xce4987ceUL, 0x55ffaa55UL, 0x28785028UL, 0xdf7aa5dfUL,+      0x8c8f038cUL, 0xa1f859a1UL, 0x89800989UL, 0x0d171a0dUL,+      0xbfda65bfUL, 0xe631d7e6UL, 0x42c68442UL, 0x68b8d068UL,+      0x41c38241UL, 0x99b02999UL, 0x2d775a2dUL, 0x0f111e0fUL,+      0xb0cb7bb0UL, 0x54fca854UL, 0xbbd66dbbUL, 0x163a2c16UL+  };+  static const SWord32 table4[] = {+      0x6363a5c6UL, 0x7c7c84f8UL, 0x777799eeUL, 0x7b7b8df6UL,+      0xf2f20dffUL, 0x6b6bbdd6UL, 0x6f6fb1deUL, 0xc5c55491UL,+      0x30305060UL, 0x01010302UL, 0x6767a9ceUL, 0x2b2b7d56UL,+      0xfefe19e7UL, 0xd7d762b5UL, 0xababe64dUL, 0x76769aecUL,+      0xcaca458fUL, 0x82829d1fUL, 0xc9c94089UL, 0x7d7d87faUL,+      0xfafa15efUL, 0x5959ebb2UL, 0x4747c98eUL, 0xf0f00bfbUL,+      0xadadec41UL, 0xd4d467b3UL, 0xa2a2fd5fUL, 0xafafea45UL,+      0x9c9cbf23UL, 0xa4a4f753UL, 0x727296e4UL, 0xc0c05b9bUL,+      0xb7b7c275UL, 0xfdfd1ce1UL, 0x9393ae3dUL, 0x26266a4cUL,+      0x36365a6cUL, 0x3f3f417eUL, 0xf7f702f5UL, 0xcccc4f83UL,+      0x34345c68UL, 0xa5a5f451UL, 0xe5e534d1UL, 0xf1f108f9UL,+      0x717193e2UL, 0xd8d873abUL, 0x31315362UL, 0x15153f2aUL,+      0x04040c08UL, 0xc7c75295UL, 0x23236546UL, 0xc3c35e9dUL,+      0x18182830UL, 0x9696a137UL, 0x05050f0aUL, 0x9a9ab52fUL,+      0x0707090eUL, 0x12123624UL, 0x80809b1bUL, 0xe2e23ddfUL,+      0xebeb26cdUL, 0x2727694eUL, 0xb2b2cd7fUL, 0x75759feaUL,+      0x09091b12UL, 0x83839e1dUL, 0x2c2c7458UL, 0x1a1a2e34UL,+      0x1b1b2d36UL, 0x6e6eb2dcUL, 0x5a5aeeb4UL, 0xa0a0fb5bUL,+      0x5252f6a4UL, 0x3b3b4d76UL, 0xd6d661b7UL, 0xb3b3ce7dUL,+      0x29297b52UL, 0xe3e33eddUL, 0x2f2f715eUL, 0x84849713UL,+      0x5353f5a6UL, 0xd1d168b9UL, 0x00000000UL, 0xeded2cc1UL,+      0x20206040UL, 0xfcfc1fe3UL, 0xb1b1c879UL, 0x5b5bedb6UL,+      0x6a6abed4UL, 0xcbcb468dUL, 0xbebed967UL, 0x39394b72UL,+      0x4a4ade94UL, 0x4c4cd498UL, 0x5858e8b0UL, 0xcfcf4a85UL,+      0xd0d06bbbUL, 0xefef2ac5UL, 0xaaaae54fUL, 0xfbfb16edUL,+      0x4343c586UL, 0x4d4dd79aUL, 0x33335566UL, 0x85859411UL,+      0x4545cf8aUL, 0xf9f910e9UL, 0x02020604UL, 0x7f7f81feUL,+      0x5050f0a0UL, 0x3c3c4478UL, 0x9f9fba25UL, 0xa8a8e34bUL,+      0x5151f3a2UL, 0xa3a3fe5dUL, 0x4040c080UL, 0x8f8f8a05UL,+      0x9292ad3fUL, 0x9d9dbc21UL, 0x38384870UL, 0xf5f504f1UL,+      0xbcbcdf63UL, 0xb6b6c177UL, 0xdada75afUL, 0x21216342UL,+      0x10103020UL, 0xffff1ae5UL, 0xf3f30efdUL, 0xd2d26dbfUL,+      0xcdcd4c81UL, 0x0c0c1418UL, 0x13133526UL, 0xecec2fc3UL,+      0x5f5fe1beUL, 0x9797a235UL, 0x4444cc88UL, 0x1717392eUL,+      0xc4c45793UL, 0xa7a7f255UL, 0x7e7e82fcUL, 0x3d3d477aUL,+      0x6464acc8UL, 0x5d5de7baUL, 0x19192b32UL, 0x737395e6UL,+      0x6060a0c0UL, 0x81819819UL, 0x4f4fd19eUL, 0xdcdc7fa3UL,+      0x22226644UL, 0x2a2a7e54UL, 0x9090ab3bUL, 0x8888830bUL,+      0x4646ca8cUL, 0xeeee29c7UL, 0xb8b8d36bUL, 0x14143c28UL,+      0xdede79a7UL, 0x5e5ee2bcUL, 0x0b0b1d16UL, 0xdbdb76adUL,+      0xe0e03bdbUL, 0x32325664UL, 0x3a3a4e74UL, 0x0a0a1e14UL,+      0x4949db92UL, 0x06060a0cUL, 0x24246c48UL, 0x5c5ce4b8UL,+      0xc2c25d9fUL, 0xd3d36ebdUL, 0xacacef43UL, 0x6262a6c4UL,+      0x9191a839UL, 0x9595a431UL, 0xe4e437d3UL, 0x79798bf2UL,+      0xe7e732d5UL, 0xc8c8438bUL, 0x3737596eUL, 0x6d6db7daUL,+      0x8d8d8c01UL, 0xd5d564b1UL, 0x4e4ed29cUL, 0xa9a9e049UL,+      0x6c6cb4d8UL, 0x5656faacUL, 0xf4f407f3UL, 0xeaea25cfUL,+      0x6565afcaUL, 0x7a7a8ef4UL, 0xaeaee947UL, 0x08081810UL,+      0xbabad56fUL, 0x787888f0UL, 0x25256f4aUL, 0x2e2e725cUL,+      0x1c1c2438UL, 0xa6a6f157UL, 0xb4b4c773UL, 0xc6c65197UL,+      0xe8e823cbUL, 0xdddd7ca1UL, 0x74749ce8UL, 0x1f1f213eUL,+      0x4b4bdd96UL, 0xbdbddc61UL, 0x8b8b860dUL, 0x8a8a850fUL,+      0x707090e0UL, 0x3e3e427cUL, 0xb5b5c471UL, 0x6666aaccUL,+      0x4848d890UL, 0x03030506UL, 0xf6f601f7UL, 0x0e0e121cUL,+      0x6161a3c2UL, 0x35355f6aUL, 0x5757f9aeUL, 0xb9b9d069UL,+      0x86869117UL, 0xc1c15899UL, 0x1d1d273aUL, 0x9e9eb927UL,+      0xe1e138d9UL, 0xf8f813ebUL, 0x9898b32bUL, 0x11113322UL,+      0x6969bbd2UL, 0xd9d970a9UL, 0x8e8e8907UL, 0x9494a733UL,+      0x9b9bb62dUL, 0x1e1e223cUL, 0x87879215UL, 0xe9e920c9UL,+      0xcece4987UL, 0x5555ffaaUL, 0x28287850UL, 0xdfdf7aa5UL,+      0x8c8c8f03UL, 0xa1a1f859UL, 0x89898009UL, 0x0d0d171aUL,+      0xbfbfda65UL, 0xe6e631d7UL, 0x4242c684UL, 0x6868b8d0UL,+      0x4141c382UL, 0x9999b029UL, 0x2d2d775aUL, 0x0f0f111eUL,+      0xb0b0cb7bUL, 0x5454fca8UL, 0xbbbbd66dUL, 0x16163a2cUL+  };+  const SWord32 s560 = s0 ^ s4;+  const SWord16 s561 = (SWord16) (s560 >> 16);+  const SWord8  s562 = (SWord8) (s561 >> 8);+  const SWord32 s563 = table1[s562];+  const SWord32 s819 = s1 ^ s5;+  const SWord16 s820 = (SWord16) (s819 >> 16);+  const SWord8  s821 = (SWord8) s820;+  const SWord32 s822 = table2[s821];+  const SWord32 s823 = s563 ^ s822;+  const SWord32 s1079 = s2 ^ s6;+  const SWord16 s1080 = (SWord16) s1079;+  const SWord8  s1081 = (SWord8) (s1080 >> 8);+  const SWord32 s1082 = table3[s1081];+  const SWord32 s1083 = s823 ^ s1082;+  const SWord32 s1339 = s3 ^ s7;+  const SWord16 s1340 = (SWord16) s1339;+  const SWord8  s1341 = (SWord8) s1340;+  const SWord32 s1342 = table4[s1341];+  const SWord32 s1343 = s1083 ^ s1342;+  const SWord32 s1344 = s8 ^ s1343;+  const SWord16 s1345 = (SWord16) (s1344 >> 16);+  const SWord8  s1346 = (SWord8) (s1345 >> 8);+  const SWord32 s1347 = table1[s1346];+  const SWord8  s1348 = (SWord8) (s820 >> 8);+  const SWord32 s1349 = table1[s1348];+  const SWord16 s1350 = (SWord16) (s1079 >> 16);+  const SWord8  s1351 = (SWord8) s1350;+  const SWord32 s1352 = table2[s1351];+  const SWord32 s1353 = s1349 ^ s1352;+  const SWord8  s1354 = (SWord8) (s1340 >> 8);+  const SWord32 s1355 = table3[s1354];+  const SWord32 s1356 = s1353 ^ s1355;+  const SWord16 s1357 = (SWord16) s560;+  const SWord8  s1358 = (SWord8) s1357;+  const SWord32 s1359 = table4[s1358];+  const SWord32 s1360 = s1356 ^ s1359;+  const SWord32 s1361 = s9 ^ s1360;+  const SWord16 s1362 = (SWord16) (s1361 >> 16);+  const SWord8  s1363 = (SWord8) s1362;+  const SWord32 s1364 = table2[s1363];+  const SWord32 s1365 = s1347 ^ s1364;+  const SWord8  s1366 = (SWord8) (s1350 >> 8);+  const SWord32 s1367 = table1[s1366];+  const SWord16 s1368 = (SWord16) (s1339 >> 16);+  const SWord8  s1369 = (SWord8) s1368;+  const SWord32 s1370 = table2[s1369];+  const SWord32 s1371 = s1367 ^ s1370;+  const SWord8  s1372 = (SWord8) (s1357 >> 8);+  const SWord32 s1373 = table3[s1372];+  const SWord32 s1374 = s1371 ^ s1373;+  const SWord16 s1375 = (SWord16) s819;+  const SWord8  s1376 = (SWord8) s1375;+  const SWord32 s1377 = table4[s1376];+  const SWord32 s1378 = s1374 ^ s1377;+  const SWord32 s1379 = s10 ^ s1378;+  const SWord16 s1380 = (SWord16) s1379;+  const SWord8  s1381 = (SWord8) (s1380 >> 8);+  const SWord32 s1382 = table3[s1381];+  const SWord32 s1383 = s1365 ^ s1382;+  const SWord8  s1384 = (SWord8) (s1368 >> 8);+  const SWord32 s1385 = table1[s1384];+  const SWord8  s1386 = (SWord8) s561;+  const SWord32 s1387 = table2[s1386];+  const SWord32 s1388 = s1385 ^ s1387;+  const SWord8  s1389 = (SWord8) (s1375 >> 8);+  const SWord32 s1390 = table3[s1389];+  const SWord32 s1391 = s1388 ^ s1390;+  const SWord8  s1392 = (SWord8) s1080;+  const SWord32 s1393 = table4[s1392];+  const SWord32 s1394 = s1391 ^ s1393;+  const SWord32 s1395 = s11 ^ s1394;+  const SWord16 s1396 = (SWord16) s1395;+  const SWord8  s1397 = (SWord8) s1396;+  const SWord32 s1398 = table4[s1397];+  const SWord32 s1399 = s1383 ^ s1398;+  const SWord32 s1400 = s12 ^ s1399;+  const SWord16 s1401 = (SWord16) (s1400 >> 16);+  const SWord8  s1402 = (SWord8) (s1401 >> 8);+  const SWord32 s1403 = table1[s1402];+  const SWord8  s1404 = (SWord8) (s1362 >> 8);+  const SWord32 s1405 = table1[s1404];+  const SWord16 s1406 = (SWord16) (s1379 >> 16);+  const SWord8  s1407 = (SWord8) s1406;+  const SWord32 s1408 = table2[s1407];+  const SWord32 s1409 = s1405 ^ s1408;+  const SWord8  s1410 = (SWord8) (s1396 >> 8);+  const SWord32 s1411 = table3[s1410];+  const SWord32 s1412 = s1409 ^ s1411;+  const SWord16 s1413 = (SWord16) s1344;+  const SWord8  s1414 = (SWord8) s1413;+  const SWord32 s1415 = table4[s1414];+  const SWord32 s1416 = s1412 ^ s1415;+  const SWord32 s1417 = s13 ^ s1416;+  const SWord16 s1418 = (SWord16) (s1417 >> 16);+  const SWord8  s1419 = (SWord8) s1418;+  const SWord32 s1420 = table2[s1419];+  const SWord32 s1421 = s1403 ^ s1420;+  const SWord8  s1422 = (SWord8) (s1406 >> 8);+  const SWord32 s1423 = table1[s1422];+  const SWord16 s1424 = (SWord16) (s1395 >> 16);+  const SWord8  s1425 = (SWord8) s1424;+  const SWord32 s1426 = table2[s1425];+  const SWord32 s1427 = s1423 ^ s1426;+  const SWord8  s1428 = (SWord8) (s1413 >> 8);+  const SWord32 s1429 = table3[s1428];+  const SWord32 s1430 = s1427 ^ s1429;+  const SWord16 s1431 = (SWord16) s1361;+  const SWord8  s1432 = (SWord8) s1431;+  const SWord32 s1433 = table4[s1432];+  const SWord32 s1434 = s1430 ^ s1433;+  const SWord32 s1435 = s14 ^ s1434;+  const SWord16 s1436 = (SWord16) s1435;+  const SWord8  s1437 = (SWord8) (s1436 >> 8);+  const SWord32 s1438 = table3[s1437];+  const SWord32 s1439 = s1421 ^ s1438;+  const SWord8  s1440 = (SWord8) (s1424 >> 8);+  const SWord32 s1441 = table1[s1440];+  const SWord8  s1442 = (SWord8) s1345;+  const SWord32 s1443 = table2[s1442];+  const SWord32 s1444 = s1441 ^ s1443;+  const SWord8  s1445 = (SWord8) (s1431 >> 8);+  const SWord32 s1446 = table3[s1445];+  const SWord32 s1447 = s1444 ^ s1446;+  const SWord8  s1448 = (SWord8) s1380;+  const SWord32 s1449 = table4[s1448];+  const SWord32 s1450 = s1447 ^ s1449;+  const SWord32 s1451 = s15 ^ s1450;+  const SWord16 s1452 = (SWord16) s1451;+  const SWord8  s1453 = (SWord8) s1452;+  const SWord32 s1454 = table4[s1453];+  const SWord32 s1455 = s1439 ^ s1454;+  const SWord32 s1456 = s16 ^ s1455;+  const SWord16 s1457 = (SWord16) (s1456 >> 16);+  const SWord8  s1458 = (SWord8) (s1457 >> 8);+  const SWord32 s1459 = table1[s1458];+  const SWord8  s1460 = (SWord8) (s1418 >> 8);+  const SWord32 s1461 = table1[s1460];+  const SWord16 s1462 = (SWord16) (s1435 >> 16);+  const SWord8  s1463 = (SWord8) s1462;+  const SWord32 s1464 = table2[s1463];+  const SWord32 s1465 = s1461 ^ s1464;+  const SWord8  s1466 = (SWord8) (s1452 >> 8);+  const SWord32 s1467 = table3[s1466];+  const SWord32 s1468 = s1465 ^ s1467;+  const SWord16 s1469 = (SWord16) s1400;+  const SWord8  s1470 = (SWord8) s1469;+  const SWord32 s1471 = table4[s1470];+  const SWord32 s1472 = s1468 ^ s1471;+  const SWord32 s1473 = s17 ^ s1472;+  const SWord16 s1474 = (SWord16) (s1473 >> 16);+  const SWord8  s1475 = (SWord8) s1474;+  const SWord32 s1476 = table2[s1475];+  const SWord32 s1477 = s1459 ^ s1476;+  const SWord8  s1478 = (SWord8) (s1462 >> 8);+  const SWord32 s1479 = table1[s1478];+  const SWord16 s1480 = (SWord16) (s1451 >> 16);+  const SWord8  s1481 = (SWord8) s1480;+  const SWord32 s1482 = table2[s1481];+  const SWord32 s1483 = s1479 ^ s1482;+  const SWord8  s1484 = (SWord8) (s1469 >> 8);+  const SWord32 s1485 = table3[s1484];+  const SWord32 s1486 = s1483 ^ s1485;+  const SWord16 s1487 = (SWord16) s1417;+  const SWord8  s1488 = (SWord8) s1487;+  const SWord32 s1489 = table4[s1488];+  const SWord32 s1490 = s1486 ^ s1489;+  const SWord32 s1491 = s18 ^ s1490;+  const SWord16 s1492 = (SWord16) s1491;+  const SWord8  s1493 = (SWord8) (s1492 >> 8);+  const SWord32 s1494 = table3[s1493];+  const SWord32 s1495 = s1477 ^ s1494;+  const SWord8  s1496 = (SWord8) (s1480 >> 8);+  const SWord32 s1497 = table1[s1496];+  const SWord8  s1498 = (SWord8) s1401;+  const SWord32 s1499 = table2[s1498];+  const SWord32 s1500 = s1497 ^ s1499;+  const SWord8  s1501 = (SWord8) (s1487 >> 8);+  const SWord32 s1502 = table3[s1501];+  const SWord32 s1503 = s1500 ^ s1502;+  const SWord8  s1504 = (SWord8) s1436;+  const SWord32 s1505 = table4[s1504];+  const SWord32 s1506 = s1503 ^ s1505;+  const SWord32 s1507 = s19 ^ s1506;+  const SWord16 s1508 = (SWord16) s1507;+  const SWord8  s1509 = (SWord8) s1508;+  const SWord32 s1510 = table4[s1509];+  const SWord32 s1511 = s1495 ^ s1510;+  const SWord32 s1512 = s20 ^ s1511;+  const SWord16 s1513 = (SWord16) (s1512 >> 16);+  const SWord8  s1514 = (SWord8) (s1513 >> 8);+  const SWord32 s1515 = table1[s1514];+  const SWord8  s1516 = (SWord8) (s1474 >> 8);+  const SWord32 s1517 = table1[s1516];+  const SWord16 s1518 = (SWord16) (s1491 >> 16);+  const SWord8  s1519 = (SWord8) s1518;+  const SWord32 s1520 = table2[s1519];+  const SWord32 s1521 = s1517 ^ s1520;+  const SWord8  s1522 = (SWord8) (s1508 >> 8);+  const SWord32 s1523 = table3[s1522];+  const SWord32 s1524 = s1521 ^ s1523;+  const SWord16 s1525 = (SWord16) s1456;+  const SWord8  s1526 = (SWord8) s1525;+  const SWord32 s1527 = table4[s1526];+  const SWord32 s1528 = s1524 ^ s1527;+  const SWord32 s1529 = s21 ^ s1528;+  const SWord16 s1530 = (SWord16) (s1529 >> 16);+  const SWord8  s1531 = (SWord8) s1530;+  const SWord32 s1532 = table2[s1531];+  const SWord32 s1533 = s1515 ^ s1532;+  const SWord8  s1534 = (SWord8) (s1518 >> 8);+  const SWord32 s1535 = table1[s1534];+  const SWord16 s1536 = (SWord16) (s1507 >> 16);+  const SWord8  s1537 = (SWord8) s1536;+  const SWord32 s1538 = table2[s1537];+  const SWord32 s1539 = s1535 ^ s1538;+  const SWord8  s1540 = (SWord8) (s1525 >> 8);+  const SWord32 s1541 = table3[s1540];+  const SWord32 s1542 = s1539 ^ s1541;+  const SWord16 s1543 = (SWord16) s1473;+  const SWord8  s1544 = (SWord8) s1543;+  const SWord32 s1545 = table4[s1544];+  const SWord32 s1546 = s1542 ^ s1545;+  const SWord32 s1547 = s22 ^ s1546;+  const SWord16 s1548 = (SWord16) s1547;+  const SWord8  s1549 = (SWord8) (s1548 >> 8);+  const SWord32 s1550 = table3[s1549];+  const SWord32 s1551 = s1533 ^ s1550;+  const SWord8  s1552 = (SWord8) (s1536 >> 8);+  const SWord32 s1553 = table1[s1552];+  const SWord8  s1554 = (SWord8) s1457;+  const SWord32 s1555 = table2[s1554];+  const SWord32 s1556 = s1553 ^ s1555;+  const SWord8  s1557 = (SWord8) (s1543 >> 8);+  const SWord32 s1558 = table3[s1557];+  const SWord32 s1559 = s1556 ^ s1558;+  const SWord8  s1560 = (SWord8) s1492;+  const SWord32 s1561 = table4[s1560];+  const SWord32 s1562 = s1559 ^ s1561;+  const SWord32 s1563 = s23 ^ s1562;+  const SWord16 s1564 = (SWord16) s1563;+  const SWord8  s1565 = (SWord8) s1564;+  const SWord32 s1566 = table4[s1565];+  const SWord32 s1567 = s1551 ^ s1566;+  const SWord32 s1568 = s24 ^ s1567;+  const SWord16 s1569 = (SWord16) (s1568 >> 16);+  const SWord8  s1570 = (SWord8) (s1569 >> 8);+  const SWord32 s1571 = table1[s1570];+  const SWord8  s1572 = (SWord8) (s1530 >> 8);+  const SWord32 s1573 = table1[s1572];+  const SWord16 s1574 = (SWord16) (s1547 >> 16);+  const SWord8  s1575 = (SWord8) s1574;+  const SWord32 s1576 = table2[s1575];+  const SWord32 s1577 = s1573 ^ s1576;+  const SWord8  s1578 = (SWord8) (s1564 >> 8);+  const SWord32 s1579 = table3[s1578];+  const SWord32 s1580 = s1577 ^ s1579;+  const SWord16 s1581 = (SWord16) s1512;+  const SWord8  s1582 = (SWord8) s1581;+  const SWord32 s1583 = table4[s1582];+  const SWord32 s1584 = s1580 ^ s1583;+  const SWord32 s1585 = s25 ^ s1584;+  const SWord16 s1586 = (SWord16) (s1585 >> 16);+  const SWord8  s1587 = (SWord8) s1586;+  const SWord32 s1588 = table2[s1587];+  const SWord32 s1589 = s1571 ^ s1588;+  const SWord8  s1590 = (SWord8) (s1574 >> 8);+  const SWord32 s1591 = table1[s1590];+  const SWord16 s1592 = (SWord16) (s1563 >> 16);+  const SWord8  s1593 = (SWord8) s1592;+  const SWord32 s1594 = table2[s1593];+  const SWord32 s1595 = s1591 ^ s1594;+  const SWord8  s1596 = (SWord8) (s1581 >> 8);+  const SWord32 s1597 = table3[s1596];+  const SWord32 s1598 = s1595 ^ s1597;+  const SWord16 s1599 = (SWord16) s1529;+  const SWord8  s1600 = (SWord8) s1599;+  const SWord32 s1601 = table4[s1600];+  const SWord32 s1602 = s1598 ^ s1601;+  const SWord32 s1603 = s26 ^ s1602;+  const SWord16 s1604 = (SWord16) s1603;+  const SWord8  s1605 = (SWord8) (s1604 >> 8);+  const SWord32 s1606 = table3[s1605];+  const SWord32 s1607 = s1589 ^ s1606;+  const SWord8  s1608 = (SWord8) (s1592 >> 8);+  const SWord32 s1609 = table1[s1608];+  const SWord8  s1610 = (SWord8) s1513;+  const SWord32 s1611 = table2[s1610];+  const SWord32 s1612 = s1609 ^ s1611;+  const SWord8  s1613 = (SWord8) (s1599 >> 8);+  const SWord32 s1614 = table3[s1613];+  const SWord32 s1615 = s1612 ^ s1614;+  const SWord8  s1616 = (SWord8) s1548;+  const SWord32 s1617 = table4[s1616];+  const SWord32 s1618 = s1615 ^ s1617;+  const SWord32 s1619 = s27 ^ s1618;+  const SWord16 s1620 = (SWord16) s1619;+  const SWord8  s1621 = (SWord8) s1620;+  const SWord32 s1622 = table4[s1621];+  const SWord32 s1623 = s1607 ^ s1622;+  const SWord32 s1624 = s28 ^ s1623;+  const SWord16 s1625 = (SWord16) (s1624 >> 16);+  const SWord8  s1626 = (SWord8) (s1625 >> 8);+  const SWord32 s1627 = table1[s1626];+  const SWord8  s1628 = (SWord8) (s1586 >> 8);+  const SWord32 s1629 = table1[s1628];+  const SWord16 s1630 = (SWord16) (s1603 >> 16);+  const SWord8  s1631 = (SWord8) s1630;+  const SWord32 s1632 = table2[s1631];+  const SWord32 s1633 = s1629 ^ s1632;+  const SWord8  s1634 = (SWord8) (s1620 >> 8);+  const SWord32 s1635 = table3[s1634];+  const SWord32 s1636 = s1633 ^ s1635;+  const SWord16 s1637 = (SWord16) s1568;+  const SWord8  s1638 = (SWord8) s1637;+  const SWord32 s1639 = table4[s1638];+  const SWord32 s1640 = s1636 ^ s1639;+  const SWord32 s1641 = s29 ^ s1640;+  const SWord16 s1642 = (SWord16) (s1641 >> 16);+  const SWord8  s1643 = (SWord8) s1642;+  const SWord32 s1644 = table2[s1643];+  const SWord32 s1645 = s1627 ^ s1644;+  const SWord8  s1646 = (SWord8) (s1630 >> 8);+  const SWord32 s1647 = table1[s1646];+  const SWord16 s1648 = (SWord16) (s1619 >> 16);+  const SWord8  s1649 = (SWord8) s1648;+  const SWord32 s1650 = table2[s1649];+  const SWord32 s1651 = s1647 ^ s1650;+  const SWord8  s1652 = (SWord8) (s1637 >> 8);+  const SWord32 s1653 = table3[s1652];+  const SWord32 s1654 = s1651 ^ s1653;+  const SWord16 s1655 = (SWord16) s1585;+  const SWord8  s1656 = (SWord8) s1655;+  const SWord32 s1657 = table4[s1656];+  const SWord32 s1658 = s1654 ^ s1657;+  const SWord32 s1659 = s30 ^ s1658;+  const SWord16 s1660 = (SWord16) s1659;+  const SWord8  s1661 = (SWord8) (s1660 >> 8);+  const SWord32 s1662 = table3[s1661];+  const SWord32 s1663 = s1645 ^ s1662;+  const SWord8  s1664 = (SWord8) (s1648 >> 8);+  const SWord32 s1665 = table1[s1664];+  const SWord8  s1666 = (SWord8) s1569;+  const SWord32 s1667 = table2[s1666];+  const SWord32 s1668 = s1665 ^ s1667;+  const SWord8  s1669 = (SWord8) (s1655 >> 8);+  const SWord32 s1670 = table3[s1669];+  const SWord32 s1671 = s1668 ^ s1670;+  const SWord8  s1672 = (SWord8) s1604;+  const SWord32 s1673 = table4[s1672];+  const SWord32 s1674 = s1671 ^ s1673;+  const SWord32 s1675 = s31 ^ s1674;+  const SWord16 s1676 = (SWord16) s1675;+  const SWord8  s1677 = (SWord8) s1676;+  const SWord32 s1678 = table4[s1677];+  const SWord32 s1679 = s1663 ^ s1678;+  const SWord32 s1680 = s32 ^ s1679;+  const SWord16 s1681 = (SWord16) (s1680 >> 16);+  const SWord8  s1682 = (SWord8) (s1681 >> 8);+  const SWord32 s1683 = table1[s1682];+  const SWord8  s1684 = (SWord8) (s1642 >> 8);+  const SWord32 s1685 = table1[s1684];+  const SWord16 s1686 = (SWord16) (s1659 >> 16);+  const SWord8  s1687 = (SWord8) s1686;+  const SWord32 s1688 = table2[s1687];+  const SWord32 s1689 = s1685 ^ s1688;+  const SWord8  s1690 = (SWord8) (s1676 >> 8);+  const SWord32 s1691 = table3[s1690];+  const SWord32 s1692 = s1689 ^ s1691;+  const SWord16 s1693 = (SWord16) s1624;+  const SWord8  s1694 = (SWord8) s1693;+  const SWord32 s1695 = table4[s1694];+  const SWord32 s1696 = s1692 ^ s1695;+  const SWord32 s1697 = s33 ^ s1696;+  const SWord16 s1698 = (SWord16) (s1697 >> 16);+  const SWord8  s1699 = (SWord8) s1698;+  const SWord32 s1700 = table2[s1699];+  const SWord32 s1701 = s1683 ^ s1700;+  const SWord8  s1702 = (SWord8) (s1686 >> 8);+  const SWord32 s1703 = table1[s1702];+  const SWord16 s1704 = (SWord16) (s1675 >> 16);+  const SWord8  s1705 = (SWord8) s1704;+  const SWord32 s1706 = table2[s1705];+  const SWord32 s1707 = s1703 ^ s1706;+  const SWord8  s1708 = (SWord8) (s1693 >> 8);+  const SWord32 s1709 = table3[s1708];+  const SWord32 s1710 = s1707 ^ s1709;+  const SWord16 s1711 = (SWord16) s1641;+  const SWord8  s1712 = (SWord8) s1711;+  const SWord32 s1713 = table4[s1712];+  const SWord32 s1714 = s1710 ^ s1713;+  const SWord32 s1715 = s34 ^ s1714;+  const SWord16 s1716 = (SWord16) s1715;+  const SWord8  s1717 = (SWord8) (s1716 >> 8);+  const SWord32 s1718 = table3[s1717];+  const SWord32 s1719 = s1701 ^ s1718;+  const SWord8  s1720 = (SWord8) (s1704 >> 8);+  const SWord32 s1721 = table1[s1720];+  const SWord8  s1722 = (SWord8) s1625;+  const SWord32 s1723 = table2[s1722];+  const SWord32 s1724 = s1721 ^ s1723;+  const SWord8  s1725 = (SWord8) (s1711 >> 8);+  const SWord32 s1726 = table3[s1725];+  const SWord32 s1727 = s1724 ^ s1726;+  const SWord8  s1728 = (SWord8) s1660;+  const SWord32 s1729 = table4[s1728];+  const SWord32 s1730 = s1727 ^ s1729;+  const SWord32 s1731 = s35 ^ s1730;+  const SWord16 s1732 = (SWord16) s1731;+  const SWord8  s1733 = (SWord8) s1732;+  const SWord32 s1734 = table4[s1733];+  const SWord32 s1735 = s1719 ^ s1734;+  const SWord32 s1736 = s36 ^ s1735;+  const SWord16 s1737 = (SWord16) (s1736 >> 16);+  const SWord8  s1738 = (SWord8) (s1737 >> 8);+  const SWord32 s1739 = table1[s1738];+  const SWord8  s1740 = (SWord8) (s1698 >> 8);+  const SWord32 s1741 = table1[s1740];+  const SWord16 s1742 = (SWord16) (s1715 >> 16);+  const SWord8  s1743 = (SWord8) s1742;+  const SWord32 s1744 = table2[s1743];+  const SWord32 s1745 = s1741 ^ s1744;+  const SWord8  s1746 = (SWord8) (s1732 >> 8);+  const SWord32 s1747 = table3[s1746];+  const SWord32 s1748 = s1745 ^ s1747;+  const SWord16 s1749 = (SWord16) s1680;+  const SWord8  s1750 = (SWord8) s1749;+  const SWord32 s1751 = table4[s1750];+  const SWord32 s1752 = s1748 ^ s1751;+  const SWord32 s1753 = s37 ^ s1752;+  const SWord16 s1754 = (SWord16) (s1753 >> 16);+  const SWord8  s1755 = (SWord8) s1754;+  const SWord32 s1756 = table2[s1755];+  const SWord32 s1757 = s1739 ^ s1756;+  const SWord8  s1758 = (SWord8) (s1742 >> 8);+  const SWord32 s1759 = table1[s1758];+  const SWord16 s1760 = (SWord16) (s1731 >> 16);+  const SWord8  s1761 = (SWord8) s1760;+  const SWord32 s1762 = table2[s1761];+  const SWord32 s1763 = s1759 ^ s1762;+  const SWord8  s1764 = (SWord8) (s1749 >> 8);+  const SWord32 s1765 = table3[s1764];+  const SWord32 s1766 = s1763 ^ s1765;+  const SWord16 s1767 = (SWord16) s1697;+  const SWord8  s1768 = (SWord8) s1767;+  const SWord32 s1769 = table4[s1768];+  const SWord32 s1770 = s1766 ^ s1769;+  const SWord32 s1771 = s38 ^ s1770;+  const SWord16 s1772 = (SWord16) s1771;+  const SWord8  s1773 = (SWord8) (s1772 >> 8);+  const SWord32 s1774 = table3[s1773];+  const SWord32 s1775 = s1757 ^ s1774;+  const SWord8  s1776 = (SWord8) (s1760 >> 8);+  const SWord32 s1777 = table1[s1776];+  const SWord8  s1778 = (SWord8) s1681;+  const SWord32 s1779 = table2[s1778];+  const SWord32 s1780 = s1777 ^ s1779;+  const SWord8  s1781 = (SWord8) (s1767 >> 8);+  const SWord32 s1782 = table3[s1781];+  const SWord32 s1783 = s1780 ^ s1782;+  const SWord8  s1784 = (SWord8) s1716;+  const SWord32 s1785 = table4[s1784];+  const SWord32 s1786 = s1783 ^ s1785;+  const SWord32 s1787 = s39 ^ s1786;+  const SWord16 s1788 = (SWord16) s1787;+  const SWord8  s1789 = (SWord8) s1788;+  const SWord32 s1790 = table4[s1789];+  const SWord32 s1791 = s1775 ^ s1790;+  const SWord32 s1792 = s40 ^ s1791;+  const SWord16 s1793 = (SWord16) (s1792 >> 16);+  const SWord8  s1794 = (SWord8) (s1793 >> 8);+  const SWord8  s1795 = table0[s1794];+  const SWord8  s1796 = (SWord8) (s1754 >> 8);+  const SWord32 s1797 = table1[s1796];+  const SWord16 s1798 = (SWord16) (s1771 >> 16);+  const SWord8  s1799 = (SWord8) s1798;+  const SWord32 s1800 = table2[s1799];+  const SWord32 s1801 = s1797 ^ s1800;+  const SWord8  s1802 = (SWord8) (s1788 >> 8);+  const SWord32 s1803 = table3[s1802];+  const SWord32 s1804 = s1801 ^ s1803;+  const SWord16 s1805 = (SWord16) s1736;+  const SWord8  s1806 = (SWord8) s1805;+  const SWord32 s1807 = table4[s1806];+  const SWord32 s1808 = s1804 ^ s1807;+  const SWord32 s1809 = s41 ^ s1808;+  const SWord16 s1810 = (SWord16) (s1809 >> 16);+  const SWord8  s1811 = (SWord8) s1810;+  const SWord8  s1812 = table0[s1811];+  const SWord16 s1813 = (((SWord16) s1795) << 8) | ((SWord16) s1812);+  const SWord8  s1814 = (SWord8) (s1798 >> 8);+  const SWord32 s1815 = table1[s1814];+  const SWord16 s1816 = (SWord16) (s1787 >> 16);+  const SWord8  s1817 = (SWord8) s1816;+  const SWord32 s1818 = table2[s1817];+  const SWord32 s1819 = s1815 ^ s1818;+  const SWord8  s1820 = (SWord8) (s1805 >> 8);+  const SWord32 s1821 = table3[s1820];+  const SWord32 s1822 = s1819 ^ s1821;+  const SWord16 s1823 = (SWord16) s1753;+  const SWord8  s1824 = (SWord8) s1823;+  const SWord32 s1825 = table4[s1824];+  const SWord32 s1826 = s1822 ^ s1825;+  const SWord32 s1827 = s42 ^ s1826;+  const SWord16 s1828 = (SWord16) s1827;+  const SWord8  s1829 = (SWord8) (s1828 >> 8);+  const SWord8  s1830 = table0[s1829];+  const SWord8  s1831 = (SWord8) (s1816 >> 8);+  const SWord32 s1832 = table1[s1831];+  const SWord8  s1833 = (SWord8) s1737;+  const SWord32 s1834 = table2[s1833];+  const SWord32 s1835 = s1832 ^ s1834;+  const SWord8  s1836 = (SWord8) (s1823 >> 8);+  const SWord32 s1837 = table3[s1836];+  const SWord32 s1838 = s1835 ^ s1837;+  const SWord8  s1839 = (SWord8) s1772;+  const SWord32 s1840 = table4[s1839];+  const SWord32 s1841 = s1838 ^ s1840;+  const SWord32 s1842 = s43 ^ s1841;+  const SWord16 s1843 = (SWord16) s1842;+  const SWord8  s1844 = (SWord8) s1843;+  const SWord8  s1845 = table0[s1844];+  const SWord16 s1846 = (((SWord16) s1830) << 8) | ((SWord16) s1845);+  const SWord32 s1847 = (((SWord32) s1813) << 16) | ((SWord32) s1846);+  const SWord32 s1848 = s44 ^ s1847;+  const SWord8  s1849 = (SWord8) (s1810 >> 8);+  const SWord8  s1850 = table0[s1849];+  const SWord16 s1851 = (SWord16) (s1827 >> 16);+  const SWord8  s1852 = (SWord8) s1851;+  const SWord8  s1853 = table0[s1852];+  const SWord16 s1854 = (((SWord16) s1850) << 8) | ((SWord16) s1853);+  const SWord8  s1855 = (SWord8) (s1843 >> 8);+  const SWord8  s1856 = table0[s1855];+  const SWord16 s1857 = (SWord16) s1792;+  const SWord8  s1858 = (SWord8) s1857;+  const SWord8  s1859 = table0[s1858];+  const SWord16 s1860 = (((SWord16) s1856) << 8) | ((SWord16) s1859);+  const SWord32 s1861 = (((SWord32) s1854) << 16) | ((SWord32) s1860);+  const SWord32 s1862 = s45 ^ s1861;+  const SWord8  s1863 = (SWord8) (s1851 >> 8);+  const SWord8  s1864 = table0[s1863];+  const SWord16 s1865 = (SWord16) (s1842 >> 16);+  const SWord8  s1866 = (SWord8) s1865;+  const SWord8  s1867 = table0[s1866];+  const SWord16 s1868 = (((SWord16) s1864) << 8) | ((SWord16) s1867);+  const SWord8  s1869 = (SWord8) (s1857 >> 8);+  const SWord8  s1870 = table0[s1869];+  const SWord16 s1871 = (SWord16) s1809;+  const SWord8  s1872 = (SWord8) s1871;+  const SWord8  s1873 = table0[s1872];+  const SWord16 s1874 = (((SWord16) s1870) << 8) | ((SWord16) s1873);+  const SWord32 s1875 = (((SWord32) s1868) << 16) | ((SWord32) s1874);+  const SWord32 s1876 = s46 ^ s1875;+  const SWord8  s1877 = (SWord8) (s1865 >> 8);+  const SWord8  s1878 = table0[s1877];+  const SWord8  s1879 = (SWord8) s1793;+  const SWord8  s1880 = table0[s1879];+  const SWord16 s1881 = (((SWord16) s1878) << 8) | ((SWord16) s1880);+  const SWord8  s1882 = (SWord8) (s1871 >> 8);+  const SWord8  s1883 = table0[s1882];+  const SWord8  s1884 = (SWord8) s1828;+  const SWord8  s1885 = table0[s1884];+  const SWord16 s1886 = (((SWord16) s1883) << 8) | ((SWord16) s1885);+  const SWord32 s1887 = (((SWord32) s1881) << 16) | ((SWord32) s1886);+  const SWord32 s1888 = s47 ^ s1887;++  ct[0] = s1848;+  ct[1] = s1862;+  ct[2] = s1876;+  ct[3] = s1888;+}+== END: "aes128BlockEncrypt.c" ==================+== BEGIN: "aes128BlockDecrypt.c" ================+/* File: "aes128BlockDecrypt.c". Automatically generated by SBV. Do not edit! */++#include "aes128Lib.h"++void aes128BlockDecrypt(const SWord32 *ct, const SWord32 *xkey,+                        SWord32 *pt)+{+  const SWord32 s0 = ct[0];+  const SWord32 s1 = ct[1];+  const SWord32 s2 = ct[2];+  const SWord32 s3 = ct[3];+  const SWord32 s4 = xkey[0];+  const SWord32 s5 = xkey[1];+  const SWord32 s6 = xkey[2];+  const SWord32 s7 = xkey[3];+  const SWord32 s8 = xkey[4];+  const SWord32 s9 = xkey[5];+  const SWord32 s10 = xkey[6];+  const SWord32 s11 = xkey[7];+  const SWord32 s12 = xkey[8];+  const SWord32 s13 = xkey[9];+  const SWord32 s14 = xkey[10];+  const SWord32 s15 = xkey[11];+  const SWord32 s16 = xkey[12];+  const SWord32 s17 = xkey[13];+  const SWord32 s18 = xkey[14];+  const SWord32 s19 = xkey[15];+  const SWord32 s20 = xkey[16];+  const SWord32 s21 = xkey[17];+  const SWord32 s22 = xkey[18];+  const SWord32 s23 = xkey[19];+  const SWord32 s24 = xkey[20];+  const SWord32 s25 = xkey[21];+  const SWord32 s26 = xkey[22];+  const SWord32 s27 = xkey[23];+  const SWord32 s28 = xkey[24];+  const SWord32 s29 = xkey[25];+  const SWord32 s30 = xkey[26];+  const SWord32 s31 = xkey[27];+  const SWord32 s32 = xkey[28];+  const SWord32 s33 = xkey[29];+  const SWord32 s34 = xkey[30];+  const SWord32 s35 = xkey[31];+  const SWord32 s36 = xkey[32];+  const SWord32 s37 = xkey[33];+  const SWord32 s38 = xkey[34];+  const SWord32 s39 = xkey[35];+  const SWord32 s40 = xkey[36];+  const SWord32 s41 = xkey[37];+  const SWord32 s42 = xkey[38];+  const SWord32 s43 = xkey[39];+  const SWord32 s44 = xkey[40];+  const SWord32 s45 = xkey[41];+  const SWord32 s46 = xkey[42];+  const SWord32 s47 = xkey[43];+  static const SWord8 table0[] = {+       82,   9, 106, 213,  48,  54, 165,  56, 191,  64, 163, 158, 129,+      243, 215, 251, 124, 227,  57, 130, 155,  47, 255, 135,  52, 142,+       67,  68, 196, 222, 233, 203,  84, 123, 148,  50, 166, 194,  35,+       61, 238,  76, 149,  11,  66, 250, 195,  78,   8,  46, 161, 102,+       40, 217,  36, 178, 118,  91, 162,  73, 109, 139, 209,  37, 114,+      248, 246, 100, 134, 104, 152,  22, 212, 164,  92, 204,  93, 101,+      182, 146, 108, 112,  72,  80, 253, 237, 185, 218,  94,  21,  70,+       87, 167, 141, 157, 132, 144, 216, 171,   0, 140, 188, 211,  10,+      247, 228,  88,   5, 184, 179,  69,   6, 208,  44,  30, 143, 202,+       63,  15,   2, 193, 175, 189,   3,   1,  19, 138, 107,  58, 145,+       17,  65,  79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230,+      115, 150, 172, 116,  34, 231, 173,  53, 133, 226, 249,  55, 232,+       28, 117, 223, 110,  71, 241,  26, 113,  29,  41, 197, 137, 111,+      183,  98,  14, 170,  24, 190,  27, 252,  86,  62,  75, 198, 210,+      121,  32, 154, 219, 192, 254, 120, 205,  90, 244,  31, 221, 168,+       51, 136,   7, 199,  49, 177,  18,  16,  89,  39, 128, 236,  95,+       96,  81, 127, 169,  25, 181,  74,  13,  45, 229, 122, 159, 147,+      201, 156, 239, 160, 224,  59,  77, 174,  42, 245, 176, 200, 235,+      187,  60, 131,  83, 153,  97,  23,  43,   4, 126, 186, 119, 214,+       38, 225, 105,  20,  99,  85,  33,  12, 125+  };+  static const SWord32 table1[] = {+      0x51f4a750UL, 0x7e416553UL, 0x1a17a4c3UL, 0x3a275e96UL,+      0x3bab6bcbUL, 0x1f9d45f1UL, 0xacfa58abUL, 0x4be30393UL,+      0x2030fa55UL, 0xad766df6UL, 0x88cc7691UL, 0xf5024c25UL,+      0x4fe5d7fcUL, 0xc52acbd7UL, 0x26354480UL, 0xb562a38fUL,+      0xdeb15a49UL, 0x25ba1b67UL, 0x45ea0e98UL, 0x5dfec0e1UL,+      0xc32f7502UL, 0x814cf012UL, 0x8d4697a3UL, 0x6bd3f9c6UL,+      0x038f5fe7UL, 0x15929c95UL, 0xbf6d7aebUL, 0x955259daUL,+      0xd4be832dUL, 0x587421d3UL, 0x49e06929UL, 0x8ec9c844UL,+      0x75c2896aUL, 0xf48e7978UL, 0x99583e6bUL, 0x27b971ddUL,+      0xbee14fb6UL, 0xf088ad17UL, 0xc920ac66UL, 0x7dce3ab4UL,+      0x63df4a18UL, 0xe51a3182UL, 0x97513360UL, 0x62537f45UL,+      0xb16477e0UL, 0xbb6bae84UL, 0xfe81a01cUL, 0xf9082b94UL,+      0x70486858UL, 0x8f45fd19UL, 0x94de6c87UL, 0x527bf8b7UL,+      0xab73d323UL, 0x724b02e2UL, 0xe31f8f57UL, 0x6655ab2aUL,+      0xb2eb2807UL, 0x2fb5c203UL, 0x86c57b9aUL, 0xd33708a5UL,+      0x302887f2UL, 0x23bfa5b2UL, 0x02036abaUL, 0xed16825cUL,+      0x8acf1c2bUL, 0xa779b492UL, 0xf307f2f0UL, 0x4e69e2a1UL,+      0x65daf4cdUL, 0x0605bed5UL, 0xd134621fUL, 0xc4a6fe8aUL,+      0x342e539dUL, 0xa2f355a0UL, 0x058ae132UL, 0xa4f6eb75UL,+      0x0b83ec39UL, 0x4060efaaUL, 0x5e719f06UL, 0xbd6e1051UL,+      0x3e218af9UL, 0x96dd063dUL, 0xdd3e05aeUL, 0x4de6bd46UL,+      0x91548db5UL, 0x71c45d05UL, 0x0406d46fUL, 0x605015ffUL,+      0x1998fb24UL, 0xd6bde997UL, 0x894043ccUL, 0x67d99e77UL,+      0xb0e842bdUL, 0x07898b88UL, 0xe7195b38UL, 0x79c8eedbUL,+      0xa17c0a47UL, 0x7c420fe9UL, 0xf8841ec9UL, 0x00000000UL,+      0x09808683UL, 0x322bed48UL, 0x1e1170acUL, 0x6c5a724eUL,+      0xfd0efffbUL, 0x0f853856UL, 0x3daed51eUL, 0x362d3927UL,+      0x0a0fd964UL, 0x685ca621UL, 0x9b5b54d1UL, 0x24362e3aUL,+      0x0c0a67b1UL, 0x9357e70fUL, 0xb4ee96d2UL, 0x1b9b919eUL,+      0x80c0c54fUL, 0x61dc20a2UL, 0x5a774b69UL, 0x1c121a16UL,+      0xe293ba0aUL, 0xc0a02ae5UL, 0x3c22e043UL, 0x121b171dUL,+      0x0e090d0bUL, 0xf28bc7adUL, 0x2db6a8b9UL, 0x141ea9c8UL,+      0x57f11985UL, 0xaf75074cUL, 0xee99ddbbUL, 0xa37f60fdUL,+      0xf701269fUL, 0x5c72f5bcUL, 0x44663bc5UL, 0x5bfb7e34UL,+      0x8b432976UL, 0xcb23c6dcUL, 0xb6edfc68UL, 0xb8e4f163UL,+      0xd731dccaUL, 0x42638510UL, 0x13972240UL, 0x84c61120UL,+      0x854a247dUL, 0xd2bb3df8UL, 0xaef93211UL, 0xc729a16dUL,+      0x1d9e2f4bUL, 0xdcb230f3UL, 0x0d8652ecUL, 0x77c1e3d0UL,+      0x2bb3166cUL, 0xa970b999UL, 0x119448faUL, 0x47e96422UL,+      0xa8fc8cc4UL, 0xa0f03f1aUL, 0x567d2cd8UL, 0x223390efUL,+      0x87494ec7UL, 0xd938d1c1UL, 0x8ccaa2feUL, 0x98d40b36UL,+      0xa6f581cfUL, 0xa57ade28UL, 0xdab78e26UL, 0x3fadbfa4UL,+      0x2c3a9de4UL, 0x5078920dUL, 0x6a5fcc9bUL, 0x547e4662UL,+      0xf68d13c2UL, 0x90d8b8e8UL, 0x2e39f75eUL, 0x82c3aff5UL,+      0x9f5d80beUL, 0x69d0937cUL, 0x6fd52da9UL, 0xcf2512b3UL,+      0xc8ac993bUL, 0x10187da7UL, 0xe89c636eUL, 0xdb3bbb7bUL,+      0xcd267809UL, 0x6e5918f4UL, 0xec9ab701UL, 0x834f9aa8UL,+      0xe6956e65UL, 0xaaffe67eUL, 0x21bccf08UL, 0xef15e8e6UL,+      0xbae79bd9UL, 0x4a6f36ceUL, 0xea9f09d4UL, 0x29b07cd6UL,+      0x31a4b2afUL, 0x2a3f2331UL, 0xc6a59430UL, 0x35a266c0UL,+      0x744ebc37UL, 0xfc82caa6UL, 0xe090d0b0UL, 0x33a7d815UL,+      0xf104984aUL, 0x41ecdaf7UL, 0x7fcd500eUL, 0x1791f62fUL,+      0x764dd68dUL, 0x43efb04dUL, 0xccaa4d54UL, 0xe49604dfUL,+      0x9ed1b5e3UL, 0x4c6a881bUL, 0xc12c1fb8UL, 0x4665517fUL,+      0x9d5eea04UL, 0x018c355dUL, 0xfa877473UL, 0xfb0b412eUL,+      0xb3671d5aUL, 0x92dbd252UL, 0xe9105633UL, 0x6dd64713UL,+      0x9ad7618cUL, 0x37a10c7aUL, 0x59f8148eUL, 0xeb133c89UL,+      0xcea927eeUL, 0xb761c935UL, 0xe11ce5edUL, 0x7a47b13cUL,+      0x9cd2df59UL, 0x55f2733fUL, 0x1814ce79UL, 0x73c737bfUL,+      0x53f7cdeaUL, 0x5ffdaa5bUL, 0xdf3d6f14UL, 0x7844db86UL,+      0xcaaff381UL, 0xb968c43eUL, 0x3824342cUL, 0xc2a3405fUL,+      0x161dc372UL, 0xbce2250cUL, 0x283c498bUL, 0xff0d9541UL,+      0x39a80171UL, 0x080cb3deUL, 0xd8b4e49cUL, 0x6456c190UL,+      0x7bcb8461UL, 0xd532b670UL, 0x486c5c74UL, 0xd0b85742UL+  };+  static const SWord32 table2[] = {+      0x5051f4a7UL, 0x537e4165UL, 0xc31a17a4UL, 0x963a275eUL,+      0xcb3bab6bUL, 0xf11f9d45UL, 0xabacfa58UL, 0x934be303UL,+      0x552030faUL, 0xf6ad766dUL, 0x9188cc76UL, 0x25f5024cUL,+      0xfc4fe5d7UL, 0xd7c52acbUL, 0x80263544UL, 0x8fb562a3UL,+      0x49deb15aUL, 0x6725ba1bUL, 0x9845ea0eUL, 0xe15dfec0UL,+      0x02c32f75UL, 0x12814cf0UL, 0xa38d4697UL, 0xc66bd3f9UL,+      0xe7038f5fUL, 0x9515929cUL, 0xebbf6d7aUL, 0xda955259UL,+      0x2dd4be83UL, 0xd3587421UL, 0x2949e069UL, 0x448ec9c8UL,+      0x6a75c289UL, 0x78f48e79UL, 0x6b99583eUL, 0xdd27b971UL,+      0xb6bee14fUL, 0x17f088adUL, 0x66c920acUL, 0xb47dce3aUL,+      0x1863df4aUL, 0x82e51a31UL, 0x60975133UL, 0x4562537fUL,+      0xe0b16477UL, 0x84bb6baeUL, 0x1cfe81a0UL, 0x94f9082bUL,+      0x58704868UL, 0x198f45fdUL, 0x8794de6cUL, 0xb7527bf8UL,+      0x23ab73d3UL, 0xe2724b02UL, 0x57e31f8fUL, 0x2a6655abUL,+      0x07b2eb28UL, 0x032fb5c2UL, 0x9a86c57bUL, 0xa5d33708UL,+      0xf2302887UL, 0xb223bfa5UL, 0xba02036aUL, 0x5ced1682UL,+      0x2b8acf1cUL, 0x92a779b4UL, 0xf0f307f2UL, 0xa14e69e2UL,+      0xcd65daf4UL, 0xd50605beUL, 0x1fd13462UL, 0x8ac4a6feUL,+      0x9d342e53UL, 0xa0a2f355UL, 0x32058ae1UL, 0x75a4f6ebUL,+      0x390b83ecUL, 0xaa4060efUL, 0x065e719fUL, 0x51bd6e10UL,+      0xf93e218aUL, 0x3d96dd06UL, 0xaedd3e05UL, 0x464de6bdUL,+      0xb591548dUL, 0x0571c45dUL, 0x6f0406d4UL, 0xff605015UL,+      0x241998fbUL, 0x97d6bde9UL, 0xcc894043UL, 0x7767d99eUL,+      0xbdb0e842UL, 0x8807898bUL, 0x38e7195bUL, 0xdb79c8eeUL,+      0x47a17c0aUL, 0xe97c420fUL, 0xc9f8841eUL, 0x00000000UL,+      0x83098086UL, 0x48322bedUL, 0xac1e1170UL, 0x4e6c5a72UL,+      0xfbfd0effUL, 0x560f8538UL, 0x1e3daed5UL, 0x27362d39UL,+      0x640a0fd9UL, 0x21685ca6UL, 0xd19b5b54UL, 0x3a24362eUL,+      0xb10c0a67UL, 0x0f9357e7UL, 0xd2b4ee96UL, 0x9e1b9b91UL,+      0x4f80c0c5UL, 0xa261dc20UL, 0x695a774bUL, 0x161c121aUL,+      0x0ae293baUL, 0xe5c0a02aUL, 0x433c22e0UL, 0x1d121b17UL,+      0x0b0e090dUL, 0xadf28bc7UL, 0xb92db6a8UL, 0xc8141ea9UL,+      0x8557f119UL, 0x4caf7507UL, 0xbbee99ddUL, 0xfda37f60UL,+      0x9ff70126UL, 0xbc5c72f5UL, 0xc544663bUL, 0x345bfb7eUL,+      0x768b4329UL, 0xdccb23c6UL, 0x68b6edfcUL, 0x63b8e4f1UL,+      0xcad731dcUL, 0x10426385UL, 0x40139722UL, 0x2084c611UL,+      0x7d854a24UL, 0xf8d2bb3dUL, 0x11aef932UL, 0x6dc729a1UL,+      0x4b1d9e2fUL, 0xf3dcb230UL, 0xec0d8652UL, 0xd077c1e3UL,+      0x6c2bb316UL, 0x99a970b9UL, 0xfa119448UL, 0x2247e964UL,+      0xc4a8fc8cUL, 0x1aa0f03fUL, 0xd8567d2cUL, 0xef223390UL,+      0xc787494eUL, 0xc1d938d1UL, 0xfe8ccaa2UL, 0x3698d40bUL,+      0xcfa6f581UL, 0x28a57adeUL, 0x26dab78eUL, 0xa43fadbfUL,+      0xe42c3a9dUL, 0x0d507892UL, 0x9b6a5fccUL, 0x62547e46UL,+      0xc2f68d13UL, 0xe890d8b8UL, 0x5e2e39f7UL, 0xf582c3afUL,+      0xbe9f5d80UL, 0x7c69d093UL, 0xa96fd52dUL, 0xb3cf2512UL,+      0x3bc8ac99UL, 0xa710187dUL, 0x6ee89c63UL, 0x7bdb3bbbUL,+      0x09cd2678UL, 0xf46e5918UL, 0x01ec9ab7UL, 0xa8834f9aUL,+      0x65e6956eUL, 0x7eaaffe6UL, 0x0821bccfUL, 0xe6ef15e8UL,+      0xd9bae79bUL, 0xce4a6f36UL, 0xd4ea9f09UL, 0xd629b07cUL,+      0xaf31a4b2UL, 0x312a3f23UL, 0x30c6a594UL, 0xc035a266UL,+      0x37744ebcUL, 0xa6fc82caUL, 0xb0e090d0UL, 0x1533a7d8UL,+      0x4af10498UL, 0xf741ecdaUL, 0x0e7fcd50UL, 0x2f1791f6UL,+      0x8d764dd6UL, 0x4d43efb0UL, 0x54ccaa4dUL, 0xdfe49604UL,+      0xe39ed1b5UL, 0x1b4c6a88UL, 0xb8c12c1fUL, 0x7f466551UL,+      0x049d5eeaUL, 0x5d018c35UL, 0x73fa8774UL, 0x2efb0b41UL,+      0x5ab3671dUL, 0x5292dbd2UL, 0x33e91056UL, 0x136dd647UL,+      0x8c9ad761UL, 0x7a37a10cUL, 0x8e59f814UL, 0x89eb133cUL,+      0xeecea927UL, 0x35b761c9UL, 0xede11ce5UL, 0x3c7a47b1UL,+      0x599cd2dfUL, 0x3f55f273UL, 0x791814ceUL, 0xbf73c737UL,+      0xea53f7cdUL, 0x5b5ffdaaUL, 0x14df3d6fUL, 0x867844dbUL,+      0x81caaff3UL, 0x3eb968c4UL, 0x2c382434UL, 0x5fc2a340UL,+      0x72161dc3UL, 0x0cbce225UL, 0x8b283c49UL, 0x41ff0d95UL,+      0x7139a801UL, 0xde080cb3UL, 0x9cd8b4e4UL, 0x906456c1UL,+      0x617bcb84UL, 0x70d532b6UL, 0x74486c5cUL, 0x42d0b857UL+  };+  static const SWord32 table3[] = {+      0xa75051f4UL, 0x65537e41UL, 0xa4c31a17UL, 0x5e963a27UL,+      0x6bcb3babUL, 0x45f11f9dUL, 0x58abacfaUL, 0x03934be3UL,+      0xfa552030UL, 0x6df6ad76UL, 0x769188ccUL, 0x4c25f502UL,+      0xd7fc4fe5UL, 0xcbd7c52aUL, 0x44802635UL, 0xa38fb562UL,+      0x5a49deb1UL, 0x1b6725baUL, 0x0e9845eaUL, 0xc0e15dfeUL,+      0x7502c32fUL, 0xf012814cUL, 0x97a38d46UL, 0xf9c66bd3UL,+      0x5fe7038fUL, 0x9c951592UL, 0x7aebbf6dUL, 0x59da9552UL,+      0x832dd4beUL, 0x21d35874UL, 0x692949e0UL, 0xc8448ec9UL,+      0x896a75c2UL, 0x7978f48eUL, 0x3e6b9958UL, 0x71dd27b9UL,+      0x4fb6bee1UL, 0xad17f088UL, 0xac66c920UL, 0x3ab47dceUL,+      0x4a1863dfUL, 0x3182e51aUL, 0x33609751UL, 0x7f456253UL,+      0x77e0b164UL, 0xae84bb6bUL, 0xa01cfe81UL, 0x2b94f908UL,+      0x68587048UL, 0xfd198f45UL, 0x6c8794deUL, 0xf8b7527bUL,+      0xd323ab73UL, 0x02e2724bUL, 0x8f57e31fUL, 0xab2a6655UL,+      0x2807b2ebUL, 0xc2032fb5UL, 0x7b9a86c5UL, 0x08a5d337UL,+      0x87f23028UL, 0xa5b223bfUL, 0x6aba0203UL, 0x825ced16UL,+      0x1c2b8acfUL, 0xb492a779UL, 0xf2f0f307UL, 0xe2a14e69UL,+      0xf4cd65daUL, 0xbed50605UL, 0x621fd134UL, 0xfe8ac4a6UL,+      0x539d342eUL, 0x55a0a2f3UL, 0xe132058aUL, 0xeb75a4f6UL,+      0xec390b83UL, 0xefaa4060UL, 0x9f065e71UL, 0x1051bd6eUL,+      0x8af93e21UL, 0x063d96ddUL, 0x05aedd3eUL, 0xbd464de6UL,+      0x8db59154UL, 0x5d0571c4UL, 0xd46f0406UL, 0x15ff6050UL,+      0xfb241998UL, 0xe997d6bdUL, 0x43cc8940UL, 0x9e7767d9UL,+      0x42bdb0e8UL, 0x8b880789UL, 0x5b38e719UL, 0xeedb79c8UL,+      0x0a47a17cUL, 0x0fe97c42UL, 0x1ec9f884UL, 0x00000000UL,+      0x86830980UL, 0xed48322bUL, 0x70ac1e11UL, 0x724e6c5aUL,+      0xfffbfd0eUL, 0x38560f85UL, 0xd51e3daeUL, 0x3927362dUL,+      0xd9640a0fUL, 0xa621685cUL, 0x54d19b5bUL, 0x2e3a2436UL,+      0x67b10c0aUL, 0xe70f9357UL, 0x96d2b4eeUL, 0x919e1b9bUL,+      0xc54f80c0UL, 0x20a261dcUL, 0x4b695a77UL, 0x1a161c12UL,+      0xba0ae293UL, 0x2ae5c0a0UL, 0xe0433c22UL, 0x171d121bUL,+      0x0d0b0e09UL, 0xc7adf28bUL, 0xa8b92db6UL, 0xa9c8141eUL,+      0x198557f1UL, 0x074caf75UL, 0xddbbee99UL, 0x60fda37fUL,+      0x269ff701UL, 0xf5bc5c72UL, 0x3bc54466UL, 0x7e345bfbUL,+      0x29768b43UL, 0xc6dccb23UL, 0xfc68b6edUL, 0xf163b8e4UL,+      0xdccad731UL, 0x85104263UL, 0x22401397UL, 0x112084c6UL,+      0x247d854aUL, 0x3df8d2bbUL, 0x3211aef9UL, 0xa16dc729UL,+      0x2f4b1d9eUL, 0x30f3dcb2UL, 0x52ec0d86UL, 0xe3d077c1UL,+      0x166c2bb3UL, 0xb999a970UL, 0x48fa1194UL, 0x642247e9UL,+      0x8cc4a8fcUL, 0x3f1aa0f0UL, 0x2cd8567dUL, 0x90ef2233UL,+      0x4ec78749UL, 0xd1c1d938UL, 0xa2fe8ccaUL, 0x0b3698d4UL,+      0x81cfa6f5UL, 0xde28a57aUL, 0x8e26dab7UL, 0xbfa43fadUL,+      0x9de42c3aUL, 0x920d5078UL, 0xcc9b6a5fUL, 0x4662547eUL,+      0x13c2f68dUL, 0xb8e890d8UL, 0xf75e2e39UL, 0xaff582c3UL,+      0x80be9f5dUL, 0x937c69d0UL, 0x2da96fd5UL, 0x12b3cf25UL,+      0x993bc8acUL, 0x7da71018UL, 0x636ee89cUL, 0xbb7bdb3bUL,+      0x7809cd26UL, 0x18f46e59UL, 0xb701ec9aUL, 0x9aa8834fUL,+      0x6e65e695UL, 0xe67eaaffUL, 0xcf0821bcUL, 0xe8e6ef15UL,+      0x9bd9bae7UL, 0x36ce4a6fUL, 0x09d4ea9fUL, 0x7cd629b0UL,+      0xb2af31a4UL, 0x23312a3fUL, 0x9430c6a5UL, 0x66c035a2UL,+      0xbc37744eUL, 0xcaa6fc82UL, 0xd0b0e090UL, 0xd81533a7UL,+      0x984af104UL, 0xdaf741ecUL, 0x500e7fcdUL, 0xf62f1791UL,+      0xd68d764dUL, 0xb04d43efUL, 0x4d54ccaaUL, 0x04dfe496UL,+      0xb5e39ed1UL, 0x881b4c6aUL, 0x1fb8c12cUL, 0x517f4665UL,+      0xea049d5eUL, 0x355d018cUL, 0x7473fa87UL, 0x412efb0bUL,+      0x1d5ab367UL, 0xd25292dbUL, 0x5633e910UL, 0x47136dd6UL,+      0x618c9ad7UL, 0x0c7a37a1UL, 0x148e59f8UL, 0x3c89eb13UL,+      0x27eecea9UL, 0xc935b761UL, 0xe5ede11cUL, 0xb13c7a47UL,+      0xdf599cd2UL, 0x733f55f2UL, 0xce791814UL, 0x37bf73c7UL,+      0xcdea53f7UL, 0xaa5b5ffdUL, 0x6f14df3dUL, 0xdb867844UL,+      0xf381caafUL, 0xc43eb968UL, 0x342c3824UL, 0x405fc2a3UL,+      0xc372161dUL, 0x250cbce2UL, 0x498b283cUL, 0x9541ff0dUL,+      0x017139a8UL, 0xb3de080cUL, 0xe49cd8b4UL, 0xc1906456UL,+      0x84617bcbUL, 0xb670d532UL, 0x5c74486cUL, 0x5742d0b8UL+  };+  static const SWord32 table4[] = {+      0xf4a75051UL, 0x4165537eUL, 0x17a4c31aUL, 0x275e963aUL,+      0xab6bcb3bUL, 0x9d45f11fUL, 0xfa58abacUL, 0xe303934bUL,+      0x30fa5520UL, 0x766df6adUL, 0xcc769188UL, 0x024c25f5UL,+      0xe5d7fc4fUL, 0x2acbd7c5UL, 0x35448026UL, 0x62a38fb5UL,+      0xb15a49deUL, 0xba1b6725UL, 0xea0e9845UL, 0xfec0e15dUL,+      0x2f7502c3UL, 0x4cf01281UL, 0x4697a38dUL, 0xd3f9c66bUL,+      0x8f5fe703UL, 0x929c9515UL, 0x6d7aebbfUL, 0x5259da95UL,+      0xbe832dd4UL, 0x7421d358UL, 0xe0692949UL, 0xc9c8448eUL,+      0xc2896a75UL, 0x8e7978f4UL, 0x583e6b99UL, 0xb971dd27UL,+      0xe14fb6beUL, 0x88ad17f0UL, 0x20ac66c9UL, 0xce3ab47dUL,+      0xdf4a1863UL, 0x1a3182e5UL, 0x51336097UL, 0x537f4562UL,+      0x6477e0b1UL, 0x6bae84bbUL, 0x81a01cfeUL, 0x082b94f9UL,+      0x48685870UL, 0x45fd198fUL, 0xde6c8794UL, 0x7bf8b752UL,+      0x73d323abUL, 0x4b02e272UL, 0x1f8f57e3UL, 0x55ab2a66UL,+      0xeb2807b2UL, 0xb5c2032fUL, 0xc57b9a86UL, 0x3708a5d3UL,+      0x2887f230UL, 0xbfa5b223UL, 0x036aba02UL, 0x16825cedUL,+      0xcf1c2b8aUL, 0x79b492a7UL, 0x07f2f0f3UL, 0x69e2a14eUL,+      0xdaf4cd65UL, 0x05bed506UL, 0x34621fd1UL, 0xa6fe8ac4UL,+      0x2e539d34UL, 0xf355a0a2UL, 0x8ae13205UL, 0xf6eb75a4UL,+      0x83ec390bUL, 0x60efaa40UL, 0x719f065eUL, 0x6e1051bdUL,+      0x218af93eUL, 0xdd063d96UL, 0x3e05aeddUL, 0xe6bd464dUL,+      0x548db591UL, 0xc45d0571UL, 0x06d46f04UL, 0x5015ff60UL,+      0x98fb2419UL, 0xbde997d6UL, 0x4043cc89UL, 0xd99e7767UL,+      0xe842bdb0UL, 0x898b8807UL, 0x195b38e7UL, 0xc8eedb79UL,+      0x7c0a47a1UL, 0x420fe97cUL, 0x841ec9f8UL, 0x00000000UL,+      0x80868309UL, 0x2bed4832UL, 0x1170ac1eUL, 0x5a724e6cUL,+      0x0efffbfdUL, 0x8538560fUL, 0xaed51e3dUL, 0x2d392736UL,+      0x0fd9640aUL, 0x5ca62168UL, 0x5b54d19bUL, 0x362e3a24UL,+      0x0a67b10cUL, 0x57e70f93UL, 0xee96d2b4UL, 0x9b919e1bUL,+      0xc0c54f80UL, 0xdc20a261UL, 0x774b695aUL, 0x121a161cUL,+      0x93ba0ae2UL, 0xa02ae5c0UL, 0x22e0433cUL, 0x1b171d12UL,+      0x090d0b0eUL, 0x8bc7adf2UL, 0xb6a8b92dUL, 0x1ea9c814UL,+      0xf1198557UL, 0x75074cafUL, 0x99ddbbeeUL, 0x7f60fda3UL,+      0x01269ff7UL, 0x72f5bc5cUL, 0x663bc544UL, 0xfb7e345bUL,+      0x4329768bUL, 0x23c6dccbUL, 0xedfc68b6UL, 0xe4f163b8UL,+      0x31dccad7UL, 0x63851042UL, 0x97224013UL, 0xc6112084UL,+      0x4a247d85UL, 0xbb3df8d2UL, 0xf93211aeUL, 0x29a16dc7UL,+      0x9e2f4b1dUL, 0xb230f3dcUL, 0x8652ec0dUL, 0xc1e3d077UL,+      0xb3166c2bUL, 0x70b999a9UL, 0x9448fa11UL, 0xe9642247UL,+      0xfc8cc4a8UL, 0xf03f1aa0UL, 0x7d2cd856UL, 0x3390ef22UL,+      0x494ec787UL, 0x38d1c1d9UL, 0xcaa2fe8cUL, 0xd40b3698UL,+      0xf581cfa6UL, 0x7ade28a5UL, 0xb78e26daUL, 0xadbfa43fUL,+      0x3a9de42cUL, 0x78920d50UL, 0x5fcc9b6aUL, 0x7e466254UL,+      0x8d13c2f6UL, 0xd8b8e890UL, 0x39f75e2eUL, 0xc3aff582UL,+      0x5d80be9fUL, 0xd0937c69UL, 0xd52da96fUL, 0x2512b3cfUL,+      0xac993bc8UL, 0x187da710UL, 0x9c636ee8UL, 0x3bbb7bdbUL,+      0x267809cdUL, 0x5918f46eUL, 0x9ab701ecUL, 0x4f9aa883UL,+      0x956e65e6UL, 0xffe67eaaUL, 0xbccf0821UL, 0x15e8e6efUL,+      0xe79bd9baUL, 0x6f36ce4aUL, 0x9f09d4eaUL, 0xb07cd629UL,+      0xa4b2af31UL, 0x3f23312aUL, 0xa59430c6UL, 0xa266c035UL,+      0x4ebc3774UL, 0x82caa6fcUL, 0x90d0b0e0UL, 0xa7d81533UL,+      0x04984af1UL, 0xecdaf741UL, 0xcd500e7fUL, 0x91f62f17UL,+      0x4dd68d76UL, 0xefb04d43UL, 0xaa4d54ccUL, 0x9604dfe4UL,+      0xd1b5e39eUL, 0x6a881b4cUL, 0x2c1fb8c1UL, 0x65517f46UL,+      0x5eea049dUL, 0x8c355d01UL, 0x877473faUL, 0x0b412efbUL,+      0x671d5ab3UL, 0xdbd25292UL, 0x105633e9UL, 0xd647136dUL,+      0xd7618c9aUL, 0xa10c7a37UL, 0xf8148e59UL, 0x133c89ebUL,+      0xa927eeceUL, 0x61c935b7UL, 0x1ce5ede1UL, 0x47b13c7aUL,+      0xd2df599cUL, 0xf2733f55UL, 0x14ce7918UL, 0xc737bf73UL,+      0xf7cdea53UL, 0xfdaa5b5fUL, 0x3d6f14dfUL, 0x44db8678UL,+      0xaff381caUL, 0x68c43eb9UL, 0x24342c38UL, 0xa3405fc2UL,+      0x1dc37216UL, 0xe2250cbcUL, 0x3c498b28UL, 0x0d9541ffUL,+      0xa8017139UL, 0x0cb3de08UL, 0xb4e49cd8UL, 0x56c19064UL,+      0xcb84617bUL, 0x32b670d5UL, 0x6c5c7448UL, 0xb85742d0UL+  };+  const SWord32 s560 = s0 ^ s4;+  const SWord16 s561 = (SWord16) (s560 >> 16);+  const SWord8  s562 = (SWord8) (s561 >> 8);+  const SWord32 s563 = table1[s562];+  const SWord32 s819 = s3 ^ s7;+  const SWord16 s820 = (SWord16) (s819 >> 16);+  const SWord8  s821 = (SWord8) s820;+  const SWord32 s822 = table2[s821];+  const SWord32 s823 = s563 ^ s822;+  const SWord32 s1079 = s2 ^ s6;+  const SWord16 s1080 = (SWord16) s1079;+  const SWord8  s1081 = (SWord8) (s1080 >> 8);+  const SWord32 s1082 = table3[s1081];+  const SWord32 s1083 = s823 ^ s1082;+  const SWord32 s1339 = s1 ^ s5;+  const SWord16 s1340 = (SWord16) s1339;+  const SWord8  s1341 = (SWord8) s1340;+  const SWord32 s1342 = table4[s1341];+  const SWord32 s1343 = s1083 ^ s1342;+  const SWord32 s1344 = s8 ^ s1343;+  const SWord16 s1345 = (SWord16) (s1344 >> 16);+  const SWord8  s1346 = (SWord8) (s1345 >> 8);+  const SWord32 s1347 = table1[s1346];+  const SWord8  s1348 = (SWord8) (s820 >> 8);+  const SWord32 s1349 = table1[s1348];+  const SWord16 s1350 = (SWord16) (s1079 >> 16);+  const SWord8  s1351 = (SWord8) s1350;+  const SWord32 s1352 = table2[s1351];+  const SWord32 s1353 = s1349 ^ s1352;+  const SWord8  s1354 = (SWord8) (s1340 >> 8);+  const SWord32 s1355 = table3[s1354];+  const SWord32 s1356 = s1353 ^ s1355;+  const SWord16 s1357 = (SWord16) s560;+  const SWord8  s1358 = (SWord8) s1357;+  const SWord32 s1359 = table4[s1358];+  const SWord32 s1360 = s1356 ^ s1359;+  const SWord32 s1361 = s11 ^ s1360;+  const SWord16 s1362 = (SWord16) (s1361 >> 16);+  const SWord8  s1363 = (SWord8) s1362;+  const SWord32 s1364 = table2[s1363];+  const SWord32 s1365 = s1347 ^ s1364;+  const SWord8  s1366 = (SWord8) (s1350 >> 8);+  const SWord32 s1367 = table1[s1366];+  const SWord16 s1368 = (SWord16) (s1339 >> 16);+  const SWord8  s1369 = (SWord8) s1368;+  const SWord32 s1370 = table2[s1369];+  const SWord32 s1371 = s1367 ^ s1370;+  const SWord8  s1372 = (SWord8) (s1357 >> 8);+  const SWord32 s1373 = table3[s1372];+  const SWord32 s1374 = s1371 ^ s1373;+  const SWord16 s1375 = (SWord16) s819;+  const SWord8  s1376 = (SWord8) s1375;+  const SWord32 s1377 = table4[s1376];+  const SWord32 s1378 = s1374 ^ s1377;+  const SWord32 s1379 = s10 ^ s1378;+  const SWord16 s1380 = (SWord16) s1379;+  const SWord8  s1381 = (SWord8) (s1380 >> 8);+  const SWord32 s1382 = table3[s1381];+  const SWord32 s1383 = s1365 ^ s1382;+  const SWord8  s1384 = (SWord8) (s1368 >> 8);+  const SWord32 s1385 = table1[s1384];+  const SWord8  s1386 = (SWord8) s561;+  const SWord32 s1387 = table2[s1386];+  const SWord32 s1388 = s1385 ^ s1387;+  const SWord8  s1389 = (SWord8) (s1375 >> 8);+  const SWord32 s1390 = table3[s1389];+  const SWord32 s1391 = s1388 ^ s1390;+  const SWord8  s1392 = (SWord8) s1080;+  const SWord32 s1393 = table4[s1392];+  const SWord32 s1394 = s1391 ^ s1393;+  const SWord32 s1395 = s9 ^ s1394;+  const SWord16 s1396 = (SWord16) s1395;+  const SWord8  s1397 = (SWord8) s1396;+  const SWord32 s1398 = table4[s1397];+  const SWord32 s1399 = s1383 ^ s1398;+  const SWord32 s1400 = s12 ^ s1399;+  const SWord16 s1401 = (SWord16) (s1400 >> 16);+  const SWord8  s1402 = (SWord8) (s1401 >> 8);+  const SWord32 s1403 = table1[s1402];+  const SWord8  s1404 = (SWord8) (s1362 >> 8);+  const SWord32 s1405 = table1[s1404];+  const SWord16 s1406 = (SWord16) (s1379 >> 16);+  const SWord8  s1407 = (SWord8) s1406;+  const SWord32 s1408 = table2[s1407];+  const SWord32 s1409 = s1405 ^ s1408;+  const SWord8  s1410 = (SWord8) (s1396 >> 8);+  const SWord32 s1411 = table3[s1410];+  const SWord32 s1412 = s1409 ^ s1411;+  const SWord16 s1413 = (SWord16) s1344;+  const SWord8  s1414 = (SWord8) s1413;+  const SWord32 s1415 = table4[s1414];+  const SWord32 s1416 = s1412 ^ s1415;+  const SWord32 s1417 = s15 ^ s1416;+  const SWord16 s1418 = (SWord16) (s1417 >> 16);+  const SWord8  s1419 = (SWord8) s1418;+  const SWord32 s1420 = table2[s1419];+  const SWord32 s1421 = s1403 ^ s1420;+  const SWord8  s1422 = (SWord8) (s1406 >> 8);+  const SWord32 s1423 = table1[s1422];+  const SWord16 s1424 = (SWord16) (s1395 >> 16);+  const SWord8  s1425 = (SWord8) s1424;+  const SWord32 s1426 = table2[s1425];+  const SWord32 s1427 = s1423 ^ s1426;+  const SWord8  s1428 = (SWord8) (s1413 >> 8);+  const SWord32 s1429 = table3[s1428];+  const SWord32 s1430 = s1427 ^ s1429;+  const SWord16 s1431 = (SWord16) s1361;+  const SWord8  s1432 = (SWord8) s1431;+  const SWord32 s1433 = table4[s1432];+  const SWord32 s1434 = s1430 ^ s1433;+  const SWord32 s1435 = s14 ^ s1434;+  const SWord16 s1436 = (SWord16) s1435;+  const SWord8  s1437 = (SWord8) (s1436 >> 8);+  const SWord32 s1438 = table3[s1437];+  const SWord32 s1439 = s1421 ^ s1438;+  const SWord8  s1440 = (SWord8) (s1424 >> 8);+  const SWord32 s1441 = table1[s1440];+  const SWord8  s1442 = (SWord8) s1345;+  const SWord32 s1443 = table2[s1442];+  const SWord32 s1444 = s1441 ^ s1443;+  const SWord8  s1445 = (SWord8) (s1431 >> 8);+  const SWord32 s1446 = table3[s1445];+  const SWord32 s1447 = s1444 ^ s1446;+  const SWord8  s1448 = (SWord8) s1380;+  const SWord32 s1449 = table4[s1448];+  const SWord32 s1450 = s1447 ^ s1449;+  const SWord32 s1451 = s13 ^ s1450;+  const SWord16 s1452 = (SWord16) s1451;+  const SWord8  s1453 = (SWord8) s1452;+  const SWord32 s1454 = table4[s1453];+  const SWord32 s1455 = s1439 ^ s1454;+  const SWord32 s1456 = s16 ^ s1455;+  const SWord16 s1457 = (SWord16) (s1456 >> 16);+  const SWord8  s1458 = (SWord8) (s1457 >> 8);+  const SWord32 s1459 = table1[s1458];+  const SWord8  s1460 = (SWord8) (s1418 >> 8);+  const SWord32 s1461 = table1[s1460];+  const SWord16 s1462 = (SWord16) (s1435 >> 16);+  const SWord8  s1463 = (SWord8) s1462;+  const SWord32 s1464 = table2[s1463];+  const SWord32 s1465 = s1461 ^ s1464;+  const SWord8  s1466 = (SWord8) (s1452 >> 8);+  const SWord32 s1467 = table3[s1466];+  const SWord32 s1468 = s1465 ^ s1467;+  const SWord16 s1469 = (SWord16) s1400;+  const SWord8  s1470 = (SWord8) s1469;+  const SWord32 s1471 = table4[s1470];+  const SWord32 s1472 = s1468 ^ s1471;+  const SWord32 s1473 = s19 ^ s1472;+  const SWord16 s1474 = (SWord16) (s1473 >> 16);+  const SWord8  s1475 = (SWord8) s1474;+  const SWord32 s1476 = table2[s1475];+  const SWord32 s1477 = s1459 ^ s1476;+  const SWord8  s1478 = (SWord8) (s1462 >> 8);+  const SWord32 s1479 = table1[s1478];+  const SWord16 s1480 = (SWord16) (s1451 >> 16);+  const SWord8  s1481 = (SWord8) s1480;+  const SWord32 s1482 = table2[s1481];+  const SWord32 s1483 = s1479 ^ s1482;+  const SWord8  s1484 = (SWord8) (s1469 >> 8);+  const SWord32 s1485 = table3[s1484];+  const SWord32 s1486 = s1483 ^ s1485;+  const SWord16 s1487 = (SWord16) s1417;+  const SWord8  s1488 = (SWord8) s1487;+  const SWord32 s1489 = table4[s1488];+  const SWord32 s1490 = s1486 ^ s1489;+  const SWord32 s1491 = s18 ^ s1490;+  const SWord16 s1492 = (SWord16) s1491;+  const SWord8  s1493 = (SWord8) (s1492 >> 8);+  const SWord32 s1494 = table3[s1493];+  const SWord32 s1495 = s1477 ^ s1494;+  const SWord8  s1496 = (SWord8) (s1480 >> 8);+  const SWord32 s1497 = table1[s1496];+  const SWord8  s1498 = (SWord8) s1401;+  const SWord32 s1499 = table2[s1498];+  const SWord32 s1500 = s1497 ^ s1499;+  const SWord8  s1501 = (SWord8) (s1487 >> 8);+  const SWord32 s1502 = table3[s1501];+  const SWord32 s1503 = s1500 ^ s1502;+  const SWord8  s1504 = (SWord8) s1436;+  const SWord32 s1505 = table4[s1504];+  const SWord32 s1506 = s1503 ^ s1505;+  const SWord32 s1507 = s17 ^ s1506;+  const SWord16 s1508 = (SWord16) s1507;+  const SWord8  s1509 = (SWord8) s1508;+  const SWord32 s1510 = table4[s1509];+  const SWord32 s1511 = s1495 ^ s1510;+  const SWord32 s1512 = s20 ^ s1511;+  const SWord16 s1513 = (SWord16) (s1512 >> 16);+  const SWord8  s1514 = (SWord8) (s1513 >> 8);+  const SWord32 s1515 = table1[s1514];+  const SWord8  s1516 = (SWord8) (s1474 >> 8);+  const SWord32 s1517 = table1[s1516];+  const SWord16 s1518 = (SWord16) (s1491 >> 16);+  const SWord8  s1519 = (SWord8) s1518;+  const SWord32 s1520 = table2[s1519];+  const SWord32 s1521 = s1517 ^ s1520;+  const SWord8  s1522 = (SWord8) (s1508 >> 8);+  const SWord32 s1523 = table3[s1522];+  const SWord32 s1524 = s1521 ^ s1523;+  const SWord16 s1525 = (SWord16) s1456;+  const SWord8  s1526 = (SWord8) s1525;+  const SWord32 s1527 = table4[s1526];+  const SWord32 s1528 = s1524 ^ s1527;+  const SWord32 s1529 = s23 ^ s1528;+  const SWord16 s1530 = (SWord16) (s1529 >> 16);+  const SWord8  s1531 = (SWord8) s1530;+  const SWord32 s1532 = table2[s1531];+  const SWord32 s1533 = s1515 ^ s1532;+  const SWord8  s1534 = (SWord8) (s1518 >> 8);+  const SWord32 s1535 = table1[s1534];+  const SWord16 s1536 = (SWord16) (s1507 >> 16);+  const SWord8  s1537 = (SWord8) s1536;+  const SWord32 s1538 = table2[s1537];+  const SWord32 s1539 = s1535 ^ s1538;+  const SWord8  s1540 = (SWord8) (s1525 >> 8);+  const SWord32 s1541 = table3[s1540];+  const SWord32 s1542 = s1539 ^ s1541;+  const SWord16 s1543 = (SWord16) s1473;+  const SWord8  s1544 = (SWord8) s1543;+  const SWord32 s1545 = table4[s1544];+  const SWord32 s1546 = s1542 ^ s1545;+  const SWord32 s1547 = s22 ^ s1546;+  const SWord16 s1548 = (SWord16) s1547;+  const SWord8  s1549 = (SWord8) (s1548 >> 8);+  const SWord32 s1550 = table3[s1549];+  const SWord32 s1551 = s1533 ^ s1550;+  const SWord8  s1552 = (SWord8) (s1536 >> 8);+  const SWord32 s1553 = table1[s1552];+  const SWord8  s1554 = (SWord8) s1457;+  const SWord32 s1555 = table2[s1554];+  const SWord32 s1556 = s1553 ^ s1555;+  const SWord8  s1557 = (SWord8) (s1543 >> 8);+  const SWord32 s1558 = table3[s1557];+  const SWord32 s1559 = s1556 ^ s1558;+  const SWord8  s1560 = (SWord8) s1492;+  const SWord32 s1561 = table4[s1560];+  const SWord32 s1562 = s1559 ^ s1561;+  const SWord32 s1563 = s21 ^ s1562;+  const SWord16 s1564 = (SWord16) s1563;+  const SWord8  s1565 = (SWord8) s1564;+  const SWord32 s1566 = table4[s1565];+  const SWord32 s1567 = s1551 ^ s1566;+  const SWord32 s1568 = s24 ^ s1567;+  const SWord16 s1569 = (SWord16) (s1568 >> 16);+  const SWord8  s1570 = (SWord8) (s1569 >> 8);+  const SWord32 s1571 = table1[s1570];+  const SWord8  s1572 = (SWord8) (s1530 >> 8);+  const SWord32 s1573 = table1[s1572];+  const SWord16 s1574 = (SWord16) (s1547 >> 16);+  const SWord8  s1575 = (SWord8) s1574;+  const SWord32 s1576 = table2[s1575];+  const SWord32 s1577 = s1573 ^ s1576;+  const SWord8  s1578 = (SWord8) (s1564 >> 8);+  const SWord32 s1579 = table3[s1578];+  const SWord32 s1580 = s1577 ^ s1579;+  const SWord16 s1581 = (SWord16) s1512;+  const SWord8  s1582 = (SWord8) s1581;+  const SWord32 s1583 = table4[s1582];+  const SWord32 s1584 = s1580 ^ s1583;+  const SWord32 s1585 = s27 ^ s1584;+  const SWord16 s1586 = (SWord16) (s1585 >> 16);+  const SWord8  s1587 = (SWord8) s1586;+  const SWord32 s1588 = table2[s1587];+  const SWord32 s1589 = s1571 ^ s1588;+  const SWord8  s1590 = (SWord8) (s1574 >> 8);+  const SWord32 s1591 = table1[s1590];+  const SWord16 s1592 = (SWord16) (s1563 >> 16);+  const SWord8  s1593 = (SWord8) s1592;+  const SWord32 s1594 = table2[s1593];+  const SWord32 s1595 = s1591 ^ s1594;+  const SWord8  s1596 = (SWord8) (s1581 >> 8);+  const SWord32 s1597 = table3[s1596];+  const SWord32 s1598 = s1595 ^ s1597;+  const SWord16 s1599 = (SWord16) s1529;+  const SWord8  s1600 = (SWord8) s1599;+  const SWord32 s1601 = table4[s1600];+  const SWord32 s1602 = s1598 ^ s1601;+  const SWord32 s1603 = s26 ^ s1602;+  const SWord16 s1604 = (SWord16) s1603;+  const SWord8  s1605 = (SWord8) (s1604 >> 8);+  const SWord32 s1606 = table3[s1605];+  const SWord32 s1607 = s1589 ^ s1606;+  const SWord8  s1608 = (SWord8) (s1592 >> 8);+  const SWord32 s1609 = table1[s1608];+  const SWord8  s1610 = (SWord8) s1513;+  const SWord32 s1611 = table2[s1610];+  const SWord32 s1612 = s1609 ^ s1611;+  const SWord8  s1613 = (SWord8) (s1599 >> 8);+  const SWord32 s1614 = table3[s1613];+  const SWord32 s1615 = s1612 ^ s1614;+  const SWord8  s1616 = (SWord8) s1548;+  const SWord32 s1617 = table4[s1616];+  const SWord32 s1618 = s1615 ^ s1617;+  const SWord32 s1619 = s25 ^ s1618;+  const SWord16 s1620 = (SWord16) s1619;+  const SWord8  s1621 = (SWord8) s1620;+  const SWord32 s1622 = table4[s1621];+  const SWord32 s1623 = s1607 ^ s1622;+  const SWord32 s1624 = s28 ^ s1623;+  const SWord16 s1625 = (SWord16) (s1624 >> 16);+  const SWord8  s1626 = (SWord8) (s1625 >> 8);+  const SWord32 s1627 = table1[s1626];+  const SWord8  s1628 = (SWord8) (s1586 >> 8);+  const SWord32 s1629 = table1[s1628];+  const SWord16 s1630 = (SWord16) (s1603 >> 16);+  const SWord8  s1631 = (SWord8) s1630;+  const SWord32 s1632 = table2[s1631];+  const SWord32 s1633 = s1629 ^ s1632;+  const SWord8  s1634 = (SWord8) (s1620 >> 8);+  const SWord32 s1635 = table3[s1634];+  const SWord32 s1636 = s1633 ^ s1635;+  const SWord16 s1637 = (SWord16) s1568;+  const SWord8  s1638 = (SWord8) s1637;+  const SWord32 s1639 = table4[s1638];+  const SWord32 s1640 = s1636 ^ s1639;+  const SWord32 s1641 = s31 ^ s1640;+  const SWord16 s1642 = (SWord16) (s1641 >> 16);+  const SWord8  s1643 = (SWord8) s1642;+  const SWord32 s1644 = table2[s1643];+  const SWord32 s1645 = s1627 ^ s1644;+  const SWord8  s1646 = (SWord8) (s1630 >> 8);+  const SWord32 s1647 = table1[s1646];+  const SWord16 s1648 = (SWord16) (s1619 >> 16);+  const SWord8  s1649 = (SWord8) s1648;+  const SWord32 s1650 = table2[s1649];+  const SWord32 s1651 = s1647 ^ s1650;+  const SWord8  s1652 = (SWord8) (s1637 >> 8);+  const SWord32 s1653 = table3[s1652];+  const SWord32 s1654 = s1651 ^ s1653;+  const SWord16 s1655 = (SWord16) s1585;+  const SWord8  s1656 = (SWord8) s1655;+  const SWord32 s1657 = table4[s1656];+  const SWord32 s1658 = s1654 ^ s1657;+  const SWord32 s1659 = s30 ^ s1658;+  const SWord16 s1660 = (SWord16) s1659;+  const SWord8  s1661 = (SWord8) (s1660 >> 8);+  const SWord32 s1662 = table3[s1661];+  const SWord32 s1663 = s1645 ^ s1662;+  const SWord8  s1664 = (SWord8) (s1648 >> 8);+  const SWord32 s1665 = table1[s1664];+  const SWord8  s1666 = (SWord8) s1569;+  const SWord32 s1667 = table2[s1666];+  const SWord32 s1668 = s1665 ^ s1667;+  const SWord8  s1669 = (SWord8) (s1655 >> 8);+  const SWord32 s1670 = table3[s1669];+  const SWord32 s1671 = s1668 ^ s1670;+  const SWord8  s1672 = (SWord8) s1604;+  const SWord32 s1673 = table4[s1672];+  const SWord32 s1674 = s1671 ^ s1673;+  const SWord32 s1675 = s29 ^ s1674;+  const SWord16 s1676 = (SWord16) s1675;+  const SWord8  s1677 = (SWord8) s1676;+  const SWord32 s1678 = table4[s1677];+  const SWord32 s1679 = s1663 ^ s1678;+  const SWord32 s1680 = s32 ^ s1679;+  const SWord16 s1681 = (SWord16) (s1680 >> 16);+  const SWord8  s1682 = (SWord8) (s1681 >> 8);+  const SWord32 s1683 = table1[s1682];+  const SWord8  s1684 = (SWord8) (s1642 >> 8);+  const SWord32 s1685 = table1[s1684];+  const SWord16 s1686 = (SWord16) (s1659 >> 16);+  const SWord8  s1687 = (SWord8) s1686;+  const SWord32 s1688 = table2[s1687];+  const SWord32 s1689 = s1685 ^ s1688;+  const SWord8  s1690 = (SWord8) (s1676 >> 8);+  const SWord32 s1691 = table3[s1690];+  const SWord32 s1692 = s1689 ^ s1691;+  const SWord16 s1693 = (SWord16) s1624;+  const SWord8  s1694 = (SWord8) s1693;+  const SWord32 s1695 = table4[s1694];+  const SWord32 s1696 = s1692 ^ s1695;+  const SWord32 s1697 = s35 ^ s1696;+  const SWord16 s1698 = (SWord16) (s1697 >> 16);+  const SWord8  s1699 = (SWord8) s1698;+  const SWord32 s1700 = table2[s1699];+  const SWord32 s1701 = s1683 ^ s1700;+  const SWord8  s1702 = (SWord8) (s1686 >> 8);+  const SWord32 s1703 = table1[s1702];+  const SWord16 s1704 = (SWord16) (s1675 >> 16);+  const SWord8  s1705 = (SWord8) s1704;+  const SWord32 s1706 = table2[s1705];+  const SWord32 s1707 = s1703 ^ s1706;+  const SWord8  s1708 = (SWord8) (s1693 >> 8);+  const SWord32 s1709 = table3[s1708];+  const SWord32 s1710 = s1707 ^ s1709;+  const SWord16 s1711 = (SWord16) s1641;+  const SWord8  s1712 = (SWord8) s1711;+  const SWord32 s1713 = table4[s1712];+  const SWord32 s1714 = s1710 ^ s1713;+  const SWord32 s1715 = s34 ^ s1714;+  const SWord16 s1716 = (SWord16) s1715;+  const SWord8  s1717 = (SWord8) (s1716 >> 8);+  const SWord32 s1718 = table3[s1717];+  const SWord32 s1719 = s1701 ^ s1718;+  const SWord8  s1720 = (SWord8) (s1704 >> 8);+  const SWord32 s1721 = table1[s1720];+  const SWord8  s1722 = (SWord8) s1625;+  const SWord32 s1723 = table2[s1722];+  const SWord32 s1724 = s1721 ^ s1723;+  const SWord8  s1725 = (SWord8) (s1711 >> 8);+  const SWord32 s1726 = table3[s1725];+  const SWord32 s1727 = s1724 ^ s1726;+  const SWord8  s1728 = (SWord8) s1660;+  const SWord32 s1729 = table4[s1728];+  const SWord32 s1730 = s1727 ^ s1729;+  const SWord32 s1731 = s33 ^ s1730;+  const SWord16 s1732 = (SWord16) s1731;+  const SWord8  s1733 = (SWord8) s1732;+  const SWord32 s1734 = table4[s1733];+  const SWord32 s1735 = s1719 ^ s1734;+  const SWord32 s1736 = s36 ^ s1735;+  const SWord16 s1737 = (SWord16) (s1736 >> 16);+  const SWord8  s1738 = (SWord8) (s1737 >> 8);+  const SWord32 s1739 = table1[s1738];+  const SWord8  s1740 = (SWord8) (s1698 >> 8);+  const SWord32 s1741 = table1[s1740];+  const SWord16 s1742 = (SWord16) (s1715 >> 16);+  const SWord8  s1743 = (SWord8) s1742;+  const SWord32 s1744 = table2[s1743];+  const SWord32 s1745 = s1741 ^ s1744;+  const SWord8  s1746 = (SWord8) (s1732 >> 8);+  const SWord32 s1747 = table3[s1746];+  const SWord32 s1748 = s1745 ^ s1747;+  const SWord16 s1749 = (SWord16) s1680;+  const SWord8  s1750 = (SWord8) s1749;+  const SWord32 s1751 = table4[s1750];+  const SWord32 s1752 = s1748 ^ s1751;+  const SWord32 s1753 = s39 ^ s1752;+  const SWord16 s1754 = (SWord16) (s1753 >> 16);+  const SWord8  s1755 = (SWord8) s1754;+  const SWord32 s1756 = table2[s1755];+  const SWord32 s1757 = s1739 ^ s1756;+  const SWord8  s1758 = (SWord8) (s1742 >> 8);+  const SWord32 s1759 = table1[s1758];+  const SWord16 s1760 = (SWord16) (s1731 >> 16);+  const SWord8  s1761 = (SWord8) s1760;+  const SWord32 s1762 = table2[s1761];+  const SWord32 s1763 = s1759 ^ s1762;+  const SWord8  s1764 = (SWord8) (s1749 >> 8);+  const SWord32 s1765 = table3[s1764];+  const SWord32 s1766 = s1763 ^ s1765;+  const SWord16 s1767 = (SWord16) s1697;+  const SWord8  s1768 = (SWord8) s1767;+  const SWord32 s1769 = table4[s1768];+  const SWord32 s1770 = s1766 ^ s1769;+  const SWord32 s1771 = s38 ^ s1770;+  const SWord16 s1772 = (SWord16) s1771;+  const SWord8  s1773 = (SWord8) (s1772 >> 8);+  const SWord32 s1774 = table3[s1773];+  const SWord32 s1775 = s1757 ^ s1774;+  const SWord8  s1776 = (SWord8) (s1760 >> 8);+  const SWord32 s1777 = table1[s1776];+  const SWord8  s1778 = (SWord8) s1681;+  const SWord32 s1779 = table2[s1778];+  const SWord32 s1780 = s1777 ^ s1779;+  const SWord8  s1781 = (SWord8) (s1767 >> 8);+  const SWord32 s1782 = table3[s1781];+  const SWord32 s1783 = s1780 ^ s1782;+  const SWord8  s1784 = (SWord8) s1716;+  const SWord32 s1785 = table4[s1784];+  const SWord32 s1786 = s1783 ^ s1785;+  const SWord32 s1787 = s37 ^ s1786;+  const SWord16 s1788 = (SWord16) s1787;+  const SWord8  s1789 = (SWord8) s1788;+  const SWord32 s1790 = table4[s1789];+  const SWord32 s1791 = s1775 ^ s1790;+  const SWord32 s1792 = s40 ^ s1791;+  const SWord16 s1793 = (SWord16) (s1792 >> 16);+  const SWord8  s1794 = (SWord8) (s1793 >> 8);+  const SWord8  s1795 = table0[s1794];+  const SWord8  s1796 = (SWord8) (s1754 >> 8);+  const SWord32 s1797 = table1[s1796];+  const SWord16 s1798 = (SWord16) (s1771 >> 16);+  const SWord8  s1799 = (SWord8) s1798;+  const SWord32 s1800 = table2[s1799];+  const SWord32 s1801 = s1797 ^ s1800;+  const SWord8  s1802 = (SWord8) (s1788 >> 8);+  const SWord32 s1803 = table3[s1802];+  const SWord32 s1804 = s1801 ^ s1803;+  const SWord16 s1805 = (SWord16) s1736;+  const SWord8  s1806 = (SWord8) s1805;+  const SWord32 s1807 = table4[s1806];+  const SWord32 s1808 = s1804 ^ s1807;+  const SWord32 s1809 = s43 ^ s1808;+  const SWord16 s1810 = (SWord16) (s1809 >> 16);+  const SWord8  s1811 = (SWord8) s1810;+  const SWord8  s1812 = table0[s1811];+  const SWord16 s1813 = (((SWord16) s1795) << 8) | ((SWord16) s1812);+  const SWord8  s1814 = (SWord8) (s1798 >> 8);+  const SWord32 s1815 = table1[s1814];+  const SWord16 s1816 = (SWord16) (s1787 >> 16);+  const SWord8  s1817 = (SWord8) s1816;+  const SWord32 s1818 = table2[s1817];+  const SWord32 s1819 = s1815 ^ s1818;+  const SWord8  s1820 = (SWord8) (s1805 >> 8);+  const SWord32 s1821 = table3[s1820];+  const SWord32 s1822 = s1819 ^ s1821;+  const SWord16 s1823 = (SWord16) s1753;+  const SWord8  s1824 = (SWord8) s1823;+  const SWord32 s1825 = table4[s1824];+  const SWord32 s1826 = s1822 ^ s1825;+  const SWord32 s1827 = s42 ^ s1826;+  const SWord16 s1828 = (SWord16) s1827;+  const SWord8  s1829 = (SWord8) (s1828 >> 8);+  const SWord8  s1830 = table0[s1829];+  const SWord8  s1831 = (SWord8) (s1816 >> 8);+  const SWord32 s1832 = table1[s1831];+  const SWord8  s1833 = (SWord8) s1737;+  const SWord32 s1834 = table2[s1833];+  const SWord32 s1835 = s1832 ^ s1834;+  const SWord8  s1836 = (SWord8) (s1823 >> 8);+  const SWord32 s1837 = table3[s1836];+  const SWord32 s1838 = s1835 ^ s1837;+  const SWord8  s1839 = (SWord8) s1772;+  const SWord32 s1840 = table4[s1839];+  const SWord32 s1841 = s1838 ^ s1840;+  const SWord32 s1842 = s41 ^ s1841;+  const SWord16 s1843 = (SWord16) s1842;+  const SWord8  s1844 = (SWord8) s1843;+  const SWord8  s1845 = table0[s1844];+  const SWord16 s1846 = (((SWord16) s1830) << 8) | ((SWord16) s1845);+  const SWord32 s1847 = (((SWord32) s1813) << 16) | ((SWord32) s1846);+  const SWord32 s1848 = s44 ^ s1847;+  const SWord16 s1849 = (SWord16) (s1842 >> 16);+  const SWord8  s1850 = (SWord8) (s1849 >> 8);+  const SWord8  s1851 = table0[s1850];+  const SWord8  s1852 = (SWord8) s1793;+  const SWord8  s1853 = table0[s1852];+  const SWord16 s1854 = (((SWord16) s1851) << 8) | ((SWord16) s1853);+  const SWord16 s1855 = (SWord16) s1809;+  const SWord8  s1856 = (SWord8) (s1855 >> 8);+  const SWord8  s1857 = table0[s1856];+  const SWord8  s1858 = (SWord8) s1828;+  const SWord8  s1859 = table0[s1858];+  const SWord16 s1860 = (((SWord16) s1857) << 8) | ((SWord16) s1859);+  const SWord32 s1861 = (((SWord32) s1854) << 16) | ((SWord32) s1860);+  const SWord32 s1862 = s45 ^ s1861;+  const SWord16 s1863 = (SWord16) (s1827 >> 16);+  const SWord8  s1864 = (SWord8) (s1863 >> 8);+  const SWord8  s1865 = table0[s1864];+  const SWord8  s1866 = (SWord8) s1849;+  const SWord8  s1867 = table0[s1866];+  const SWord16 s1868 = (((SWord16) s1865) << 8) | ((SWord16) s1867);+  const SWord16 s1869 = (SWord16) s1792;+  const SWord8  s1870 = (SWord8) (s1869 >> 8);+  const SWord8  s1871 = table0[s1870];+  const SWord8  s1872 = (SWord8) s1855;+  const SWord8  s1873 = table0[s1872];+  const SWord16 s1874 = (((SWord16) s1871) << 8) | ((SWord16) s1873);+  const SWord32 s1875 = (((SWord32) s1868) << 16) | ((SWord32) s1874);+  const SWord32 s1876 = s46 ^ s1875;+  const SWord8  s1877 = (SWord8) (s1810 >> 8);+  const SWord8  s1878 = table0[s1877];+  const SWord8  s1879 = (SWord8) s1863;+  const SWord8  s1880 = table0[s1879];+  const SWord16 s1881 = (((SWord16) s1878) << 8) | ((SWord16) s1880);+  const SWord8  s1882 = (SWord8) (s1843 >> 8);+  const SWord8  s1883 = table0[s1882];+  const SWord8  s1884 = (SWord8) s1869;+  const SWord8  s1885 = table0[s1884];+  const SWord16 s1886 = (((SWord16) s1883) << 8) | ((SWord16) s1885);+  const SWord32 s1887 = (((SWord32) s1881) << 16) | ((SWord32) s1886);+  const SWord32 s1888 = s47 ^ s1887;++  pt[0] = s1848;+  pt[1] = s1862;+  pt[2] = s1876;+  pt[3] = s1888;+}+== END: "aes128BlockDecrypt.c" ==================+== BEGIN: "aes128Lib.h" ================+/* Header file for aes128Lib. Automatically generated by SBV. Do not edit! */++#ifndef __aes128Lib__HEADER_INCLUDED__+#define __aes128Lib__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototypes: */+void aes128KeySchedule(const SWord32 *key, SWord32 *encKS,+                       SWord32 *decKS);+void aes128BlockEncrypt(const SWord32 *pt, const SWord32 *xkey,+                        SWord32 *ct);+void aes128BlockDecrypt(const SWord32 *ct, const SWord32 *xkey,+                        SWord32 *pt);++#endif /* __aes128Lib__HEADER_INCLUDED__ */+== END: "aes128Lib.h" ==================+== BEGIN: "aes128Lib_driver.c" ================+/* Example driver program for aes128Lib. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "aes128Lib.h"++void aes128KeySchedule_driver(void)+{+  const SWord32 key[4] = {+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL+  };++  printf("Contents of input array key:\n");+  int key_ctr;+  for(key_ctr = 0; key_ctr < 4 ; ++key_ctr)+    printf("  key[%d] = 0x%08"PRIx32"UL\n", key_ctr ,key[key_ctr]);++  SWord32 encKS[44];+  SWord32 decKS[44];++  aes128KeySchedule(key, encKS, decKS);++  printf("aes128KeySchedule(key, encKS, decKS) ->\n");+  int encKS_ctr;+  for(encKS_ctr = 0; encKS_ctr < 44 ; ++encKS_ctr)+    printf("  encKS[%d] = 0x%08"PRIx32"UL\n", encKS_ctr ,encKS[encKS_ctr]);+  int decKS_ctr;+  for(decKS_ctr = 0; decKS_ctr < 44 ; ++decKS_ctr)+    printf("  decKS[%d] = 0x%08"PRIx32"UL\n", decKS_ctr ,decKS[decKS_ctr]);+}++void aes128BlockEncrypt_driver(void)+{+  const SWord32 pt[4] = {+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL+  };++  printf("Contents of input array pt:\n");+  int pt_ctr;+  for(pt_ctr = 0; pt_ctr < 4 ; ++pt_ctr)+    printf("  pt[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]);++  const SWord32 xkey[44] = {+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL+  };++  printf("Contents of input array xkey:\n");+  int xkey_ctr;+  for(xkey_ctr = 0; xkey_ctr < 44 ; ++xkey_ctr)+    printf("  xkey[%d] = 0x%08"PRIx32"UL\n", xkey_ctr ,xkey[xkey_ctr]);++  SWord32 ct[4];++  aes128BlockEncrypt(pt, xkey, ct);++  printf("aes128BlockEncrypt(pt, xkey, ct) ->\n");+  int ct_ctr;+  for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr)+    printf("  ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]);+}++void aes128BlockDecrypt_driver(void)+{+  const SWord32 ct[4] = {+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL+  };++  printf("Contents of input array ct:\n");+  int ct_ctr;+  for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr)+    printf("  ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]);++  const SWord32 xkey[44] = {+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,+      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL+  };++  printf("Contents of input array xkey:\n");+  int xkey_ctr;+  for(xkey_ctr = 0; xkey_ctr < 44 ; ++xkey_ctr)+    printf("  xkey[%d] = 0x%08"PRIx32"UL\n", xkey_ctr ,xkey[xkey_ctr]);++  SWord32 pt[4];++  aes128BlockDecrypt(ct, xkey, pt);++  printf("aes128BlockDecrypt(ct, xkey, pt) ->\n");+  int pt_ctr;+  for(pt_ctr = 0; pt_ctr < 4 ; ++pt_ctr)+    printf("  pt[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]);+}++int main(void)+{+  printf("====================================\n");+  printf("** Driver run for aes128KeySchedule:\n");+  printf("====================================\n");+  aes128KeySchedule_driver();++  printf("=====================================\n");+  printf("** Driver run for aes128BlockEncrypt:\n");+  printf("=====================================\n");+  aes128BlockEncrypt_driver();++  printf("=====================================\n");+  printf("** Driver run for aes128BlockDecrypt:\n");+  printf("=====================================\n");+  aes128BlockDecrypt_driver();++  return 0;+}+== END: "aes128Lib_driver.c" ==================+== BEGIN: "Makefile" ================+# Makefile for aes128Lib. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer+AR?=ar+ARFLAGS?=cr++all: aes128Lib.a aes128Lib_driver++aes128Lib.a: aes128KeySchedule.o aes128BlockEncrypt.o aes128BlockDecrypt.o+	${AR} ${ARFLAGS} $@ $^++aes128Lib_driver: aes128Lib_driver.c aes128Lib.h+	${CC} ${CCFLAGS} $< -o $@ aes128Lib.a++aes128KeySchedule.o: aes128KeySchedule.c aes128Lib.h+	${CC} ${CCFLAGS} -c $< -o $@++aes128BlockEncrypt.o: aes128BlockEncrypt.c aes128Lib.h+	${CC} ${CCFLAGS} -c $< -o $@++aes128BlockDecrypt.o: aes128BlockDecrypt.c aes128Lib.h+	${CC} ${CCFLAGS} -c $< -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f aes128Lib.a aes128Lib_driver+== END: "Makefile" ==================
+ SBVTestSuite/GoldFiles/allSat1.gold view
@@ -0,0 +1,4 @@+Solution #1:+  x = Q!val!0 :: Q+  y = Q!val!0 :: Q+This is the only solution.
+ SBVTestSuite/GoldFiles/allSat2.gold view
@@ -0,0 +1,9 @@+Solution #1:+  x = Q!val!0 :: Q+  y = Q!val!0 :: Q+  z = Q!val!0 :: Q+Solution #2:+  x = Q!val!0 :: Q+  y = Q!val!0 :: Q+  z = Q!val!1 :: Q+Found 2 different solutions.
+ SBVTestSuite/GoldFiles/allSat3.gold view
@@ -0,0 +1,5 @@+Solution #1:+  s0 = 0.0 :: Float+Solution #2:+  s0 = -0.0 :: Float+Found 2 different solutions.
+ SBVTestSuite/GoldFiles/allSat4.gold view
@@ -0,0 +1,1 @@+No solutions found.
+ SBVTestSuite/GoldFiles/allSat5.gold view
@@ -0,0 +1,19 @@+Solution #1:+  s0 = 0 :: Word8+  s1 = 1 :: Word8+Solution #2:+  s0 = 0 :: Word8+  s1 = 3 :: Word8+Solution #3:+  s0 = 0 :: Word8+  s1 = 2 :: Word8+Solution #4:+  s0 = 1 :: Word8+  s1 = 2 :: Word8+Solution #5:+  s0 = 2 :: Word8+  s1 = 3 :: Word8+Solution #6:+  s0 = 1 :: Word8+  s1 = 3 :: Word8+Found 6 different solutions.
+ SBVTestSuite/GoldFiles/allSat6.gold view
@@ -0,0 +1,10 @@+Solution #1:+  x = 0 :: Word8+  y = 1 :: Word8+Solution #2:+  x = 0 :: Word8+  y = 2 :: Word8+Solution #3:+  x = 1 :: Word8+  y = 2 :: Word8+Found 3 different solutions. (Unique up to prefix existentials.)
+ SBVTestSuite/GoldFiles/assertSoft1.gold view
@@ -0,0 +1,7 @@+Optimal model:+  x   =     0 :: Integer+  y   =     1 :: Integer+  as1 = False :: Bool+  as2 =  True :: Bool+  as3 =  True :: Bool+  as4 = False :: Bool
+ SBVTestSuite/GoldFiles/assertSoft2.gold view
@@ -0,0 +1,8 @@+Optimal model:+  a1    = False :: Bool+  a2    =  True :: Bool+  a3    =  True :: Bool+  as_a1 = False :: Bool+  as_a2 =  True :: Bool+  as_a3 =  True :: Bool+  as_a4 =  True :: Bool
+ SBVTestSuite/GoldFiles/auf-1.gold view
@@ -0,0 +1,33 @@+INPUTS+  s0 :: SWord32, existential, aliasing "x"+  s1 :: SWord32, existential, aliasing "y"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s2 = 2 :: Word32+  s8 = 3 :: Word32+  s9 = 0 :: Word32+  s13 = 1 :: Word32+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+  [uninterpreted] f :: SWord32 -> SWord64+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s3 :: SWord32 = s0 + s2+  s4 :: SBool = s1 == s3+  s5 :: SBool = ~ s4+  s6 :: SWord32 = s1 - s2+  s7 :: SBool = s0 == s6+  s10 :: SWord32 = if s7 then s8 else s9+  s11 :: SWord64 = [uninterpreted] f s10+  s12 :: SWord32 = s1 - s0+  s14 :: SWord32 = s12 + s13+  s15 :: SWord64 = [uninterpreted] f s14+  s16 :: SBool = s11 == s15+  s17 :: SBool = s5 | s16+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s17
+ SBVTestSuite/GoldFiles/basic-1_1.gold view
@@ -0,0 +1,1 @@+5 :: Word8
+ SBVTestSuite/GoldFiles/basic-1_2.gold view
@@ -0,0 +1,1 @@+5 :: Word8
+ SBVTestSuite/GoldFiles/basic-1_3.gold view
@@ -0,0 +1,1 @@+25 :: Word8
+ SBVTestSuite/GoldFiles/basic-1_4.gold view
@@ -0,0 +1,1 @@+25 :: Word8
+ SBVTestSuite/GoldFiles/basic-1_5.gold view
@@ -0,0 +1,1 @@+4 :: Word8
+ SBVTestSuite/GoldFiles/basic-2_1.gold view
@@ -0,0 +1,19 @@+INPUTS+  s0 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s1 = 3 :: Word8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s1 - s0+  s4 :: SWord8 = s2 * s3+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s4
+ SBVTestSuite/GoldFiles/basic-2_2.gold view
@@ -0,0 +1,18 @@+INPUTS+  s0 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s1 = 9 :: Word8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 * s0+  s3 :: SWord8 = s1 - s2+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s3
+ SBVTestSuite/GoldFiles/basic-2_3.gold view
@@ -0,0 +1,18 @@+INPUTS+  s0 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s1 = 3 :: Word8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s2 * s2+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s3
+ SBVTestSuite/GoldFiles/basic-2_4.gold view
@@ -0,0 +1,18 @@+INPUTS+  s0 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s1 = 3 :: Word8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s2 * s2+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s3
+ SBVTestSuite/GoldFiles/basic-2_5.gold view
@@ -0,0 +1,1 @@+4 :: Word8
+ SBVTestSuite/GoldFiles/basic-3_1.gold view
@@ -0,0 +1,19 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s0 - s1+  s4 :: SWord8 = s2 * s3+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s4
+ SBVTestSuite/GoldFiles/basic-3_2.gold view
@@ -0,0 +1,19 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 * s0+  s3 :: SWord8 = s1 * s1+  s4 :: SWord8 = s2 - s3+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s4
+ SBVTestSuite/GoldFiles/basic-3_3.gold view
@@ -0,0 +1,18 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s2 * s2+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s3
+ SBVTestSuite/GoldFiles/basic-3_4.gold view
@@ -0,0 +1,18 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s2 * s2+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s3
+ SBVTestSuite/GoldFiles/basic-3_5.gold view
@@ -0,0 +1,18 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s2 = 1 :: Word8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s3 :: SWord8 = s0 + s2+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s3
+ SBVTestSuite/GoldFiles/basic-4_1.gold view
@@ -0,0 +1,18 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s1 :: SWord8 = s0 + s0+  s2 :: SWord8 = s0 - s0+  s3 :: SWord8 = s1 * s2+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s3
+ SBVTestSuite/GoldFiles/basic-4_2.gold view
@@ -0,0 +1,17 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s1 :: SWord8 = s0 * s0+  s2 :: SWord8 = s1 - s1+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s2
+ SBVTestSuite/GoldFiles/basic-4_3.gold view
@@ -0,0 +1,17 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s1 :: SWord8 = s0 + s0+  s2 :: SWord8 = s1 * s1+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s2
+ SBVTestSuite/GoldFiles/basic-4_4.gold view
@@ -0,0 +1,17 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s1 :: SWord8 = s0 + s0+  s2 :: SWord8 = s1 * s1+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s2
+ SBVTestSuite/GoldFiles/basic-4_5.gold view
@@ -0,0 +1,17 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s1 = 1 :: Word8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s2
+ SBVTestSuite/GoldFiles/basic-5_1.gold view
@@ -0,0 +1,20 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "q"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s0+  s3 :: SWord8 = s0 - s0+  s4 :: SWord8 = s2 * s3+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s1+  s4
+ SBVTestSuite/GoldFiles/basic-5_2.gold view
@@ -0,0 +1,19 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "q"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 * s0+  s3 :: SWord8 = s2 - s2+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s1+  s3
+ SBVTestSuite/GoldFiles/basic-5_3.gold view
@@ -0,0 +1,19 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "q"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s0+  s3 :: SWord8 = s2 * s2+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s1+  s3
+ SBVTestSuite/GoldFiles/basic-5_4.gold view
@@ -0,0 +1,19 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "q"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s0+  s3 :: SWord8 = s2 * s2+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s1+  s3
+ SBVTestSuite/GoldFiles/basic-5_5.gold view
@@ -0,0 +1,19 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "q"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s2 = 1 :: Word8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s3 :: SWord8 = s0 + s2+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s1+  s3
+ SBVTestSuite/GoldFiles/boxed1.gold view
@@ -0,0 +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+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+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+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
+ SBVTestSuite/GoldFiles/ccitt.gold view
@@ -0,0 +1,1832 @@+INPUTS+  s0 :: SWord32+  s1 :: SWord16+  s2 :: SWord32+  s3 :: SWord16+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s13 = 0 :: Word1+  s1686 = 0 :: Word8+  s1687 = 1 :: Word8+  s1815 = 3 :: Word8+  s9 = 0 :: Word16+  s525 = 1 :: Word64+  s526 = 0 :: Word64+  s528 = 2 :: Word64+  s531 = 4 :: Word64+  s534 = 8 :: Word64+  s537 = 16 :: Word64+  s540 = 32 :: Word64+  s543 = 64 :: Word64+  s546 = 128 :: Word64+  s549 = 256 :: Word64+  s552 = 512 :: Word64+  s555 = 1024 :: Word64+  s558 = 2048 :: Word64+  s561 = 4096 :: Word64+  s564 = 8192 :: Word64+  s567 = 16384 :: Word64+  s570 = 32768 :: Word64+  s573 = 65536 :: Word64+  s576 = 131072 :: Word64+  s579 = 262144 :: Word64+  s582 = 524288 :: Word64+  s585 = 1048576 :: Word64+  s588 = 2097152 :: Word64+  s591 = 4194304 :: Word64+  s594 = 8388608 :: Word64+  s597 = 16777216 :: Word64+  s600 = 33554432 :: Word64+  s603 = 67108864 :: Word64+  s606 = 134217728 :: Word64+  s609 = 268435456 :: Word64+  s612 = 536870912 :: Word64+  s615 = 1073741824 :: Word64+  s618 = 2147483648 :: Word64+  s621 = 4294967296 :: Word64+  s624 = 8589934592 :: Word64+  s627 = 17179869184 :: Word64+  s630 = 34359738368 :: Word64+  s633 = 68719476736 :: Word64+  s636 = 137438953472 :: Word64+  s639 = 274877906944 :: Word64+  s642 = 549755813888 :: Word64+  s645 = 1099511627776 :: Word64+  s648 = 2199023255552 :: Word64+  s651 = 4398046511104 :: Word64+  s654 = 8796093022208 :: Word64+  s657 = 17592186044416 :: Word64+  s660 = 35184372088832 :: Word64+  s663 = 70368744177664 :: Word64+  s666 = 140737488355328 :: Word64+  s669 = 281474976710656 :: Word64+  s672 = 562949953421312 :: Word64+  s675 = 1125899906842624 :: Word64+  s678 = 2251799813685248 :: Word64+  s681 = 4503599627370496 :: Word64+  s684 = 9007199254740992 :: Word64+  s687 = 18014398509481984 :: Word64+  s690 = 36028797018963968 :: Word64+  s693 = 72057594037927936 :: Word64+  s696 = 144115188075855872 :: Word64+  s699 = 288230376151711744 :: Word64+  s702 = 576460752303423488 :: Word64+  s705 = 1152921504606846976 :: Word64+  s708 = 2305843009213693952 :: Word64+  s711 = 4611686018427387904 :: Word64+  s714 = 9223372036854775808 :: Word64+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s4 :: SBool = s0 == s2+  s5 :: SBool = s1 == s3+  s6 :: SBool = s4 & s5+  s7 :: SBool = ~ s6+  s8 :: SBool = ~ s7+  s10 :: SWord32 = s1 # s9+  s11 :: SWord64 = s0 # s10+  s12 :: SWord1 = choose [63:63] s11+  s14 :: SBool = s12 /= s13+  s15 :: SWord1 = choose [62:62] s11+  s16 :: SBool = s13 /= s15+  s17 :: SWord1 = choose [61:61] s11+  s18 :: SBool = s13 /= s17+  s19 :: SWord1 = choose [60:60] s11+  s20 :: SBool = s13 /= s19+  s21 :: SWord1 = choose [59:59] s11+  s22 :: SBool = s13 /= s21+  s23 :: SBool = ~ s22+  s24 :: SBool = if s14 then s23 else s22+  s25 :: SWord1 = choose [58:58] s11+  s26 :: SBool = s13 /= s25+  s27 :: SBool = ~ s26+  s28 :: SBool = if s16 then s27 else s26+  s29 :: SWord1 = choose [57:57] s11+  s30 :: SBool = s13 /= s29+  s31 :: SBool = ~ s30+  s32 :: SBool = if s18 then s31 else s30+  s33 :: SWord1 = choose [56:56] s11+  s34 :: SBool = s13 /= s33+  s35 :: SBool = ~ s34+  s36 :: SBool = if s20 then s35 else s34+  s37 :: SWord1 = choose [55:55] s11+  s38 :: SBool = s13 /= s37+  s39 :: SBool = ~ s38+  s40 :: SBool = if s24 then s39 else s38+  s41 :: SWord1 = choose [54:54] s11+  s42 :: SBool = s13 /= s41+  s43 :: SBool = ~ s42+  s44 :: SBool = if s28 then s43 else s42+  s45 :: SWord1 = choose [53:53] s11+  s46 :: SBool = s13 /= s45+  s47 :: SBool = ~ s46+  s48 :: SBool = if s32 then s47 else s46+  s49 :: SWord1 = choose [52:52] s11+  s50 :: SBool = s13 /= s49+  s51 :: SBool = ~ s50+  s52 :: SBool = if s14 then s51 else s50+  s53 :: SBool = ~ s52+  s54 :: SBool = if s36 then s53 else s52+  s55 :: SWord1 = choose [51:51] s11+  s56 :: SBool = s13 /= s55+  s57 :: SBool = ~ s56+  s58 :: SBool = if s16 then s57 else s56+  s59 :: SBool = ~ s58+  s60 :: SBool = if s40 then s59 else s58+  s61 :: SWord1 = choose [50:50] s11+  s62 :: SBool = s13 /= s61+  s63 :: SBool = ~ s62+  s64 :: SBool = if s18 then s63 else s62+  s65 :: SBool = ~ s64+  s66 :: SBool = if s44 then s65 else s64+  s67 :: SWord1 = choose [49:49] s11+  s68 :: SBool = s13 /= s67+  s69 :: SBool = ~ s68+  s70 :: SBool = if s20 then s69 else s68+  s71 :: SBool = ~ s70+  s72 :: SBool = if s48 then s71 else s70+  s73 :: SWord1 = choose [48:48] s11+  s74 :: SBool = s13 /= s73+  s75 :: SBool = ~ s74+  s76 :: SBool = if s24 then s75 else s74+  s77 :: SBool = ~ s76+  s78 :: SBool = if s54 then s77 else s76+  s79 :: SWord1 = choose [47:47] s11+  s80 :: SBool = s13 /= s79+  s81 :: SBool = ~ s80+  s82 :: SBool = if s14 then s81 else s80+  s83 :: SBool = ~ s82+  s84 :: SBool = if s28 then s83 else s82+  s85 :: SBool = ~ s84+  s86 :: SBool = if s60 then s85 else s84+  s87 :: SWord1 = choose [46:46] s11+  s88 :: SBool = s13 /= s87+  s89 :: SBool = ~ s88+  s90 :: SBool = if s16 then s89 else s88+  s91 :: SBool = ~ s90+  s92 :: SBool = if s32 then s91 else s90+  s93 :: SBool = ~ s92+  s94 :: SBool = if s66 then s93 else s92+  s95 :: SWord1 = choose [45:45] s11+  s96 :: SBool = s13 /= s95+  s97 :: SBool = ~ s96+  s98 :: SBool = if s18 then s97 else s96+  s99 :: SBool = ~ s98+  s100 :: SBool = if s36 then s99 else s98+  s101 :: SBool = ~ s100+  s102 :: SBool = if s72 then s101 else s100+  s103 :: SWord1 = choose [44:44] s11+  s104 :: SBool = s13 /= s103+  s105 :: SBool = ~ s104+  s106 :: SBool = if s20 then s105 else s104+  s107 :: SBool = ~ s106+  s108 :: SBool = if s40 then s107 else s106+  s109 :: SBool = ~ s108+  s110 :: SBool = if s78 then s109 else s108+  s111 :: SWord1 = choose [43:43] s11+  s112 :: SBool = s13 /= s111+  s113 :: SBool = ~ s112+  s114 :: SBool = if s24 then s113 else s112+  s115 :: SBool = ~ s114+  s116 :: SBool = if s44 then s115 else s114+  s117 :: SBool = ~ s116+  s118 :: SBool = if s86 then s117 else s116+  s119 :: SWord1 = choose [42:42] s11+  s120 :: SBool = s13 /= s119+  s121 :: SBool = ~ s120+  s122 :: SBool = if s28 then s121 else s120+  s123 :: SBool = ~ s122+  s124 :: SBool = if s48 then s123 else s122+  s125 :: SBool = ~ s124+  s126 :: SBool = if s94 then s125 else s124+  s127 :: SWord1 = choose [41:41] s11+  s128 :: SBool = s13 /= s127+  s129 :: SBool = ~ s128+  s130 :: SBool = if s32 then s129 else s128+  s131 :: SBool = ~ s130+  s132 :: SBool = if s54 then s131 else s130+  s133 :: SBool = ~ s132+  s134 :: SBool = if s102 then s133 else s132+  s135 :: SWord1 = choose [40:40] s11+  s136 :: SBool = s13 /= s135+  s137 :: SBool = ~ s136+  s138 :: SBool = if s36 then s137 else s136+  s139 :: SBool = ~ s138+  s140 :: SBool = if s60 then s139 else s138+  s141 :: SBool = ~ s140+  s142 :: SBool = if s110 then s141 else s140+  s143 :: SWord1 = choose [39:39] s11+  s144 :: SBool = s13 /= s143+  s145 :: SBool = ~ s144+  s146 :: SBool = if s40 then s145 else s144+  s147 :: SBool = ~ s146+  s148 :: SBool = if s66 then s147 else s146+  s149 :: SBool = ~ s148+  s150 :: SBool = if s118 then s149 else s148+  s151 :: SWord1 = choose [38:38] s11+  s152 :: SBool = s13 /= s151+  s153 :: SBool = ~ s152+  s154 :: SBool = if s44 then s153 else s152+  s155 :: SBool = ~ s154+  s156 :: SBool = if s72 then s155 else s154+  s157 :: SBool = ~ s156+  s158 :: SBool = if s126 then s157 else s156+  s159 :: SWord1 = choose [37:37] s11+  s160 :: SBool = s13 /= s159+  s161 :: SBool = ~ s160+  s162 :: SBool = if s48 then s161 else s160+  s163 :: SBool = ~ s162+  s164 :: SBool = if s78 then s163 else s162+  s165 :: SBool = ~ s164+  s166 :: SBool = if s134 then s165 else s164+  s167 :: SWord1 = choose [36:36] s11+  s168 :: SBool = s13 /= s167+  s169 :: SBool = ~ s168+  s170 :: SBool = if s54 then s169 else s168+  s171 :: SBool = ~ s170+  s172 :: SBool = if s86 then s171 else s170+  s173 :: SBool = ~ s172+  s174 :: SBool = if s142 then s173 else s172+  s175 :: SWord1 = choose [35:35] s11+  s176 :: SBool = s13 /= s175+  s177 :: SBool = ~ s176+  s178 :: SBool = if s60 then s177 else s176+  s179 :: SBool = ~ s178+  s180 :: SBool = if s94 then s179 else s178+  s181 :: SBool = ~ s180+  s182 :: SBool = if s150 then s181 else s180+  s183 :: SWord1 = choose [34:34] s11+  s184 :: SBool = s13 /= s183+  s185 :: SBool = ~ s184+  s186 :: SBool = if s66 then s185 else s184+  s187 :: SBool = ~ s186+  s188 :: SBool = if s102 then s187 else s186+  s189 :: SBool = ~ s188+  s190 :: SBool = if s158 then s189 else s188+  s191 :: SWord1 = choose [33:33] s11+  s192 :: SBool = s13 /= s191+  s193 :: SBool = ~ s192+  s194 :: SBool = if s72 then s193 else s192+  s195 :: SBool = ~ s194+  s196 :: SBool = if s110 then s195 else s194+  s197 :: SBool = ~ s196+  s198 :: SBool = if s166 then s197 else s196+  s199 :: SWord1 = choose [32:32] s11+  s200 :: SBool = s13 /= s199+  s201 :: SBool = ~ s200+  s202 :: SBool = if s78 then s201 else s200+  s203 :: SBool = ~ s202+  s204 :: SBool = if s118 then s203 else s202+  s205 :: SBool = ~ s204+  s206 :: SBool = if s174 then s205 else s204+  s207 :: SWord1 = choose [31:31] s11+  s208 :: SBool = s13 /= s207+  s209 :: SBool = ~ s208+  s210 :: SBool = if s86 then s209 else s208+  s211 :: SBool = ~ s210+  s212 :: SBool = if s126 then s211 else s210+  s213 :: SBool = ~ s212+  s214 :: SBool = if s182 then s213 else s212+  s215 :: SWord1 = choose [30:30] s11+  s216 :: SBool = s13 /= s215+  s217 :: SBool = ~ s216+  s218 :: SBool = if s94 then s217 else s216+  s219 :: SBool = ~ s218+  s220 :: SBool = if s134 then s219 else s218+  s221 :: SBool = ~ s220+  s222 :: SBool = if s190 then s221 else s220+  s223 :: SWord1 = choose [29:29] s11+  s224 :: SBool = s13 /= s223+  s225 :: SBool = ~ s224+  s226 :: SBool = if s102 then s225 else s224+  s227 :: SBool = ~ s226+  s228 :: SBool = if s142 then s227 else s226+  s229 :: SBool = ~ s228+  s230 :: SBool = if s198 then s229 else s228+  s231 :: SWord1 = choose [28:28] s11+  s232 :: SBool = s13 /= s231+  s233 :: SBool = ~ s232+  s234 :: SBool = if s110 then s233 else s232+  s235 :: SBool = ~ s234+  s236 :: SBool = if s150 then s235 else s234+  s237 :: SBool = ~ s236+  s238 :: SBool = if s206 then s237 else s236+  s239 :: SWord1 = choose [27:27] s11+  s240 :: SBool = s13 /= s239+  s241 :: SBool = ~ s240+  s242 :: SBool = if s118 then s241 else s240+  s243 :: SBool = ~ s242+  s244 :: SBool = if s158 then s243 else s242+  s245 :: SBool = ~ s244+  s246 :: SBool = if s214 then s245 else s244+  s247 :: SWord1 = choose [26:26] s11+  s248 :: SBool = s13 /= s247+  s249 :: SBool = ~ s248+  s250 :: SBool = if s126 then s249 else s248+  s251 :: SBool = ~ s250+  s252 :: SBool = if s166 then s251 else s250+  s253 :: SBool = ~ s252+  s254 :: SBool = if s222 then s253 else s252+  s255 :: SWord1 = choose [25:25] s11+  s256 :: SBool = s13 /= s255+  s257 :: SBool = ~ s256+  s258 :: SBool = if s134 then s257 else s256+  s259 :: SBool = ~ s258+  s260 :: SBool = if s174 then s259 else s258+  s261 :: SBool = ~ s260+  s262 :: SBool = if s230 then s261 else s260+  s263 :: SWord1 = choose [24:24] s11+  s264 :: SBool = s13 /= s263+  s265 :: SBool = ~ s264+  s266 :: SBool = if s142 then s265 else s264+  s267 :: SBool = ~ s266+  s268 :: SBool = if s182 then s267 else s266+  s269 :: SBool = ~ s268+  s270 :: SBool = if s238 then s269 else s268+  s271 :: SWord1 = choose [23:23] s11+  s272 :: SBool = s13 /= s271+  s273 :: SBool = ~ s272+  s274 :: SBool = if s150 then s273 else s272+  s275 :: SBool = ~ s274+  s276 :: SBool = if s190 then s275 else s274+  s277 :: SBool = ~ s276+  s278 :: SBool = if s246 then s277 else s276+  s279 :: SWord1 = choose [22:22] s11+  s280 :: SBool = s13 /= s279+  s281 :: SBool = ~ s280+  s282 :: SBool = if s158 then s281 else s280+  s283 :: SBool = ~ s282+  s284 :: SBool = if s198 then s283 else s282+  s285 :: SBool = ~ s284+  s286 :: SBool = if s254 then s285 else s284+  s287 :: SWord1 = choose [21:21] s11+  s288 :: SBool = s13 /= s287+  s289 :: SBool = ~ s288+  s290 :: SBool = if s166 then s289 else s288+  s291 :: SBool = ~ s290+  s292 :: SBool = if s206 then s291 else s290+  s293 :: SBool = ~ s292+  s294 :: SBool = if s262 then s293 else s292+  s295 :: SWord1 = choose [20:20] s11+  s296 :: SBool = s13 /= s295+  s297 :: SBool = ~ s296+  s298 :: SBool = if s174 then s297 else s296+  s299 :: SBool = ~ s298+  s300 :: SBool = if s214 then s299 else s298+  s301 :: SBool = ~ s300+  s302 :: SBool = if s270 then s301 else s300+  s303 :: SWord1 = choose [19:19] s11+  s304 :: SBool = s13 /= s303+  s305 :: SBool = ~ s304+  s306 :: SBool = if s182 then s305 else s304+  s307 :: SBool = ~ s306+  s308 :: SBool = if s222 then s307 else s306+  s309 :: SBool = ~ s308+  s310 :: SBool = if s278 then s309 else s308+  s311 :: SWord1 = choose [18:18] s11+  s312 :: SBool = s13 /= s311+  s313 :: SBool = ~ s312+  s314 :: SBool = if s190 then s313 else s312+  s315 :: SBool = ~ s314+  s316 :: SBool = if s230 then s315 else s314+  s317 :: SBool = ~ s316+  s318 :: SBool = if s286 then s317 else s316+  s319 :: SWord1 = choose [17:17] s11+  s320 :: SBool = s13 /= s319+  s321 :: SBool = ~ s320+  s322 :: SBool = if s198 then s321 else s320+  s323 :: SBool = ~ s322+  s324 :: SBool = if s238 then s323 else s322+  s325 :: SBool = ~ s324+  s326 :: SBool = if s294 then s325 else s324+  s327 :: SWord1 = choose [16:16] s11+  s328 :: SBool = s13 /= s327+  s329 :: SBool = ~ s328+  s330 :: SBool = if s206 then s329 else s328+  s331 :: SBool = ~ s330+  s332 :: SBool = if s246 then s331 else s330+  s333 :: SBool = ~ s332+  s334 :: SBool = if s302 then s333 else s332+  s335 :: SBool = ~ s14+  s336 :: SBool = if s14 then s335 else s14+  s337 :: SBool = ~ s16+  s338 :: SBool = if s16 then s337 else s16+  s339 :: SBool = ~ s18+  s340 :: SBool = if s18 then s339 else s18+  s341 :: SBool = ~ s20+  s342 :: SBool = if s20 then s341 else s20+  s343 :: SBool = ~ s24+  s344 :: SBool = if s24 then s343 else s24+  s345 :: SBool = ~ s28+  s346 :: SBool = if s28 then s345 else s28+  s347 :: SBool = ~ s32+  s348 :: SBool = if s32 then s347 else s32+  s349 :: SBool = ~ s36+  s350 :: SBool = if s36 then s349 else s36+  s351 :: SBool = ~ s40+  s352 :: SBool = if s40 then s351 else s40+  s353 :: SBool = ~ s44+  s354 :: SBool = if s44 then s353 else s44+  s355 :: SBool = ~ s48+  s356 :: SBool = if s48 then s355 else s48+  s357 :: SBool = ~ s54+  s358 :: SBool = if s54 then s357 else s54+  s359 :: SBool = ~ s60+  s360 :: SBool = if s60 then s359 else s60+  s361 :: SBool = ~ s66+  s362 :: SBool = if s66 then s361 else s66+  s363 :: SBool = ~ s72+  s364 :: SBool = if s72 then s363 else s72+  s365 :: SBool = ~ s78+  s366 :: SBool = if s78 then s365 else s78+  s367 :: SBool = ~ s86+  s368 :: SBool = if s86 then s367 else s86+  s369 :: SBool = ~ s94+  s370 :: SBool = if s94 then s369 else s94+  s371 :: SBool = ~ s102+  s372 :: SBool = if s102 then s371 else s102+  s373 :: SBool = ~ s110+  s374 :: SBool = if s110 then s373 else s110+  s375 :: SBool = ~ s118+  s376 :: SBool = if s118 then s375 else s118+  s377 :: SBool = ~ s126+  s378 :: SBool = if s126 then s377 else s126+  s379 :: SBool = ~ s134+  s380 :: SBool = if s134 then s379 else s134+  s381 :: SBool = ~ s142+  s382 :: SBool = if s142 then s381 else s142+  s383 :: SBool = ~ s150+  s384 :: SBool = if s150 then s383 else s150+  s385 :: SBool = ~ s158+  s386 :: SBool = if s158 then s385 else s158+  s387 :: SBool = ~ s166+  s388 :: SBool = if s166 then s387 else s166+  s389 :: SBool = ~ s174+  s390 :: SBool = if s174 then s389 else s174+  s391 :: SBool = ~ s182+  s392 :: SBool = if s182 then s391 else s182+  s393 :: SBool = ~ s190+  s394 :: SBool = if s190 then s393 else s190+  s395 :: SBool = ~ s198+  s396 :: SBool = if s198 then s395 else s198+  s397 :: SBool = ~ s206+  s398 :: SBool = if s206 then s397 else s206+  s399 :: SBool = ~ s214+  s400 :: SBool = if s214 then s399 else s214+  s401 :: SBool = ~ s222+  s402 :: SBool = if s222 then s401 else s222+  s403 :: SBool = ~ s230+  s404 :: SBool = if s230 then s403 else s230+  s405 :: SBool = ~ s238+  s406 :: SBool = if s238 then s405 else s238+  s407 :: SBool = ~ s246+  s408 :: SBool = if s246 then s407 else s246+  s409 :: SBool = ~ s254+  s410 :: SBool = if s254 then s409 else s254+  s411 :: SBool = ~ s262+  s412 :: SBool = if s262 then s411 else s262+  s413 :: SBool = ~ s270+  s414 :: SBool = if s270 then s413 else s270+  s415 :: SBool = ~ s278+  s416 :: SBool = if s278 then s415 else s278+  s417 :: SBool = ~ s286+  s418 :: SBool = if s286 then s417 else s286+  s419 :: SBool = ~ s294+  s420 :: SBool = if s294 then s419 else s294+  s421 :: SBool = ~ s302+  s422 :: SBool = if s302 then s421 else s302+  s423 :: SBool = ~ s310+  s424 :: SBool = if s310 then s423 else s310+  s425 :: SBool = ~ s318+  s426 :: SBool = if s318 then s425 else s318+  s427 :: SBool = ~ s326+  s428 :: SBool = if s326 then s427 else s326+  s429 :: SBool = ~ s334+  s430 :: SBool = if s334 then s429 else s334+  s431 :: SWord1 = choose [15:15] s11+  s432 :: SBool = s13 /= s431+  s433 :: SBool = ~ s432+  s434 :: SBool = if s214 then s433 else s432+  s435 :: SBool = ~ s434+  s436 :: SBool = if s254 then s435 else s434+  s437 :: SBool = ~ s436+  s438 :: SBool = if s310 then s437 else s436+  s439 :: SWord1 = choose [14:14] s11+  s440 :: SBool = s13 /= s439+  s441 :: SBool = ~ s440+  s442 :: SBool = if s222 then s441 else s440+  s443 :: SBool = ~ s442+  s444 :: SBool = if s262 then s443 else s442+  s445 :: SBool = ~ s444+  s446 :: SBool = if s318 then s445 else s444+  s447 :: SWord1 = choose [13:13] s11+  s448 :: SBool = s13 /= s447+  s449 :: SBool = ~ s448+  s450 :: SBool = if s230 then s449 else s448+  s451 :: SBool = ~ s450+  s452 :: SBool = if s270 then s451 else s450+  s453 :: SBool = ~ s452+  s454 :: SBool = if s326 then s453 else s452+  s455 :: SWord1 = choose [12:12] s11+  s456 :: SBool = s13 /= s455+  s457 :: SBool = ~ s456+  s458 :: SBool = if s238 then s457 else s456+  s459 :: SBool = ~ s458+  s460 :: SBool = if s278 then s459 else s458+  s461 :: SBool = ~ s460+  s462 :: SBool = if s334 then s461 else s460+  s463 :: SWord1 = choose [11:11] s11+  s464 :: SBool = s13 /= s463+  s465 :: SBool = ~ s464+  s466 :: SBool = if s246 then s465 else s464+  s467 :: SBool = ~ s466+  s468 :: SBool = if s286 then s467 else s466+  s469 :: SWord1 = choose [10:10] s11+  s470 :: SBool = s13 /= s469+  s471 :: SBool = ~ s470+  s472 :: SBool = if s254 then s471 else s470+  s473 :: SBool = ~ s472+  s474 :: SBool = if s294 then s473 else s472+  s475 :: SWord1 = choose [9:9] s11+  s476 :: SBool = s13 /= s475+  s477 :: SBool = ~ s476+  s478 :: SBool = if s262 then s477 else s476+  s479 :: SBool = ~ s478+  s480 :: SBool = if s302 then s479 else s478+  s481 :: SWord1 = choose [8:8] s11+  s482 :: SBool = s13 /= s481+  s483 :: SBool = ~ s482+  s484 :: SBool = if s270 then s483 else s482+  s485 :: SBool = ~ s484+  s486 :: SBool = if s310 then s485 else s484+  s487 :: SWord1 = choose [7:7] s11+  s488 :: SBool = s13 /= s487+  s489 :: SBool = ~ s488+  s490 :: SBool = if s278 then s489 else s488+  s491 :: SBool = ~ s490+  s492 :: SBool = if s318 then s491 else s490+  s493 :: SWord1 = choose [6:6] s11+  s494 :: SBool = s13 /= s493+  s495 :: SBool = ~ s494+  s496 :: SBool = if s286 then s495 else s494+  s497 :: SBool = ~ s496+  s498 :: SBool = if s326 then s497 else s496+  s499 :: SWord1 = choose [5:5] s11+  s500 :: SBool = s13 /= s499+  s501 :: SBool = ~ s500+  s502 :: SBool = if s294 then s501 else s500+  s503 :: SBool = ~ s502+  s504 :: SBool = if s334 then s503 else s502+  s505 :: SWord1 = choose [4:4] s11+  s506 :: SBool = s13 /= s505+  s507 :: SBool = ~ s506+  s508 :: SBool = if s302 then s507 else s506+  s509 :: SWord1 = choose [3:3] s11+  s510 :: SBool = s13 /= s509+  s511 :: SBool = ~ s510+  s512 :: SBool = if s310 then s511 else s510+  s513 :: SWord1 = choose [2:2] s11+  s514 :: SBool = s13 /= s513+  s515 :: SBool = ~ s514+  s516 :: SBool = if s318 then s515 else s514+  s517 :: SWord1 = choose [1:1] s11+  s518 :: SBool = s13 /= s517+  s519 :: SBool = ~ s518+  s520 :: SBool = if s326 then s519 else s518+  s521 :: SWord1 = choose [0:0] s11+  s522 :: SBool = s13 /= s521+  s523 :: SBool = ~ s522+  s524 :: SBool = if s334 then s523 else s522+  s527 :: SWord64 = if s524 then s525 else s526+  s529 :: SWord64 = s527 | s528+  s530 :: SWord64 = if s520 then s529 else s527+  s532 :: SWord64 = s530 | s531+  s533 :: SWord64 = if s516 then s532 else s530+  s535 :: SWord64 = s533 | s534+  s536 :: SWord64 = if s512 then s535 else s533+  s538 :: SWord64 = s536 | s537+  s539 :: SWord64 = if s508 then s538 else s536+  s541 :: SWord64 = s539 | s540+  s542 :: SWord64 = if s504 then s541 else s539+  s544 :: SWord64 = s542 | s543+  s545 :: SWord64 = if s498 then s544 else s542+  s547 :: SWord64 = s545 | s546+  s548 :: SWord64 = if s492 then s547 else s545+  s550 :: SWord64 = s548 | s549+  s551 :: SWord64 = if s486 then s550 else s548+  s553 :: SWord64 = s551 | s552+  s554 :: SWord64 = if s480 then s553 else s551+  s556 :: SWord64 = s554 | s555+  s557 :: SWord64 = if s474 then s556 else s554+  s559 :: SWord64 = s557 | s558+  s560 :: SWord64 = if s468 then s559 else s557+  s562 :: SWord64 = s560 | s561+  s563 :: SWord64 = if s462 then s562 else s560+  s565 :: SWord64 = s563 | s564+  s566 :: SWord64 = if s454 then s565 else s563+  s568 :: SWord64 = s566 | s567+  s569 :: SWord64 = if s446 then s568 else s566+  s571 :: SWord64 = s569 | s570+  s572 :: SWord64 = if s438 then s571 else s569+  s574 :: SWord64 = s572 | s573+  s575 :: SWord64 = if s430 then s574 else s572+  s577 :: SWord64 = s575 | s576+  s578 :: SWord64 = if s428 then s577 else s575+  s580 :: SWord64 = s578 | s579+  s581 :: SWord64 = if s426 then s580 else s578+  s583 :: SWord64 = s581 | s582+  s584 :: SWord64 = if s424 then s583 else s581+  s586 :: SWord64 = s584 | s585+  s587 :: SWord64 = if s422 then s586 else s584+  s589 :: SWord64 = s587 | s588+  s590 :: SWord64 = if s420 then s589 else s587+  s592 :: SWord64 = s590 | s591+  s593 :: SWord64 = if s418 then s592 else s590+  s595 :: SWord64 = s593 | s594+  s596 :: SWord64 = if s416 then s595 else s593+  s598 :: SWord64 = s596 | s597+  s599 :: SWord64 = if s414 then s598 else s596+  s601 :: SWord64 = s599 | s600+  s602 :: SWord64 = if s412 then s601 else s599+  s604 :: SWord64 = s602 | s603+  s605 :: SWord64 = if s410 then s604 else s602+  s607 :: SWord64 = s605 | s606+  s608 :: SWord64 = if s408 then s607 else s605+  s610 :: SWord64 = s608 | s609+  s611 :: SWord64 = if s406 then s610 else s608+  s613 :: SWord64 = s611 | s612+  s614 :: SWord64 = if s404 then s613 else s611+  s616 :: SWord64 = s614 | s615+  s617 :: SWord64 = if s402 then s616 else s614+  s619 :: SWord64 = s617 | s618+  s620 :: SWord64 = if s400 then s619 else s617+  s622 :: SWord64 = s620 | s621+  s623 :: SWord64 = if s398 then s622 else s620+  s625 :: SWord64 = s623 | s624+  s626 :: SWord64 = if s396 then s625 else s623+  s628 :: SWord64 = s626 | s627+  s629 :: SWord64 = if s394 then s628 else s626+  s631 :: SWord64 = s629 | s630+  s632 :: SWord64 = if s392 then s631 else s629+  s634 :: SWord64 = s632 | s633+  s635 :: SWord64 = if s390 then s634 else s632+  s637 :: SWord64 = s635 | s636+  s638 :: SWord64 = if s388 then s637 else s635+  s640 :: SWord64 = s638 | s639+  s641 :: SWord64 = if s386 then s640 else s638+  s643 :: SWord64 = s641 | s642+  s644 :: SWord64 = if s384 then s643 else s641+  s646 :: SWord64 = s644 | s645+  s647 :: SWord64 = if s382 then s646 else s644+  s649 :: SWord64 = s647 | s648+  s650 :: SWord64 = if s380 then s649 else s647+  s652 :: SWord64 = s650 | s651+  s653 :: SWord64 = if s378 then s652 else s650+  s655 :: SWord64 = s653 | s654+  s656 :: SWord64 = if s376 then s655 else s653+  s658 :: SWord64 = s656 | s657+  s659 :: SWord64 = if s374 then s658 else s656+  s661 :: SWord64 = s659 | s660+  s662 :: SWord64 = if s372 then s661 else s659+  s664 :: SWord64 = s662 | s663+  s665 :: SWord64 = if s370 then s664 else s662+  s667 :: SWord64 = s665 | s666+  s668 :: SWord64 = if s368 then s667 else s665+  s670 :: SWord64 = s668 | s669+  s671 :: SWord64 = if s366 then s670 else s668+  s673 :: SWord64 = s671 | s672+  s674 :: SWord64 = if s364 then s673 else s671+  s676 :: SWord64 = s674 | s675+  s677 :: SWord64 = if s362 then s676 else s674+  s679 :: SWord64 = s677 | s678+  s680 :: SWord64 = if s360 then s679 else s677+  s682 :: SWord64 = s680 | s681+  s683 :: SWord64 = if s358 then s682 else s680+  s685 :: SWord64 = s683 | s684+  s686 :: SWord64 = if s356 then s685 else s683+  s688 :: SWord64 = s686 | s687+  s689 :: SWord64 = if s354 then s688 else s686+  s691 :: SWord64 = s689 | s690+  s692 :: SWord64 = if s352 then s691 else s689+  s694 :: SWord64 = s692 | s693+  s695 :: SWord64 = if s350 then s694 else s692+  s697 :: SWord64 = s695 | s696+  s698 :: SWord64 = if s348 then s697 else s695+  s700 :: SWord64 = s698 | s699+  s701 :: SWord64 = if s346 then s700 else s698+  s703 :: SWord64 = s701 | s702+  s704 :: SWord64 = if s344 then s703 else s701+  s706 :: SWord64 = s704 | s705+  s707 :: SWord64 = if s342 then s706 else s704+  s709 :: SWord64 = s707 | s708+  s710 :: SWord64 = if s340 then s709 else s707+  s712 :: SWord64 = s710 | s711+  s713 :: SWord64 = if s338 then s712 else s710+  s715 :: SWord64 = s713 | s714+  s716 :: SWord64 = if s336 then s715 else s713+  s717 :: SWord32 = choose [31:0] s716+  s718 :: SWord16 = choose [15:0] s717+  s719 :: SWord32 = s1 # s718+  s720 :: SWord64 = s0 # s719+  s721 :: SWord1 = choose [0:0] s720+  s722 :: SBool = s13 /= s721+  s723 :: SWord32 = s3 # s9+  s724 :: SWord64 = s2 # s723+  s725 :: SWord1 = choose [63:63] s724+  s726 :: SBool = s13 /= s725+  s727 :: SWord1 = choose [62:62] s724+  s728 :: SBool = s13 /= s727+  s729 :: SWord1 = choose [61:61] s724+  s730 :: SBool = s13 /= s729+  s731 :: SWord1 = choose [60:60] s724+  s732 :: SBool = s13 /= s731+  s733 :: SWord1 = choose [59:59] s724+  s734 :: SBool = s13 /= s733+  s735 :: SBool = ~ s734+  s736 :: SBool = if s726 then s735 else s734+  s737 :: SWord1 = choose [58:58] s724+  s738 :: SBool = s13 /= s737+  s739 :: SBool = ~ s738+  s740 :: SBool = if s728 then s739 else s738+  s741 :: SWord1 = choose [57:57] s724+  s742 :: SBool = s13 /= s741+  s743 :: SBool = ~ s742+  s744 :: SBool = if s730 then s743 else s742+  s745 :: SWord1 = choose [56:56] s724+  s746 :: SBool = s13 /= s745+  s747 :: SBool = ~ s746+  s748 :: SBool = if s732 then s747 else s746+  s749 :: SWord1 = choose [55:55] s724+  s750 :: SBool = s13 /= s749+  s751 :: SBool = ~ s750+  s752 :: SBool = if s736 then s751 else s750+  s753 :: SWord1 = choose [54:54] s724+  s754 :: SBool = s13 /= s753+  s755 :: SBool = ~ s754+  s756 :: SBool = if s740 then s755 else s754+  s757 :: SWord1 = choose [53:53] s724+  s758 :: SBool = s13 /= s757+  s759 :: SBool = ~ s758+  s760 :: SBool = if s744 then s759 else s758+  s761 :: SWord1 = choose [52:52] s724+  s762 :: SBool = s13 /= s761+  s763 :: SBool = ~ s762+  s764 :: SBool = if s726 then s763 else s762+  s765 :: SBool = ~ s764+  s766 :: SBool = if s748 then s765 else s764+  s767 :: SWord1 = choose [51:51] s724+  s768 :: SBool = s13 /= s767+  s769 :: SBool = ~ s768+  s770 :: SBool = if s728 then s769 else s768+  s771 :: SBool = ~ s770+  s772 :: SBool = if s752 then s771 else s770+  s773 :: SWord1 = choose [50:50] s724+  s774 :: SBool = s13 /= s773+  s775 :: SBool = ~ s774+  s776 :: SBool = if s730 then s775 else s774+  s777 :: SBool = ~ s776+  s778 :: SBool = if s756 then s777 else s776+  s779 :: SWord1 = choose [49:49] s724+  s780 :: SBool = s13 /= s779+  s781 :: SBool = ~ s780+  s782 :: SBool = if s732 then s781 else s780+  s783 :: SBool = ~ s782+  s784 :: SBool = if s760 then s783 else s782+  s785 :: SWord1 = choose [48:48] s724+  s786 :: SBool = s13 /= s785+  s787 :: SBool = ~ s786+  s788 :: SBool = if s736 then s787 else s786+  s789 :: SBool = ~ s788+  s790 :: SBool = if s766 then s789 else s788+  s791 :: SWord1 = choose [47:47] s724+  s792 :: SBool = s13 /= s791+  s793 :: SBool = ~ s792+  s794 :: SBool = if s726 then s793 else s792+  s795 :: SBool = ~ s794+  s796 :: SBool = if s740 then s795 else s794+  s797 :: SBool = ~ s796+  s798 :: SBool = if s772 then s797 else s796+  s799 :: SWord1 = choose [46:46] s724+  s800 :: SBool = s13 /= s799+  s801 :: SBool = ~ s800+  s802 :: SBool = if s728 then s801 else s800+  s803 :: SBool = ~ s802+  s804 :: SBool = if s744 then s803 else s802+  s805 :: SBool = ~ s804+  s806 :: SBool = if s778 then s805 else s804+  s807 :: SWord1 = choose [45:45] s724+  s808 :: SBool = s13 /= s807+  s809 :: SBool = ~ s808+  s810 :: SBool = if s730 then s809 else s808+  s811 :: SBool = ~ s810+  s812 :: SBool = if s748 then s811 else s810+  s813 :: SBool = ~ s812+  s814 :: SBool = if s784 then s813 else s812+  s815 :: SWord1 = choose [44:44] s724+  s816 :: SBool = s13 /= s815+  s817 :: SBool = ~ s816+  s818 :: SBool = if s732 then s817 else s816+  s819 :: SBool = ~ s818+  s820 :: SBool = if s752 then s819 else s818+  s821 :: SBool = ~ s820+  s822 :: SBool = if s790 then s821 else s820+  s823 :: SWord1 = choose [43:43] s724+  s824 :: SBool = s13 /= s823+  s825 :: SBool = ~ s824+  s826 :: SBool = if s736 then s825 else s824+  s827 :: SBool = ~ s826+  s828 :: SBool = if s756 then s827 else s826+  s829 :: SBool = ~ s828+  s830 :: SBool = if s798 then s829 else s828+  s831 :: SWord1 = choose [42:42] s724+  s832 :: SBool = s13 /= s831+  s833 :: SBool = ~ s832+  s834 :: SBool = if s740 then s833 else s832+  s835 :: SBool = ~ s834+  s836 :: SBool = if s760 then s835 else s834+  s837 :: SBool = ~ s836+  s838 :: SBool = if s806 then s837 else s836+  s839 :: SWord1 = choose [41:41] s724+  s840 :: SBool = s13 /= s839+  s841 :: SBool = ~ s840+  s842 :: SBool = if s744 then s841 else s840+  s843 :: SBool = ~ s842+  s844 :: SBool = if s766 then s843 else s842+  s845 :: SBool = ~ s844+  s846 :: SBool = if s814 then s845 else s844+  s847 :: SWord1 = choose [40:40] s724+  s848 :: SBool = s13 /= s847+  s849 :: SBool = ~ s848+  s850 :: SBool = if s748 then s849 else s848+  s851 :: SBool = ~ s850+  s852 :: SBool = if s772 then s851 else s850+  s853 :: SBool = ~ s852+  s854 :: SBool = if s822 then s853 else s852+  s855 :: SWord1 = choose [39:39] s724+  s856 :: SBool = s13 /= s855+  s857 :: SBool = ~ s856+  s858 :: SBool = if s752 then s857 else s856+  s859 :: SBool = ~ s858+  s860 :: SBool = if s778 then s859 else s858+  s861 :: SBool = ~ s860+  s862 :: SBool = if s830 then s861 else s860+  s863 :: SWord1 = choose [38:38] s724+  s864 :: SBool = s13 /= s863+  s865 :: SBool = ~ s864+  s866 :: SBool = if s756 then s865 else s864+  s867 :: SBool = ~ s866+  s868 :: SBool = if s784 then s867 else s866+  s869 :: SBool = ~ s868+  s870 :: SBool = if s838 then s869 else s868+  s871 :: SWord1 = choose [37:37] s724+  s872 :: SBool = s13 /= s871+  s873 :: SBool = ~ s872+  s874 :: SBool = if s760 then s873 else s872+  s875 :: SBool = ~ s874+  s876 :: SBool = if s790 then s875 else s874+  s877 :: SBool = ~ s876+  s878 :: SBool = if s846 then s877 else s876+  s879 :: SWord1 = choose [36:36] s724+  s880 :: SBool = s13 /= s879+  s881 :: SBool = ~ s880+  s882 :: SBool = if s766 then s881 else s880+  s883 :: SBool = ~ s882+  s884 :: SBool = if s798 then s883 else s882+  s885 :: SBool = ~ s884+  s886 :: SBool = if s854 then s885 else s884+  s887 :: SWord1 = choose [35:35] s724+  s888 :: SBool = s13 /= s887+  s889 :: SBool = ~ s888+  s890 :: SBool = if s772 then s889 else s888+  s891 :: SBool = ~ s890+  s892 :: SBool = if s806 then s891 else s890+  s893 :: SBool = ~ s892+  s894 :: SBool = if s862 then s893 else s892+  s895 :: SWord1 = choose [34:34] s724+  s896 :: SBool = s13 /= s895+  s897 :: SBool = ~ s896+  s898 :: SBool = if s778 then s897 else s896+  s899 :: SBool = ~ s898+  s900 :: SBool = if s814 then s899 else s898+  s901 :: SBool = ~ s900+  s902 :: SBool = if s870 then s901 else s900+  s903 :: SWord1 = choose [33:33] s724+  s904 :: SBool = s13 /= s903+  s905 :: SBool = ~ s904+  s906 :: SBool = if s784 then s905 else s904+  s907 :: SBool = ~ s906+  s908 :: SBool = if s822 then s907 else s906+  s909 :: SBool = ~ s908+  s910 :: SBool = if s878 then s909 else s908+  s911 :: SWord1 = choose [32:32] s724+  s912 :: SBool = s13 /= s911+  s913 :: SBool = ~ s912+  s914 :: SBool = if s790 then s913 else s912+  s915 :: SBool = ~ s914+  s916 :: SBool = if s830 then s915 else s914+  s917 :: SBool = ~ s916+  s918 :: SBool = if s886 then s917 else s916+  s919 :: SWord1 = choose [31:31] s724+  s920 :: SBool = s13 /= s919+  s921 :: SBool = ~ s920+  s922 :: SBool = if s798 then s921 else s920+  s923 :: SBool = ~ s922+  s924 :: SBool = if s838 then s923 else s922+  s925 :: SBool = ~ s924+  s926 :: SBool = if s894 then s925 else s924+  s927 :: SWord1 = choose [30:30] s724+  s928 :: SBool = s13 /= s927+  s929 :: SBool = ~ s928+  s930 :: SBool = if s806 then s929 else s928+  s931 :: SBool = ~ s930+  s932 :: SBool = if s846 then s931 else s930+  s933 :: SBool = ~ s932+  s934 :: SBool = if s902 then s933 else s932+  s935 :: SWord1 = choose [29:29] s724+  s936 :: SBool = s13 /= s935+  s937 :: SBool = ~ s936+  s938 :: SBool = if s814 then s937 else s936+  s939 :: SBool = ~ s938+  s940 :: SBool = if s854 then s939 else s938+  s941 :: SBool = ~ s940+  s942 :: SBool = if s910 then s941 else s940+  s943 :: SWord1 = choose [28:28] s724+  s944 :: SBool = s13 /= s943+  s945 :: SBool = ~ s944+  s946 :: SBool = if s822 then s945 else s944+  s947 :: SBool = ~ s946+  s948 :: SBool = if s862 then s947 else s946+  s949 :: SBool = ~ s948+  s950 :: SBool = if s918 then s949 else s948+  s951 :: SWord1 = choose [27:27] s724+  s952 :: SBool = s13 /= s951+  s953 :: SBool = ~ s952+  s954 :: SBool = if s830 then s953 else s952+  s955 :: SBool = ~ s954+  s956 :: SBool = if s870 then s955 else s954+  s957 :: SBool = ~ s956+  s958 :: SBool = if s926 then s957 else s956+  s959 :: SWord1 = choose [26:26] s724+  s960 :: SBool = s13 /= s959+  s961 :: SBool = ~ s960+  s962 :: SBool = if s838 then s961 else s960+  s963 :: SBool = ~ s962+  s964 :: SBool = if s878 then s963 else s962+  s965 :: SBool = ~ s964+  s966 :: SBool = if s934 then s965 else s964+  s967 :: SWord1 = choose [25:25] s724+  s968 :: SBool = s13 /= s967+  s969 :: SBool = ~ s968+  s970 :: SBool = if s846 then s969 else s968+  s971 :: SBool = ~ s970+  s972 :: SBool = if s886 then s971 else s970+  s973 :: SBool = ~ s972+  s974 :: SBool = if s942 then s973 else s972+  s975 :: SWord1 = choose [24:24] s724+  s976 :: SBool = s13 /= s975+  s977 :: SBool = ~ s976+  s978 :: SBool = if s854 then s977 else s976+  s979 :: SBool = ~ s978+  s980 :: SBool = if s894 then s979 else s978+  s981 :: SBool = ~ s980+  s982 :: SBool = if s950 then s981 else s980+  s983 :: SWord1 = choose [23:23] s724+  s984 :: SBool = s13 /= s983+  s985 :: SBool = ~ s984+  s986 :: SBool = if s862 then s985 else s984+  s987 :: SBool = ~ s986+  s988 :: SBool = if s902 then s987 else s986+  s989 :: SBool = ~ s988+  s990 :: SBool = if s958 then s989 else s988+  s991 :: SWord1 = choose [22:22] s724+  s992 :: SBool = s13 /= s991+  s993 :: SBool = ~ s992+  s994 :: SBool = if s870 then s993 else s992+  s995 :: SBool = ~ s994+  s996 :: SBool = if s910 then s995 else s994+  s997 :: SBool = ~ s996+  s998 :: SBool = if s966 then s997 else s996+  s999 :: SWord1 = choose [21:21] s724+  s1000 :: SBool = s13 /= s999+  s1001 :: SBool = ~ s1000+  s1002 :: SBool = if s878 then s1001 else s1000+  s1003 :: SBool = ~ s1002+  s1004 :: SBool = if s918 then s1003 else s1002+  s1005 :: SBool = ~ s1004+  s1006 :: SBool = if s974 then s1005 else s1004+  s1007 :: SWord1 = choose [20:20] s724+  s1008 :: SBool = s13 /= s1007+  s1009 :: SBool = ~ s1008+  s1010 :: SBool = if s886 then s1009 else s1008+  s1011 :: SBool = ~ s1010+  s1012 :: SBool = if s926 then s1011 else s1010+  s1013 :: SBool = ~ s1012+  s1014 :: SBool = if s982 then s1013 else s1012+  s1015 :: SWord1 = choose [19:19] s724+  s1016 :: SBool = s13 /= s1015+  s1017 :: SBool = ~ s1016+  s1018 :: SBool = if s894 then s1017 else s1016+  s1019 :: SBool = ~ s1018+  s1020 :: SBool = if s934 then s1019 else s1018+  s1021 :: SBool = ~ s1020+  s1022 :: SBool = if s990 then s1021 else s1020+  s1023 :: SWord1 = choose [18:18] s724+  s1024 :: SBool = s13 /= s1023+  s1025 :: SBool = ~ s1024+  s1026 :: SBool = if s902 then s1025 else s1024+  s1027 :: SBool = ~ s1026+  s1028 :: SBool = if s942 then s1027 else s1026+  s1029 :: SBool = ~ s1028+  s1030 :: SBool = if s998 then s1029 else s1028+  s1031 :: SWord1 = choose [17:17] s724+  s1032 :: SBool = s13 /= s1031+  s1033 :: SBool = ~ s1032+  s1034 :: SBool = if s910 then s1033 else s1032+  s1035 :: SBool = ~ s1034+  s1036 :: SBool = if s950 then s1035 else s1034+  s1037 :: SBool = ~ s1036+  s1038 :: SBool = if s1006 then s1037 else s1036+  s1039 :: SWord1 = choose [16:16] s724+  s1040 :: SBool = s13 /= s1039+  s1041 :: SBool = ~ s1040+  s1042 :: SBool = if s918 then s1041 else s1040+  s1043 :: SBool = ~ s1042+  s1044 :: SBool = if s958 then s1043 else s1042+  s1045 :: SBool = ~ s1044+  s1046 :: SBool = if s1014 then s1045 else s1044+  s1047 :: SBool = ~ s726+  s1048 :: SBool = if s726 then s1047 else s726+  s1049 :: SBool = ~ s728+  s1050 :: SBool = if s728 then s1049 else s728+  s1051 :: SBool = ~ s730+  s1052 :: SBool = if s730 then s1051 else s730+  s1053 :: SBool = ~ s732+  s1054 :: SBool = if s732 then s1053 else s732+  s1055 :: SBool = ~ s736+  s1056 :: SBool = if s736 then s1055 else s736+  s1057 :: SBool = ~ s740+  s1058 :: SBool = if s740 then s1057 else s740+  s1059 :: SBool = ~ s744+  s1060 :: SBool = if s744 then s1059 else s744+  s1061 :: SBool = ~ s748+  s1062 :: SBool = if s748 then s1061 else s748+  s1063 :: SBool = ~ s752+  s1064 :: SBool = if s752 then s1063 else s752+  s1065 :: SBool = ~ s756+  s1066 :: SBool = if s756 then s1065 else s756+  s1067 :: SBool = ~ s760+  s1068 :: SBool = if s760 then s1067 else s760+  s1069 :: SBool = ~ s766+  s1070 :: SBool = if s766 then s1069 else s766+  s1071 :: SBool = ~ s772+  s1072 :: SBool = if s772 then s1071 else s772+  s1073 :: SBool = ~ s778+  s1074 :: SBool = if s778 then s1073 else s778+  s1075 :: SBool = ~ s784+  s1076 :: SBool = if s784 then s1075 else s784+  s1077 :: SBool = ~ s790+  s1078 :: SBool = if s790 then s1077 else s790+  s1079 :: SBool = ~ s798+  s1080 :: SBool = if s798 then s1079 else s798+  s1081 :: SBool = ~ s806+  s1082 :: SBool = if s806 then s1081 else s806+  s1083 :: SBool = ~ s814+  s1084 :: SBool = if s814 then s1083 else s814+  s1085 :: SBool = ~ s822+  s1086 :: SBool = if s822 then s1085 else s822+  s1087 :: SBool = ~ s830+  s1088 :: SBool = if s830 then s1087 else s830+  s1089 :: SBool = ~ s838+  s1090 :: SBool = if s838 then s1089 else s838+  s1091 :: SBool = ~ s846+  s1092 :: SBool = if s846 then s1091 else s846+  s1093 :: SBool = ~ s854+  s1094 :: SBool = if s854 then s1093 else s854+  s1095 :: SBool = ~ s862+  s1096 :: SBool = if s862 then s1095 else s862+  s1097 :: SBool = ~ s870+  s1098 :: SBool = if s870 then s1097 else s870+  s1099 :: SBool = ~ s878+  s1100 :: SBool = if s878 then s1099 else s878+  s1101 :: SBool = ~ s886+  s1102 :: SBool = if s886 then s1101 else s886+  s1103 :: SBool = ~ s894+  s1104 :: SBool = if s894 then s1103 else s894+  s1105 :: SBool = ~ s902+  s1106 :: SBool = if s902 then s1105 else s902+  s1107 :: SBool = ~ s910+  s1108 :: SBool = if s910 then s1107 else s910+  s1109 :: SBool = ~ s918+  s1110 :: SBool = if s918 then s1109 else s918+  s1111 :: SBool = ~ s926+  s1112 :: SBool = if s926 then s1111 else s926+  s1113 :: SBool = ~ s934+  s1114 :: SBool = if s934 then s1113 else s934+  s1115 :: SBool = ~ s942+  s1116 :: SBool = if s942 then s1115 else s942+  s1117 :: SBool = ~ s950+  s1118 :: SBool = if s950 then s1117 else s950+  s1119 :: SBool = ~ s958+  s1120 :: SBool = if s958 then s1119 else s958+  s1121 :: SBool = ~ s966+  s1122 :: SBool = if s966 then s1121 else s966+  s1123 :: SBool = ~ s974+  s1124 :: SBool = if s974 then s1123 else s974+  s1125 :: SBool = ~ s982+  s1126 :: SBool = if s982 then s1125 else s982+  s1127 :: SBool = ~ s990+  s1128 :: SBool = if s990 then s1127 else s990+  s1129 :: SBool = ~ s998+  s1130 :: SBool = if s998 then s1129 else s998+  s1131 :: SBool = ~ s1006+  s1132 :: SBool = if s1006 then s1131 else s1006+  s1133 :: SBool = ~ s1014+  s1134 :: SBool = if s1014 then s1133 else s1014+  s1135 :: SBool = ~ s1022+  s1136 :: SBool = if s1022 then s1135 else s1022+  s1137 :: SBool = ~ s1030+  s1138 :: SBool = if s1030 then s1137 else s1030+  s1139 :: SBool = ~ s1038+  s1140 :: SBool = if s1038 then s1139 else s1038+  s1141 :: SBool = ~ s1046+  s1142 :: SBool = if s1046 then s1141 else s1046+  s1143 :: SWord1 = choose [15:15] s724+  s1144 :: SBool = s13 /= s1143+  s1145 :: SBool = ~ s1144+  s1146 :: SBool = if s926 then s1145 else s1144+  s1147 :: SBool = ~ s1146+  s1148 :: SBool = if s966 then s1147 else s1146+  s1149 :: SBool = ~ s1148+  s1150 :: SBool = if s1022 then s1149 else s1148+  s1151 :: SWord1 = choose [14:14] s724+  s1152 :: SBool = s13 /= s1151+  s1153 :: SBool = ~ s1152+  s1154 :: SBool = if s934 then s1153 else s1152+  s1155 :: SBool = ~ s1154+  s1156 :: SBool = if s974 then s1155 else s1154+  s1157 :: SBool = ~ s1156+  s1158 :: SBool = if s1030 then s1157 else s1156+  s1159 :: SWord1 = choose [13:13] s724+  s1160 :: SBool = s13 /= s1159+  s1161 :: SBool = ~ s1160+  s1162 :: SBool = if s942 then s1161 else s1160+  s1163 :: SBool = ~ s1162+  s1164 :: SBool = if s982 then s1163 else s1162+  s1165 :: SBool = ~ s1164+  s1166 :: SBool = if s1038 then s1165 else s1164+  s1167 :: SWord1 = choose [12:12] s724+  s1168 :: SBool = s13 /= s1167+  s1169 :: SBool = ~ s1168+  s1170 :: SBool = if s950 then s1169 else s1168+  s1171 :: SBool = ~ s1170+  s1172 :: SBool = if s990 then s1171 else s1170+  s1173 :: SBool = ~ s1172+  s1174 :: SBool = if s1046 then s1173 else s1172+  s1175 :: SWord1 = choose [11:11] s724+  s1176 :: SBool = s13 /= s1175+  s1177 :: SBool = ~ s1176+  s1178 :: SBool = if s958 then s1177 else s1176+  s1179 :: SBool = ~ s1178+  s1180 :: SBool = if s998 then s1179 else s1178+  s1181 :: SWord1 = choose [10:10] s724+  s1182 :: SBool = s13 /= s1181+  s1183 :: SBool = ~ s1182+  s1184 :: SBool = if s966 then s1183 else s1182+  s1185 :: SBool = ~ s1184+  s1186 :: SBool = if s1006 then s1185 else s1184+  s1187 :: SWord1 = choose [9:9] s724+  s1188 :: SBool = s13 /= s1187+  s1189 :: SBool = ~ s1188+  s1190 :: SBool = if s974 then s1189 else s1188+  s1191 :: SBool = ~ s1190+  s1192 :: SBool = if s1014 then s1191 else s1190+  s1193 :: SWord1 = choose [8:8] s724+  s1194 :: SBool = s13 /= s1193+  s1195 :: SBool = ~ s1194+  s1196 :: SBool = if s982 then s1195 else s1194+  s1197 :: SBool = ~ s1196+  s1198 :: SBool = if s1022 then s1197 else s1196+  s1199 :: SWord1 = choose [7:7] s724+  s1200 :: SBool = s13 /= s1199+  s1201 :: SBool = ~ s1200+  s1202 :: SBool = if s990 then s1201 else s1200+  s1203 :: SBool = ~ s1202+  s1204 :: SBool = if s1030 then s1203 else s1202+  s1205 :: SWord1 = choose [6:6] s724+  s1206 :: SBool = s13 /= s1205+  s1207 :: SBool = ~ s1206+  s1208 :: SBool = if s998 then s1207 else s1206+  s1209 :: SBool = ~ s1208+  s1210 :: SBool = if s1038 then s1209 else s1208+  s1211 :: SWord1 = choose [5:5] s724+  s1212 :: SBool = s13 /= s1211+  s1213 :: SBool = ~ s1212+  s1214 :: SBool = if s1006 then s1213 else s1212+  s1215 :: SBool = ~ s1214+  s1216 :: SBool = if s1046 then s1215 else s1214+  s1217 :: SWord1 = choose [4:4] s724+  s1218 :: SBool = s13 /= s1217+  s1219 :: SBool = ~ s1218+  s1220 :: SBool = if s1014 then s1219 else s1218+  s1221 :: SWord1 = choose [3:3] s724+  s1222 :: SBool = s13 /= s1221+  s1223 :: SBool = ~ s1222+  s1224 :: SBool = if s1022 then s1223 else s1222+  s1225 :: SWord1 = choose [2:2] s724+  s1226 :: SBool = s13 /= s1225+  s1227 :: SBool = ~ s1226+  s1228 :: SBool = if s1030 then s1227 else s1226+  s1229 :: SWord1 = choose [1:1] s724+  s1230 :: SBool = s13 /= s1229+  s1231 :: SBool = ~ s1230+  s1232 :: SBool = if s1038 then s1231 else s1230+  s1233 :: SWord1 = choose [0:0] s724+  s1234 :: SBool = s13 /= s1233+  s1235 :: SBool = ~ s1234+  s1236 :: SBool = if s1046 then s1235 else s1234+  s1237 :: SWord64 = if s1236 then s525 else s526+  s1238 :: SWord64 = s528 | s1237+  s1239 :: SWord64 = if s1232 then s1238 else s1237+  s1240 :: SWord64 = s531 | s1239+  s1241 :: SWord64 = if s1228 then s1240 else s1239+  s1242 :: SWord64 = s534 | s1241+  s1243 :: SWord64 = if s1224 then s1242 else s1241+  s1244 :: SWord64 = s537 | s1243+  s1245 :: SWord64 = if s1220 then s1244 else s1243+  s1246 :: SWord64 = s540 | s1245+  s1247 :: SWord64 = if s1216 then s1246 else s1245+  s1248 :: SWord64 = s543 | s1247+  s1249 :: SWord64 = if s1210 then s1248 else s1247+  s1250 :: SWord64 = s546 | s1249+  s1251 :: SWord64 = if s1204 then s1250 else s1249+  s1252 :: SWord64 = s549 | s1251+  s1253 :: SWord64 = if s1198 then s1252 else s1251+  s1254 :: SWord64 = s552 | s1253+  s1255 :: SWord64 = if s1192 then s1254 else s1253+  s1256 :: SWord64 = s555 | s1255+  s1257 :: SWord64 = if s1186 then s1256 else s1255+  s1258 :: SWord64 = s558 | s1257+  s1259 :: SWord64 = if s1180 then s1258 else s1257+  s1260 :: SWord64 = s561 | s1259+  s1261 :: SWord64 = if s1174 then s1260 else s1259+  s1262 :: SWord64 = s564 | s1261+  s1263 :: SWord64 = if s1166 then s1262 else s1261+  s1264 :: SWord64 = s567 | s1263+  s1265 :: SWord64 = if s1158 then s1264 else s1263+  s1266 :: SWord64 = s570 | s1265+  s1267 :: SWord64 = if s1150 then s1266 else s1265+  s1268 :: SWord64 = s573 | s1267+  s1269 :: SWord64 = if s1142 then s1268 else s1267+  s1270 :: SWord64 = s576 | s1269+  s1271 :: SWord64 = if s1140 then s1270 else s1269+  s1272 :: SWord64 = s579 | s1271+  s1273 :: SWord64 = if s1138 then s1272 else s1271+  s1274 :: SWord64 = s582 | s1273+  s1275 :: SWord64 = if s1136 then s1274 else s1273+  s1276 :: SWord64 = s585 | s1275+  s1277 :: SWord64 = if s1134 then s1276 else s1275+  s1278 :: SWord64 = s588 | s1277+  s1279 :: SWord64 = if s1132 then s1278 else s1277+  s1280 :: SWord64 = s591 | s1279+  s1281 :: SWord64 = if s1130 then s1280 else s1279+  s1282 :: SWord64 = s594 | s1281+  s1283 :: SWord64 = if s1128 then s1282 else s1281+  s1284 :: SWord64 = s597 | s1283+  s1285 :: SWord64 = if s1126 then s1284 else s1283+  s1286 :: SWord64 = s600 | s1285+  s1287 :: SWord64 = if s1124 then s1286 else s1285+  s1288 :: SWord64 = s603 | s1287+  s1289 :: SWord64 = if s1122 then s1288 else s1287+  s1290 :: SWord64 = s606 | s1289+  s1291 :: SWord64 = if s1120 then s1290 else s1289+  s1292 :: SWord64 = s609 | s1291+  s1293 :: SWord64 = if s1118 then s1292 else s1291+  s1294 :: SWord64 = s612 | s1293+  s1295 :: SWord64 = if s1116 then s1294 else s1293+  s1296 :: SWord64 = s615 | s1295+  s1297 :: SWord64 = if s1114 then s1296 else s1295+  s1298 :: SWord64 = s618 | s1297+  s1299 :: SWord64 = if s1112 then s1298 else s1297+  s1300 :: SWord64 = s621 | s1299+  s1301 :: SWord64 = if s1110 then s1300 else s1299+  s1302 :: SWord64 = s624 | s1301+  s1303 :: SWord64 = if s1108 then s1302 else s1301+  s1304 :: SWord64 = s627 | s1303+  s1305 :: SWord64 = if s1106 then s1304 else s1303+  s1306 :: SWord64 = s630 | s1305+  s1307 :: SWord64 = if s1104 then s1306 else s1305+  s1308 :: SWord64 = s633 | s1307+  s1309 :: SWord64 = if s1102 then s1308 else s1307+  s1310 :: SWord64 = s636 | s1309+  s1311 :: SWord64 = if s1100 then s1310 else s1309+  s1312 :: SWord64 = s639 | s1311+  s1313 :: SWord64 = if s1098 then s1312 else s1311+  s1314 :: SWord64 = s642 | s1313+  s1315 :: SWord64 = if s1096 then s1314 else s1313+  s1316 :: SWord64 = s645 | s1315+  s1317 :: SWord64 = if s1094 then s1316 else s1315+  s1318 :: SWord64 = s648 | s1317+  s1319 :: SWord64 = if s1092 then s1318 else s1317+  s1320 :: SWord64 = s651 | s1319+  s1321 :: SWord64 = if s1090 then s1320 else s1319+  s1322 :: SWord64 = s654 | s1321+  s1323 :: SWord64 = if s1088 then s1322 else s1321+  s1324 :: SWord64 = s657 | s1323+  s1325 :: SWord64 = if s1086 then s1324 else s1323+  s1326 :: SWord64 = s660 | s1325+  s1327 :: SWord64 = if s1084 then s1326 else s1325+  s1328 :: SWord64 = s663 | s1327+  s1329 :: SWord64 = if s1082 then s1328 else s1327+  s1330 :: SWord64 = s666 | s1329+  s1331 :: SWord64 = if s1080 then s1330 else s1329+  s1332 :: SWord64 = s669 | s1331+  s1333 :: SWord64 = if s1078 then s1332 else s1331+  s1334 :: SWord64 = s672 | s1333+  s1335 :: SWord64 = if s1076 then s1334 else s1333+  s1336 :: SWord64 = s675 | s1335+  s1337 :: SWord64 = if s1074 then s1336 else s1335+  s1338 :: SWord64 = s678 | s1337+  s1339 :: SWord64 = if s1072 then s1338 else s1337+  s1340 :: SWord64 = s681 | s1339+  s1341 :: SWord64 = if s1070 then s1340 else s1339+  s1342 :: SWord64 = s684 | s1341+  s1343 :: SWord64 = if s1068 then s1342 else s1341+  s1344 :: SWord64 = s687 | s1343+  s1345 :: SWord64 = if s1066 then s1344 else s1343+  s1346 :: SWord64 = s690 | s1345+  s1347 :: SWord64 = if s1064 then s1346 else s1345+  s1348 :: SWord64 = s693 | s1347+  s1349 :: SWord64 = if s1062 then s1348 else s1347+  s1350 :: SWord64 = s696 | s1349+  s1351 :: SWord64 = if s1060 then s1350 else s1349+  s1352 :: SWord64 = s699 | s1351+  s1353 :: SWord64 = if s1058 then s1352 else s1351+  s1354 :: SWord64 = s702 | s1353+  s1355 :: SWord64 = if s1056 then s1354 else s1353+  s1356 :: SWord64 = s705 | s1355+  s1357 :: SWord64 = if s1054 then s1356 else s1355+  s1358 :: SWord64 = s708 | s1357+  s1359 :: SWord64 = if s1052 then s1358 else s1357+  s1360 :: SWord64 = s711 | s1359+  s1361 :: SWord64 = if s1050 then s1360 else s1359+  s1362 :: SWord64 = s714 | s1361+  s1363 :: SWord64 = if s1048 then s1362 else s1361+  s1364 :: SWord32 = choose [31:0] s1363+  s1365 :: SWord16 = choose [15:0] s1364+  s1366 :: SWord32 = s3 # s1365+  s1367 :: SWord64 = s2 # s1366+  s1368 :: SWord1 = choose [0:0] s1367+  s1369 :: SBool = s13 /= s1368+  s1370 :: SBool = s722 == s1369+  s1371 :: SWord1 = choose [1:1] s720+  s1372 :: SBool = s13 /= s1371+  s1373 :: SWord1 = choose [1:1] s1367+  s1374 :: SBool = s13 /= s1373+  s1375 :: SBool = s1372 == s1374+  s1376 :: SWord1 = choose [2:2] s720+  s1377 :: SBool = s13 /= s1376+  s1378 :: SWord1 = choose [2:2] s1367+  s1379 :: SBool = s13 /= s1378+  s1380 :: SBool = s1377 == s1379+  s1381 :: SWord1 = choose [3:3] s720+  s1382 :: SBool = s13 /= s1381+  s1383 :: SWord1 = choose [3:3] s1367+  s1384 :: SBool = s13 /= s1383+  s1385 :: SBool = s1382 == s1384+  s1386 :: SWord1 = choose [4:4] s720+  s1387 :: SBool = s13 /= s1386+  s1388 :: SWord1 = choose [4:4] s1367+  s1389 :: SBool = s13 /= s1388+  s1390 :: SBool = s1387 == s1389+  s1391 :: SWord1 = choose [5:5] s720+  s1392 :: SBool = s13 /= s1391+  s1393 :: SWord1 = choose [5:5] s1367+  s1394 :: SBool = s13 /= s1393+  s1395 :: SBool = s1392 == s1394+  s1396 :: SWord1 = choose [6:6] s720+  s1397 :: SBool = s13 /= s1396+  s1398 :: SWord1 = choose [6:6] s1367+  s1399 :: SBool = s13 /= s1398+  s1400 :: SBool = s1397 == s1399+  s1401 :: SWord1 = choose [7:7] s720+  s1402 :: SBool = s13 /= s1401+  s1403 :: SWord1 = choose [7:7] s1367+  s1404 :: SBool = s13 /= s1403+  s1405 :: SBool = s1402 == s1404+  s1406 :: SWord1 = choose [8:8] s720+  s1407 :: SBool = s13 /= s1406+  s1408 :: SWord1 = choose [8:8] s1367+  s1409 :: SBool = s13 /= s1408+  s1410 :: SBool = s1407 == s1409+  s1411 :: SWord1 = choose [9:9] s720+  s1412 :: SBool = s13 /= s1411+  s1413 :: SWord1 = choose [9:9] s1367+  s1414 :: SBool = s13 /= s1413+  s1415 :: SBool = s1412 == s1414+  s1416 :: SWord1 = choose [10:10] s720+  s1417 :: SBool = s13 /= s1416+  s1418 :: SWord1 = choose [10:10] s1367+  s1419 :: SBool = s13 /= s1418+  s1420 :: SBool = s1417 == s1419+  s1421 :: SWord1 = choose [11:11] s720+  s1422 :: SBool = s13 /= s1421+  s1423 :: SWord1 = choose [11:11] s1367+  s1424 :: SBool = s13 /= s1423+  s1425 :: SBool = s1422 == s1424+  s1426 :: SWord1 = choose [12:12] s720+  s1427 :: SBool = s13 /= s1426+  s1428 :: SWord1 = choose [12:12] s1367+  s1429 :: SBool = s13 /= s1428+  s1430 :: SBool = s1427 == s1429+  s1431 :: SWord1 = choose [13:13] s720+  s1432 :: SBool = s13 /= s1431+  s1433 :: SWord1 = choose [13:13] s1367+  s1434 :: SBool = s13 /= s1433+  s1435 :: SBool = s1432 == s1434+  s1436 :: SWord1 = choose [14:14] s720+  s1437 :: SBool = s13 /= s1436+  s1438 :: SWord1 = choose [14:14] s1367+  s1439 :: SBool = s13 /= s1438+  s1440 :: SBool = s1437 == s1439+  s1441 :: SWord1 = choose [15:15] s720+  s1442 :: SBool = s13 /= s1441+  s1443 :: SWord1 = choose [15:15] s1367+  s1444 :: SBool = s13 /= s1443+  s1445 :: SBool = s1442 == s1444+  s1446 :: SWord1 = choose [16:16] s720+  s1447 :: SBool = s13 /= s1446+  s1448 :: SWord1 = choose [16:16] s1367+  s1449 :: SBool = s13 /= s1448+  s1450 :: SBool = s1447 == s1449+  s1451 :: SWord1 = choose [17:17] s720+  s1452 :: SBool = s13 /= s1451+  s1453 :: SWord1 = choose [17:17] s1367+  s1454 :: SBool = s13 /= s1453+  s1455 :: SBool = s1452 == s1454+  s1456 :: SWord1 = choose [18:18] s720+  s1457 :: SBool = s13 /= s1456+  s1458 :: SWord1 = choose [18:18] s1367+  s1459 :: SBool = s13 /= s1458+  s1460 :: SBool = s1457 == s1459+  s1461 :: SWord1 = choose [19:19] s720+  s1462 :: SBool = s13 /= s1461+  s1463 :: SWord1 = choose [19:19] s1367+  s1464 :: SBool = s13 /= s1463+  s1465 :: SBool = s1462 == s1464+  s1466 :: SWord1 = choose [20:20] s720+  s1467 :: SBool = s13 /= s1466+  s1468 :: SWord1 = choose [20:20] s1367+  s1469 :: SBool = s13 /= s1468+  s1470 :: SBool = s1467 == s1469+  s1471 :: SWord1 = choose [21:21] s720+  s1472 :: SBool = s13 /= s1471+  s1473 :: SWord1 = choose [21:21] s1367+  s1474 :: SBool = s13 /= s1473+  s1475 :: SBool = s1472 == s1474+  s1476 :: SWord1 = choose [22:22] s720+  s1477 :: SBool = s13 /= s1476+  s1478 :: SWord1 = choose [22:22] s1367+  s1479 :: SBool = s13 /= s1478+  s1480 :: SBool = s1477 == s1479+  s1481 :: SWord1 = choose [23:23] s720+  s1482 :: SBool = s13 /= s1481+  s1483 :: SWord1 = choose [23:23] s1367+  s1484 :: SBool = s13 /= s1483+  s1485 :: SBool = s1482 == s1484+  s1486 :: SWord1 = choose [24:24] s720+  s1487 :: SBool = s13 /= s1486+  s1488 :: SWord1 = choose [24:24] s1367+  s1489 :: SBool = s13 /= s1488+  s1490 :: SBool = s1487 == s1489+  s1491 :: SWord1 = choose [25:25] s720+  s1492 :: SBool = s13 /= s1491+  s1493 :: SWord1 = choose [25:25] s1367+  s1494 :: SBool = s13 /= s1493+  s1495 :: SBool = s1492 == s1494+  s1496 :: SWord1 = choose [26:26] s720+  s1497 :: SBool = s13 /= s1496+  s1498 :: SWord1 = choose [26:26] s1367+  s1499 :: SBool = s13 /= s1498+  s1500 :: SBool = s1497 == s1499+  s1501 :: SWord1 = choose [27:27] s720+  s1502 :: SBool = s13 /= s1501+  s1503 :: SWord1 = choose [27:27] s1367+  s1504 :: SBool = s13 /= s1503+  s1505 :: SBool = s1502 == s1504+  s1506 :: SWord1 = choose [28:28] s720+  s1507 :: SBool = s13 /= s1506+  s1508 :: SWord1 = choose [28:28] s1367+  s1509 :: SBool = s13 /= s1508+  s1510 :: SBool = s1507 == s1509+  s1511 :: SWord1 = choose [29:29] s720+  s1512 :: SBool = s13 /= s1511+  s1513 :: SWord1 = choose [29:29] s1367+  s1514 :: SBool = s13 /= s1513+  s1515 :: SBool = s1512 == s1514+  s1516 :: SWord1 = choose [30:30] s720+  s1517 :: SBool = s13 /= s1516+  s1518 :: SWord1 = choose [30:30] s1367+  s1519 :: SBool = s13 /= s1518+  s1520 :: SBool = s1517 == s1519+  s1521 :: SWord1 = choose [31:31] s720+  s1522 :: SBool = s13 /= s1521+  s1523 :: SWord1 = choose [31:31] s1367+  s1524 :: SBool = s13 /= s1523+  s1525 :: SBool = s1522 == s1524+  s1526 :: SWord1 = choose [32:32] s720+  s1527 :: SBool = s13 /= s1526+  s1528 :: SWord1 = choose [32:32] s1367+  s1529 :: SBool = s13 /= s1528+  s1530 :: SBool = s1527 == s1529+  s1531 :: SWord1 = choose [33:33] s720+  s1532 :: SBool = s13 /= s1531+  s1533 :: SWord1 = choose [33:33] s1367+  s1534 :: SBool = s13 /= s1533+  s1535 :: SBool = s1532 == s1534+  s1536 :: SWord1 = choose [34:34] s720+  s1537 :: SBool = s13 /= s1536+  s1538 :: SWord1 = choose [34:34] s1367+  s1539 :: SBool = s13 /= s1538+  s1540 :: SBool = s1537 == s1539+  s1541 :: SWord1 = choose [35:35] s720+  s1542 :: SBool = s13 /= s1541+  s1543 :: SWord1 = choose [35:35] s1367+  s1544 :: SBool = s13 /= s1543+  s1545 :: SBool = s1542 == s1544+  s1546 :: SWord1 = choose [36:36] s720+  s1547 :: SBool = s13 /= s1546+  s1548 :: SWord1 = choose [36:36] s1367+  s1549 :: SBool = s13 /= s1548+  s1550 :: SBool = s1547 == s1549+  s1551 :: SWord1 = choose [37:37] s720+  s1552 :: SBool = s13 /= s1551+  s1553 :: SWord1 = choose [37:37] s1367+  s1554 :: SBool = s13 /= s1553+  s1555 :: SBool = s1552 == s1554+  s1556 :: SWord1 = choose [38:38] s720+  s1557 :: SBool = s13 /= s1556+  s1558 :: SWord1 = choose [38:38] s1367+  s1559 :: SBool = s13 /= s1558+  s1560 :: SBool = s1557 == s1559+  s1561 :: SWord1 = choose [39:39] s720+  s1562 :: SBool = s13 /= s1561+  s1563 :: SWord1 = choose [39:39] s1367+  s1564 :: SBool = s13 /= s1563+  s1565 :: SBool = s1562 == s1564+  s1566 :: SWord1 = choose [40:40] s720+  s1567 :: SBool = s13 /= s1566+  s1568 :: SWord1 = choose [40:40] s1367+  s1569 :: SBool = s13 /= s1568+  s1570 :: SBool = s1567 == s1569+  s1571 :: SWord1 = choose [41:41] s720+  s1572 :: SBool = s13 /= s1571+  s1573 :: SWord1 = choose [41:41] s1367+  s1574 :: SBool = s13 /= s1573+  s1575 :: SBool = s1572 == s1574+  s1576 :: SWord1 = choose [42:42] s720+  s1577 :: SBool = s13 /= s1576+  s1578 :: SWord1 = choose [42:42] s1367+  s1579 :: SBool = s13 /= s1578+  s1580 :: SBool = s1577 == s1579+  s1581 :: SWord1 = choose [43:43] s720+  s1582 :: SBool = s13 /= s1581+  s1583 :: SWord1 = choose [43:43] s1367+  s1584 :: SBool = s13 /= s1583+  s1585 :: SBool = s1582 == s1584+  s1586 :: SWord1 = choose [44:44] s720+  s1587 :: SBool = s13 /= s1586+  s1588 :: SWord1 = choose [44:44] s1367+  s1589 :: SBool = s13 /= s1588+  s1590 :: SBool = s1587 == s1589+  s1591 :: SWord1 = choose [45:45] s720+  s1592 :: SBool = s13 /= s1591+  s1593 :: SWord1 = choose [45:45] s1367+  s1594 :: SBool = s13 /= s1593+  s1595 :: SBool = s1592 == s1594+  s1596 :: SWord1 = choose [46:46] s720+  s1597 :: SBool = s13 /= s1596+  s1598 :: SWord1 = choose [46:46] s1367+  s1599 :: SBool = s13 /= s1598+  s1600 :: SBool = s1597 == s1599+  s1601 :: SWord1 = choose [47:47] s720+  s1602 :: SBool = s13 /= s1601+  s1603 :: SWord1 = choose [47:47] s1367+  s1604 :: SBool = s13 /= s1603+  s1605 :: SBool = s1602 == s1604+  s1606 :: SWord1 = choose [48:48] s720+  s1607 :: SBool = s13 /= s1606+  s1608 :: SWord1 = choose [48:48] s1367+  s1609 :: SBool = s13 /= s1608+  s1610 :: SBool = s1607 == s1609+  s1611 :: SWord1 = choose [49:49] s720+  s1612 :: SBool = s13 /= s1611+  s1613 :: SWord1 = choose [49:49] s1367+  s1614 :: SBool = s13 /= s1613+  s1615 :: SBool = s1612 == s1614+  s1616 :: SWord1 = choose [50:50] s720+  s1617 :: SBool = s13 /= s1616+  s1618 :: SWord1 = choose [50:50] s1367+  s1619 :: SBool = s13 /= s1618+  s1620 :: SBool = s1617 == s1619+  s1621 :: SWord1 = choose [51:51] s720+  s1622 :: SBool = s13 /= s1621+  s1623 :: SWord1 = choose [51:51] s1367+  s1624 :: SBool = s13 /= s1623+  s1625 :: SBool = s1622 == s1624+  s1626 :: SWord1 = choose [52:52] s720+  s1627 :: SBool = s13 /= s1626+  s1628 :: SWord1 = choose [52:52] s1367+  s1629 :: SBool = s13 /= s1628+  s1630 :: SBool = s1627 == s1629+  s1631 :: SWord1 = choose [53:53] s720+  s1632 :: SBool = s13 /= s1631+  s1633 :: SWord1 = choose [53:53] s1367+  s1634 :: SBool = s13 /= s1633+  s1635 :: SBool = s1632 == s1634+  s1636 :: SWord1 = choose [54:54] s720+  s1637 :: SBool = s13 /= s1636+  s1638 :: SWord1 = choose [54:54] s1367+  s1639 :: SBool = s13 /= s1638+  s1640 :: SBool = s1637 == s1639+  s1641 :: SWord1 = choose [55:55] s720+  s1642 :: SBool = s13 /= s1641+  s1643 :: SWord1 = choose [55:55] s1367+  s1644 :: SBool = s13 /= s1643+  s1645 :: SBool = s1642 == s1644+  s1646 :: SWord1 = choose [56:56] s720+  s1647 :: SBool = s13 /= s1646+  s1648 :: SWord1 = choose [56:56] s1367+  s1649 :: SBool = s13 /= s1648+  s1650 :: SBool = s1647 == s1649+  s1651 :: SWord1 = choose [57:57] s720+  s1652 :: SBool = s13 /= s1651+  s1653 :: SWord1 = choose [57:57] s1367+  s1654 :: SBool = s13 /= s1653+  s1655 :: SBool = s1652 == s1654+  s1656 :: SWord1 = choose [58:58] s720+  s1657 :: SBool = s13 /= s1656+  s1658 :: SWord1 = choose [58:58] s1367+  s1659 :: SBool = s13 /= s1658+  s1660 :: SBool = s1657 == s1659+  s1661 :: SWord1 = choose [59:59] s720+  s1662 :: SBool = s13 /= s1661+  s1663 :: SWord1 = choose [59:59] s1367+  s1664 :: SBool = s13 /= s1663+  s1665 :: SBool = s1662 == s1664+  s1666 :: SWord1 = choose [60:60] s720+  s1667 :: SBool = s13 /= s1666+  s1668 :: SWord1 = choose [60:60] s1367+  s1669 :: SBool = s13 /= s1668+  s1670 :: SBool = s1667 == s1669+  s1671 :: SWord1 = choose [61:61] s720+  s1672 :: SBool = s13 /= s1671+  s1673 :: SWord1 = choose [61:61] s1367+  s1674 :: SBool = s13 /= s1673+  s1675 :: SBool = s1672 == s1674+  s1676 :: SWord1 = choose [62:62] s720+  s1677 :: SBool = s13 /= s1676+  s1678 :: SWord1 = choose [62:62] s1367+  s1679 :: SBool = s13 /= s1678+  s1680 :: SBool = s1677 == s1679+  s1681 :: SWord1 = choose [63:63] s720+  s1682 :: SBool = s13 /= s1681+  s1683 :: SWord1 = choose [63:63] s1367+  s1684 :: SBool = s13 /= s1683+  s1685 :: SBool = s1682 == s1684+  s1688 :: SWord8 = if s1685 then s1686 else s1687+  s1689 :: SWord8 = s1687 + s1688+  s1690 :: SWord8 = if s1680 then s1688 else s1689+  s1691 :: SWord8 = s1687 + s1690+  s1692 :: SWord8 = if s1675 then s1690 else s1691+  s1693 :: SWord8 = s1687 + s1692+  s1694 :: SWord8 = if s1670 then s1692 else s1693+  s1695 :: SWord8 = s1687 + s1694+  s1696 :: SWord8 = if s1665 then s1694 else s1695+  s1697 :: SWord8 = s1687 + s1696+  s1698 :: SWord8 = if s1660 then s1696 else s1697+  s1699 :: SWord8 = s1687 + s1698+  s1700 :: SWord8 = if s1655 then s1698 else s1699+  s1701 :: SWord8 = s1687 + s1700+  s1702 :: SWord8 = if s1650 then s1700 else s1701+  s1703 :: SWord8 = s1687 + s1702+  s1704 :: SWord8 = if s1645 then s1702 else s1703+  s1705 :: SWord8 = s1687 + s1704+  s1706 :: SWord8 = if s1640 then s1704 else s1705+  s1707 :: SWord8 = s1687 + s1706+  s1708 :: SWord8 = if s1635 then s1706 else s1707+  s1709 :: SWord8 = s1687 + s1708+  s1710 :: SWord8 = if s1630 then s1708 else s1709+  s1711 :: SWord8 = s1687 + s1710+  s1712 :: SWord8 = if s1625 then s1710 else s1711+  s1713 :: SWord8 = s1687 + s1712+  s1714 :: SWord8 = if s1620 then s1712 else s1713+  s1715 :: SWord8 = s1687 + s1714+  s1716 :: SWord8 = if s1615 then s1714 else s1715+  s1717 :: SWord8 = s1687 + s1716+  s1718 :: SWord8 = if s1610 then s1716 else s1717+  s1719 :: SWord8 = s1687 + s1718+  s1720 :: SWord8 = if s1605 then s1718 else s1719+  s1721 :: SWord8 = s1687 + s1720+  s1722 :: SWord8 = if s1600 then s1720 else s1721+  s1723 :: SWord8 = s1687 + s1722+  s1724 :: SWord8 = if s1595 then s1722 else s1723+  s1725 :: SWord8 = s1687 + s1724+  s1726 :: SWord8 = if s1590 then s1724 else s1725+  s1727 :: SWord8 = s1687 + s1726+  s1728 :: SWord8 = if s1585 then s1726 else s1727+  s1729 :: SWord8 = s1687 + s1728+  s1730 :: SWord8 = if s1580 then s1728 else s1729+  s1731 :: SWord8 = s1687 + s1730+  s1732 :: SWord8 = if s1575 then s1730 else s1731+  s1733 :: SWord8 = s1687 + s1732+  s1734 :: SWord8 = if s1570 then s1732 else s1733+  s1735 :: SWord8 = s1687 + s1734+  s1736 :: SWord8 = if s1565 then s1734 else s1735+  s1737 :: SWord8 = s1687 + s1736+  s1738 :: SWord8 = if s1560 then s1736 else s1737+  s1739 :: SWord8 = s1687 + s1738+  s1740 :: SWord8 = if s1555 then s1738 else s1739+  s1741 :: SWord8 = s1687 + s1740+  s1742 :: SWord8 = if s1550 then s1740 else s1741+  s1743 :: SWord8 = s1687 + s1742+  s1744 :: SWord8 = if s1545 then s1742 else s1743+  s1745 :: SWord8 = s1687 + s1744+  s1746 :: SWord8 = if s1540 then s1744 else s1745+  s1747 :: SWord8 = s1687 + s1746+  s1748 :: SWord8 = if s1535 then s1746 else s1747+  s1749 :: SWord8 = s1687 + s1748+  s1750 :: SWord8 = if s1530 then s1748 else s1749+  s1751 :: SWord8 = s1687 + s1750+  s1752 :: SWord8 = if s1525 then s1750 else s1751+  s1753 :: SWord8 = s1687 + s1752+  s1754 :: SWord8 = if s1520 then s1752 else s1753+  s1755 :: SWord8 = s1687 + s1754+  s1756 :: SWord8 = if s1515 then s1754 else s1755+  s1757 :: SWord8 = s1687 + s1756+  s1758 :: SWord8 = if s1510 then s1756 else s1757+  s1759 :: SWord8 = s1687 + s1758+  s1760 :: SWord8 = if s1505 then s1758 else s1759+  s1761 :: SWord8 = s1687 + s1760+  s1762 :: SWord8 = if s1500 then s1760 else s1761+  s1763 :: SWord8 = s1687 + s1762+  s1764 :: SWord8 = if s1495 then s1762 else s1763+  s1765 :: SWord8 = s1687 + s1764+  s1766 :: SWord8 = if s1490 then s1764 else s1765+  s1767 :: SWord8 = s1687 + s1766+  s1768 :: SWord8 = if s1485 then s1766 else s1767+  s1769 :: SWord8 = s1687 + s1768+  s1770 :: SWord8 = if s1480 then s1768 else s1769+  s1771 :: SWord8 = s1687 + s1770+  s1772 :: SWord8 = if s1475 then s1770 else s1771+  s1773 :: SWord8 = s1687 + s1772+  s1774 :: SWord8 = if s1470 then s1772 else s1773+  s1775 :: SWord8 = s1687 + s1774+  s1776 :: SWord8 = if s1465 then s1774 else s1775+  s1777 :: SWord8 = s1687 + s1776+  s1778 :: SWord8 = if s1460 then s1776 else s1777+  s1779 :: SWord8 = s1687 + s1778+  s1780 :: SWord8 = if s1455 then s1778 else s1779+  s1781 :: SWord8 = s1687 + s1780+  s1782 :: SWord8 = if s1450 then s1780 else s1781+  s1783 :: SWord8 = s1687 + s1782+  s1784 :: SWord8 = if s1445 then s1782 else s1783+  s1785 :: SWord8 = s1687 + s1784+  s1786 :: SWord8 = if s1440 then s1784 else s1785+  s1787 :: SWord8 = s1687 + s1786+  s1788 :: SWord8 = if s1435 then s1786 else s1787+  s1789 :: SWord8 = s1687 + s1788+  s1790 :: SWord8 = if s1430 then s1788 else s1789+  s1791 :: SWord8 = s1687 + s1790+  s1792 :: SWord8 = if s1425 then s1790 else s1791+  s1793 :: SWord8 = s1687 + s1792+  s1794 :: SWord8 = if s1420 then s1792 else s1793+  s1795 :: SWord8 = s1687 + s1794+  s1796 :: SWord8 = if s1415 then s1794 else s1795+  s1797 :: SWord8 = s1687 + s1796+  s1798 :: SWord8 = if s1410 then s1796 else s1797+  s1799 :: SWord8 = s1687 + s1798+  s1800 :: SWord8 = if s1405 then s1798 else s1799+  s1801 :: SWord8 = s1687 + s1800+  s1802 :: SWord8 = if s1400 then s1800 else s1801+  s1803 :: SWord8 = s1687 + s1802+  s1804 :: SWord8 = if s1395 then s1802 else s1803+  s1805 :: SWord8 = s1687 + s1804+  s1806 :: SWord8 = if s1390 then s1804 else s1805+  s1807 :: SWord8 = s1687 + s1806+  s1808 :: SWord8 = if s1385 then s1806 else s1807+  s1809 :: SWord8 = s1687 + s1808+  s1810 :: SWord8 = if s1380 then s1808 else s1809+  s1811 :: SWord8 = s1687 + s1810+  s1812 :: SWord8 = if s1375 then s1810 else s1811+  s1813 :: SWord8 = s1687 + s1812+  s1814 :: SWord8 = if s1370 then s1812 else s1813+  s1816 :: SBool = s1814 > s1815+  s1817 :: SBool = s8 | s1816+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s1817
+ SBVTestSuite/GoldFiles/cgUninterpret.gold view
@@ -0,0 +1,114 @@+== BEGIN: "Makefile" ================+# Makefile for tstShiftLeft. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: tstShiftLeft_driver++tstShiftLeft.o: tstShiftLeft.c tstShiftLeft.h+	${CC} ${CCFLAGS} -c $< -o $@++tstShiftLeft_driver.o: tstShiftLeft_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++tstShiftLeft_driver: tstShiftLeft.o tstShiftLeft_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f tstShiftLeft_driver+== END: "Makefile" ==================+== BEGIN: "tstShiftLeft.h" ================+/* Header file for tstShiftLeft. Automatically generated by SBV. Do not edit! */++#ifndef __tstShiftLeft__HEADER_INCLUDED__+#define __tstShiftLeft__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+SWord32 tstShiftLeft(const SWord32 *vs);++#endif /* __tstShiftLeft__HEADER_INCLUDED__ */+== END: "tstShiftLeft.h" ==================+== BEGIN: "tstShiftLeft_driver.c" ================+/* Example driver program for tstShiftLeft. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "tstShiftLeft.h"++int main(void)+{+  const SWord32 vs[3] = {+      0x00000001UL, 0x00000002UL, 0x00000003UL+  };++  printf("Contents of input array vs:\n");+  int vs_ctr;+  for(vs_ctr = 0; vs_ctr < 3 ; ++vs_ctr)+    printf("  vs[%d] = 0x%08"PRIx32"UL\n", vs_ctr ,vs[vs_ctr]);+++  const SWord32 __result = tstShiftLeft(vs);++  printf("tstShiftLeft(vs) = 0x%08"PRIx32"UL\n", __result);++  return 0;+}+== END: "tstShiftLeft_driver.c" ==================+== BEGIN: "tstShiftLeft.c" ================+/* File: "tstShiftLeft.c". Automatically generated by SBV. Do not edit! */++#include "tstShiftLeft.h"++/* User specified custom code for "SBV_SHIFTLEFT" */+#define SBV_SHIFTLEFT(x, y) ((x) << (y))++SWord32 tstShiftLeft(const SWord32 *vs)+{+  const SWord32 s0 = vs[0];+  const SWord32 s1 = vs[1];+  const SWord32 s2 = vs[2];+  const SWord32 s3 = /* Uninterpreted function */ SBV_SHIFTLEFT(s0,+                                                                s2);+  const SWord32 s4 = /* Uninterpreted function */ SBV_SHIFTLEFT(s1,+                                                                s2);+  const SWord32 s5 = s3 + s4;++  return s5;+}+== END: "tstShiftLeft.c" ==================
+ SBVTestSuite/GoldFiles/codeGen1.gold view
@@ -0,0 +1,230 @@+== BEGIN: "Makefile" ================+# Makefile for foo. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: foo_driver++foo.o: foo.c foo.h+	${CC} ${CCFLAGS} -c $< -o $@++foo_driver.o: foo_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++foo_driver: foo.o foo_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f foo_driver+== END: "Makefile" ==================+== BEGIN: "foo.h" ================+/* Header file for foo. Automatically generated by SBV. Do not edit! */++#ifndef __foo__HEADER_INCLUDED__+#define __foo__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+SInt16 foo(const SInt16 x, const SInt64 *xArr, SWord16 *z,+           SInt16 *zArr, SInt64 *yArr);++#endif /* __foo__HEADER_INCLUDED__ */+== END: "foo.h" ==================+== BEGIN: "foo_driver.c" ================+/* Example driver program for foo. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "foo.h"++int main(void)+{+  const SInt64 xArr[45] = {+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,+      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL+  };++  printf("Contents of input array xArr:\n");+  int xArr_ctr;+  for(xArr_ctr = 0; xArr_ctr < 45 ; ++xArr_ctr)+    printf("  xArr[%d] = %"PRId64"LL\n", xArr_ctr ,xArr[xArr_ctr]);++  SWord16 z;+  SInt16 zArr[7];+  SInt64 yArr[45];++  const SInt16 __result = foo(0x0000, xArr, &z, zArr, yArr);++  printf("foo(0x0000, xArr, &z, zArr, yArr) = %"PRId16"\n", __result);+  printf("  z = 0x%04"PRIx16"U\n", z);+  int zArr_ctr;+  for(zArr_ctr = 0; zArr_ctr < 7 ; ++zArr_ctr)+    printf("  zArr[%d] = %"PRId16"\n", zArr_ctr ,zArr[zArr_ctr]);+  int yArr_ctr;+  for(yArr_ctr = 0; yArr_ctr < 45 ; ++yArr_ctr)+    printf("  yArr[%d] = %"PRId64"LL\n", yArr_ctr ,yArr[yArr_ctr]);++  return 0;+}+== END: "foo_driver.c" ==================+== BEGIN: "foo.c" ================+/* File: "foo.c". Automatically generated by SBV. Do not edit! */++#include "foo.h"++SInt16 foo(const SInt16 x, const SInt64 *xArr, SWord16 *z,+           SInt16 *zArr, SInt64 *yArr)+{+  const SInt16 s0 = x;+  const SInt64 s1 = xArr[0];+  const SInt64 s2 = xArr[1];+  const SInt64 s3 = xArr[2];+  const SInt64 s4 = xArr[3];+  const SInt64 s5 = xArr[4];+  const SInt64 s6 = xArr[5];+  const SInt64 s7 = xArr[6];+  const SInt64 s8 = xArr[7];+  const SInt64 s9 = xArr[8];+  const SInt64 s10 = xArr[9];+  const SInt64 s11 = xArr[10];+  const SInt64 s12 = xArr[11];+  const SInt64 s13 = xArr[12];+  const SInt64 s14 = xArr[13];+  const SInt64 s15 = xArr[14];+  const SInt64 s16 = xArr[15];+  const SInt64 s17 = xArr[16];+  const SInt64 s18 = xArr[17];+  const SInt64 s19 = xArr[18];+  const SInt64 s20 = xArr[19];+  const SInt64 s21 = xArr[20];+  const SInt64 s22 = xArr[21];+  const SInt64 s23 = xArr[22];+  const SInt64 s24 = xArr[23];+  const SInt64 s25 = xArr[24];+  const SInt64 s26 = xArr[25];+  const SInt64 s27 = xArr[26];+  const SInt64 s28 = xArr[27];+  const SInt64 s29 = xArr[28];+  const SInt64 s30 = xArr[29];+  const SInt64 s31 = xArr[30];+  const SInt64 s32 = xArr[31];+  const SInt64 s33 = xArr[32];+  const SInt64 s34 = xArr[33];+  const SInt64 s35 = xArr[34];+  const SInt64 s36 = xArr[35];+  const SInt64 s37 = xArr[36];+  const SInt64 s38 = xArr[37];+  const SInt64 s39 = xArr[38];+  const SInt64 s40 = xArr[39];+  const SInt64 s41 = xArr[40];+  const SInt64 s42 = xArr[41];+  const SInt64 s43 = xArr[42];+  const SInt64 s44 = xArr[43];+  const SInt64 s45 = xArr[44];+  const SInt16 s48 = s0 + 0x0001;+  const SInt16 s50 = s0 * 0x0002;++  *z = 0x0005U;+  zArr[0] = s48;+  zArr[1] = s48;+  zArr[2] = s48;+  zArr[3] = s48;+  zArr[4] = s48;+  zArr[5] = s48;+  zArr[6] = s48;+  yArr[0] = s1;+  yArr[1] = s2;+  yArr[2] = s3;+  yArr[3] = s4;+  yArr[4] = s5;+  yArr[5] = s6;+  yArr[6] = s7;+  yArr[7] = s8;+  yArr[8] = s9;+  yArr[9] = s10;+  yArr[10] = s11;+  yArr[11] = s12;+  yArr[12] = s13;+  yArr[13] = s14;+  yArr[14] = s15;+  yArr[15] = s16;+  yArr[16] = s17;+  yArr[17] = s18;+  yArr[18] = s19;+  yArr[19] = s20;+  yArr[20] = s21;+  yArr[21] = s22;+  yArr[22] = s23;+  yArr[23] = s24;+  yArr[24] = s25;+  yArr[25] = s26;+  yArr[26] = s27;+  yArr[27] = s28;+  yArr[28] = s29;+  yArr[29] = s30;+  yArr[30] = s31;+  yArr[31] = s32;+  yArr[32] = s33;+  yArr[33] = s34;+  yArr[34] = s35;+  yArr[35] = s36;+  yArr[36] = s37;+  yArr[37] = s38;+  yArr[38] = s39;+  yArr[39] = s40;+  yArr[40] = s41;+  yArr[41] = s42;+  yArr[42] = s43;+  yArr[43] = s44;+  yArr[44] = s45;+  return s50;+}+== END: "foo.c" ==================
+ SBVTestSuite/GoldFiles/coins.gold view
@@ -0,0 +1,916 @@+INPUTS+  s0 :: SWord16, existential, aliasing "c1"+  s18 :: SWord16, existential, aliasing "c2"+  s30 :: SWord16, existential, aliasing "c3"+  s42 :: SWord16, existential, aliasing "c4"+  s54 :: SWord16, existential, aliasing "c5"+  s66 :: SWord16, existential, aliasing "c6"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s1 = 1 :: Word16+  s3 = 5 :: Word16+  s5 = 10 :: Word16+  s7 = 25 :: Word16+  s9 = 50 :: Word16+  s11 = 100 :: Word16+  s84 = 0 :: Word16+  s88 = 95 :: Word16+  s551 = 115 :: Word16+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s2 :: SBool = s0 == s1+  s4 :: SBool = s0 == s3+  s6 :: SBool = s0 == s5+  s8 :: SBool = s0 == s7+  s10 :: SBool = s0 == s9+  s12 :: SBool = s0 == s11+  s13 :: SBool = s10 | s12+  s14 :: SBool = s8 | s13+  s15 :: SBool = s6 | s14+  s16 :: SBool = s4 | s15+  s17 :: SBool = s2 | s16+  s19 :: SBool = s1 == s18+  s20 :: SBool = s3 == s18+  s21 :: SBool = s5 == s18+  s22 :: SBool = s7 == s18+  s23 :: SBool = s9 == s18+  s24 :: SBool = s11 == s18+  s25 :: SBool = s23 | s24+  s26 :: SBool = s22 | s25+  s27 :: SBool = s21 | s26+  s28 :: SBool = s20 | s27+  s29 :: SBool = s19 | s28+  s31 :: SBool = s1 == s30+  s32 :: SBool = s3 == s30+  s33 :: SBool = s5 == s30+  s34 :: SBool = s7 == s30+  s35 :: SBool = s9 == s30+  s36 :: SBool = s11 == s30+  s37 :: SBool = s35 | s36+  s38 :: SBool = s34 | s37+  s39 :: SBool = s33 | s38+  s40 :: SBool = s32 | s39+  s41 :: SBool = s31 | s40+  s43 :: SBool = s1 == s42+  s44 :: SBool = s3 == s42+  s45 :: SBool = s5 == s42+  s46 :: SBool = s7 == s42+  s47 :: SBool = s9 == s42+  s48 :: SBool = s11 == s42+  s49 :: SBool = s47 | s48+  s50 :: SBool = s46 | s49+  s51 :: SBool = s45 | s50+  s52 :: SBool = s44 | s51+  s53 :: SBool = s43 | s52+  s55 :: SBool = s1 == s54+  s56 :: SBool = s3 == s54+  s57 :: SBool = s5 == s54+  s58 :: SBool = s7 == s54+  s59 :: SBool = s9 == s54+  s60 :: SBool = s11 == s54+  s61 :: SBool = s59 | s60+  s62 :: SBool = s58 | s61+  s63 :: SBool = s57 | s62+  s64 :: SBool = s56 | s63+  s65 :: SBool = s55 | s64+  s67 :: SBool = s1 == s66+  s68 :: SBool = s3 == s66+  s69 :: SBool = s5 == s66+  s70 :: SBool = s7 == s66+  s71 :: SBool = s9 == s66+  s72 :: SBool = s11 == s66+  s73 :: SBool = s71 | s72+  s74 :: SBool = s70 | s73+  s75 :: SBool = s69 | s74+  s76 :: SBool = s68 | s75+  s77 :: SBool = s67 | s76+  s78 :: SWord16 = s0 + s18+  s79 :: SBool = s11 /= s78+  s80 :: SBool = s9 /= s78+  s81 :: SBool = s7 /= s78+  s82 :: SBool = s5 /= s78+  s83 :: SBool = s3 /= s78+  s85 :: SWord16 = if s10 then s84 else s0+  s86 :: SWord16 = if s23 then s84 else s18+  s87 :: SWord16 = s85 + s86+  s89 :: SBool = s87 /= s88+  s90 :: SWord16 = s0 + s30+  s91 :: SBool = s11 /= s90+  s92 :: SBool = s9 /= s90+  s93 :: SBool = s7 /= s90+  s94 :: SBool = s5 /= s90+  s95 :: SBool = s3 /= s90+  s96 :: SWord16 = if s35 then s84 else s30+  s97 :: SWord16 = s85 + s96+  s98 :: SBool = s88 /= s97+  s99 :: SWord16 = s0 + s42+  s100 :: SBool = s11 /= s99+  s101 :: SBool = s9 /= s99+  s102 :: SBool = s7 /= s99+  s103 :: SBool = s5 /= s99+  s104 :: SBool = s3 /= s99+  s105 :: SWord16 = if s47 then s84 else s42+  s106 :: SWord16 = s85 + s105+  s107 :: SBool = s88 /= s106+  s108 :: SWord16 = s0 + s54+  s109 :: SBool = s11 /= s108+  s110 :: SBool = s9 /= s108+  s111 :: SBool = s7 /= s108+  s112 :: SBool = s5 /= s108+  s113 :: SBool = s3 /= s108+  s114 :: SWord16 = if s59 then s84 else s54+  s115 :: SWord16 = s85 + s114+  s116 :: SBool = s88 /= s115+  s117 :: SWord16 = s0 + s66+  s118 :: SBool = s11 /= s117+  s119 :: SBool = s9 /= s117+  s120 :: SBool = s7 /= s117+  s121 :: SBool = s5 /= s117+  s122 :: SBool = s3 /= s117+  s123 :: SWord16 = if s71 then s84 else s66+  s124 :: SWord16 = s85 + s123+  s125 :: SBool = s88 /= s124+  s126 :: SWord16 = s18 + s30+  s127 :: SBool = s11 /= s126+  s128 :: SBool = s9 /= s126+  s129 :: SBool = s7 /= s126+  s130 :: SBool = s5 /= s126+  s131 :: SBool = s3 /= s126+  s132 :: SWord16 = s86 + s96+  s133 :: SBool = s88 /= s132+  s134 :: SWord16 = s18 + s42+  s135 :: SBool = s11 /= s134+  s136 :: SBool = s9 /= s134+  s137 :: SBool = s7 /= s134+  s138 :: SBool = s5 /= s134+  s139 :: SBool = s3 /= s134+  s140 :: SWord16 = s86 + s105+  s141 :: SBool = s88 /= s140+  s142 :: SWord16 = s18 + s54+  s143 :: SBool = s11 /= s142+  s144 :: SBool = s9 /= s142+  s145 :: SBool = s7 /= s142+  s146 :: SBool = s5 /= s142+  s147 :: SBool = s3 /= s142+  s148 :: SWord16 = s86 + s114+  s149 :: SBool = s88 /= s148+  s150 :: SWord16 = s18 + s66+  s151 :: SBool = s11 /= s150+  s152 :: SBool = s9 /= s150+  s153 :: SBool = s7 /= s150+  s154 :: SBool = s5 /= s150+  s155 :: SBool = s3 /= s150+  s156 :: SWord16 = s86 + s123+  s157 :: SBool = s88 /= s156+  s158 :: SWord16 = s30 + s42+  s159 :: SBool = s11 /= s158+  s160 :: SBool = s9 /= s158+  s161 :: SBool = s7 /= s158+  s162 :: SBool = s5 /= s158+  s163 :: SBool = s3 /= s158+  s164 :: SWord16 = s96 + s105+  s165 :: SBool = s88 /= s164+  s166 :: SWord16 = s30 + s54+  s167 :: SBool = s11 /= s166+  s168 :: SBool = s9 /= s166+  s169 :: SBool = s7 /= s166+  s170 :: SBool = s5 /= s166+  s171 :: SBool = s3 /= s166+  s172 :: SWord16 = s96 + s114+  s173 :: SBool = s88 /= s172+  s174 :: SWord16 = s30 + s66+  s175 :: SBool = s11 /= s174+  s176 :: SBool = s9 /= s174+  s177 :: SBool = s7 /= s174+  s178 :: SBool = s5 /= s174+  s179 :: SBool = s3 /= s174+  s180 :: SWord16 = s96 + s123+  s181 :: SBool = s88 /= s180+  s182 :: SWord16 = s42 + s54+  s183 :: SBool = s11 /= s182+  s184 :: SBool = s9 /= s182+  s185 :: SBool = s7 /= s182+  s186 :: SBool = s5 /= s182+  s187 :: SBool = s3 /= s182+  s188 :: SWord16 = s105 + s114+  s189 :: SBool = s88 /= s188+  s190 :: SWord16 = s42 + s66+  s191 :: SBool = s11 /= s190+  s192 :: SBool = s9 /= s190+  s193 :: SBool = s7 /= s190+  s194 :: SBool = s5 /= s190+  s195 :: SBool = s3 /= s190+  s196 :: SWord16 = s105 + s123+  s197 :: SBool = s88 /= s196+  s198 :: SWord16 = s54 + s66+  s199 :: SBool = s11 /= s198+  s200 :: SBool = s9 /= s198+  s201 :: SBool = s7 /= s198+  s202 :: SBool = s5 /= s198+  s203 :: SBool = s3 /= s198+  s204 :: SWord16 = s114 + s123+  s205 :: SBool = s88 /= s204+  s206 :: SWord16 = s30 + s78+  s207 :: SBool = s11 /= s206+  s208 :: SBool = s9 /= s206+  s209 :: SBool = s7 /= s206+  s210 :: SBool = s5 /= s206+  s211 :: SBool = s3 /= s206+  s212 :: SWord16 = s87 + s96+  s213 :: SBool = s88 /= s212+  s214 :: SWord16 = s42 + s78+  s215 :: SBool = s11 /= s214+  s216 :: SBool = s9 /= s214+  s217 :: SBool = s7 /= s214+  s218 :: SBool = s5 /= s214+  s219 :: SBool = s3 /= s214+  s220 :: SWord16 = s87 + s105+  s221 :: SBool = s88 /= s220+  s222 :: SWord16 = s54 + s78+  s223 :: SBool = s11 /= s222+  s224 :: SBool = s9 /= s222+  s225 :: SBool = s7 /= s222+  s226 :: SBool = s5 /= s222+  s227 :: SBool = s3 /= s222+  s228 :: SWord16 = s87 + s114+  s229 :: SBool = s88 /= s228+  s230 :: SWord16 = s66 + s78+  s231 :: SBool = s11 /= s230+  s232 :: SBool = s9 /= s230+  s233 :: SBool = s7 /= s230+  s234 :: SBool = s5 /= s230+  s235 :: SBool = s3 /= s230+  s236 :: SWord16 = s87 + s123+  s237 :: SBool = s88 /= s236+  s238 :: SWord16 = s42 + s90+  s239 :: SBool = s11 /= s238+  s240 :: SBool = s9 /= s238+  s241 :: SBool = s7 /= s238+  s242 :: SBool = s5 /= s238+  s243 :: SBool = s3 /= s238+  s244 :: SWord16 = s97 + s105+  s245 :: SBool = s88 /= s244+  s246 :: SWord16 = s54 + s90+  s247 :: SBool = s11 /= s246+  s248 :: SBool = s9 /= s246+  s249 :: SBool = s7 /= s246+  s250 :: SBool = s5 /= s246+  s251 :: SBool = s3 /= s246+  s252 :: SWord16 = s97 + s114+  s253 :: SBool = s88 /= s252+  s254 :: SWord16 = s66 + s90+  s255 :: SBool = s11 /= s254+  s256 :: SBool = s9 /= s254+  s257 :: SBool = s7 /= s254+  s258 :: SBool = s5 /= s254+  s259 :: SBool = s3 /= s254+  s260 :: SWord16 = s97 + s123+  s261 :: SBool = s88 /= s260+  s262 :: SWord16 = s54 + s99+  s263 :: SBool = s11 /= s262+  s264 :: SBool = s9 /= s262+  s265 :: SBool = s7 /= s262+  s266 :: SBool = s5 /= s262+  s267 :: SBool = s3 /= s262+  s268 :: SWord16 = s106 + s114+  s269 :: SBool = s88 /= s268+  s270 :: SWord16 = s66 + s99+  s271 :: SBool = s11 /= s270+  s272 :: SBool = s9 /= s270+  s273 :: SBool = s7 /= s270+  s274 :: SBool = s5 /= s270+  s275 :: SBool = s3 /= s270+  s276 :: SWord16 = s106 + s123+  s277 :: SBool = s88 /= s276+  s278 :: SWord16 = s66 + s108+  s279 :: SBool = s11 /= s278+  s280 :: SBool = s9 /= s278+  s281 :: SBool = s7 /= s278+  s282 :: SBool = s5 /= s278+  s283 :: SBool = s3 /= s278+  s284 :: SWord16 = s115 + s123+  s285 :: SBool = s88 /= s284+  s286 :: SWord16 = s42 + s126+  s287 :: SBool = s11 /= s286+  s288 :: SBool = s9 /= s286+  s289 :: SBool = s7 /= s286+  s290 :: SBool = s5 /= s286+  s291 :: SBool = s3 /= s286+  s292 :: SWord16 = s105 + s132+  s293 :: SBool = s88 /= s292+  s294 :: SWord16 = s54 + s126+  s295 :: SBool = s11 /= s294+  s296 :: SBool = s9 /= s294+  s297 :: SBool = s7 /= s294+  s298 :: SBool = s5 /= s294+  s299 :: SBool = s3 /= s294+  s300 :: SWord16 = s114 + s132+  s301 :: SBool = s88 /= s300+  s302 :: SWord16 = s66 + s126+  s303 :: SBool = s11 /= s302+  s304 :: SBool = s9 /= s302+  s305 :: SBool = s7 /= s302+  s306 :: SBool = s5 /= s302+  s307 :: SBool = s3 /= s302+  s308 :: SWord16 = s123 + s132+  s309 :: SBool = s88 /= s308+  s310 :: SWord16 = s54 + s134+  s311 :: SBool = s11 /= s310+  s312 :: SBool = s9 /= s310+  s313 :: SBool = s7 /= s310+  s314 :: SBool = s5 /= s310+  s315 :: SBool = s3 /= s310+  s316 :: SWord16 = s114 + s140+  s317 :: SBool = s88 /= s316+  s318 :: SWord16 = s66 + s134+  s319 :: SBool = s11 /= s318+  s320 :: SBool = s9 /= s318+  s321 :: SBool = s7 /= s318+  s322 :: SBool = s5 /= s318+  s323 :: SBool = s3 /= s318+  s324 :: SWord16 = s123 + s140+  s325 :: SBool = s88 /= s324+  s326 :: SWord16 = s66 + s142+  s327 :: SBool = s11 /= s326+  s328 :: SBool = s9 /= s326+  s329 :: SBool = s7 /= s326+  s330 :: SBool = s5 /= s326+  s331 :: SBool = s3 /= s326+  s332 :: SWord16 = s123 + s148+  s333 :: SBool = s88 /= s332+  s334 :: SWord16 = s54 + s158+  s335 :: SBool = s11 /= s334+  s336 :: SBool = s9 /= s334+  s337 :: SBool = s7 /= s334+  s338 :: SBool = s5 /= s334+  s339 :: SBool = s3 /= s334+  s340 :: SWord16 = s114 + s164+  s341 :: SBool = s88 /= s340+  s342 :: SWord16 = s66 + s158+  s343 :: SBool = s11 /= s342+  s344 :: SBool = s9 /= s342+  s345 :: SBool = s7 /= s342+  s346 :: SBool = s5 /= s342+  s347 :: SBool = s3 /= s342+  s348 :: SWord16 = s123 + s164+  s349 :: SBool = s88 /= s348+  s350 :: SWord16 = s66 + s166+  s351 :: SBool = s11 /= s350+  s352 :: SBool = s9 /= s350+  s353 :: SBool = s7 /= s350+  s354 :: SBool = s5 /= s350+  s355 :: SBool = s3 /= s350+  s356 :: SWord16 = s123 + s172+  s357 :: SBool = s88 /= s356+  s358 :: SWord16 = s66 + s182+  s359 :: SBool = s11 /= s358+  s360 :: SBool = s9 /= s358+  s361 :: SBool = s7 /= s358+  s362 :: SBool = s5 /= s358+  s363 :: SBool = s3 /= s358+  s364 :: SWord16 = s123 + s188+  s365 :: SBool = s88 /= s364+  s366 :: SWord16 = s42 + s206+  s367 :: SBool = s11 /= s366+  s368 :: SBool = s9 /= s366+  s369 :: SBool = s7 /= s366+  s370 :: SBool = s5 /= s366+  s371 :: SBool = s3 /= s366+  s372 :: SWord16 = s105 + s212+  s373 :: SBool = s88 /= s372+  s374 :: SWord16 = s54 + s206+  s375 :: SBool = s11 /= s374+  s376 :: SBool = s9 /= s374+  s377 :: SBool = s7 /= s374+  s378 :: SBool = s5 /= s374+  s379 :: SBool = s3 /= s374+  s380 :: SWord16 = s114 + s212+  s381 :: SBool = s88 /= s380+  s382 :: SWord16 = s66 + s206+  s383 :: SBool = s11 /= s382+  s384 :: SBool = s9 /= s382+  s385 :: SBool = s7 /= s382+  s386 :: SBool = s5 /= s382+  s387 :: SBool = s3 /= s382+  s388 :: SWord16 = s123 + s212+  s389 :: SBool = s88 /= s388+  s390 :: SWord16 = s54 + s214+  s391 :: SBool = s11 /= s390+  s392 :: SBool = s9 /= s390+  s393 :: SBool = s7 /= s390+  s394 :: SBool = s5 /= s390+  s395 :: SBool = s3 /= s390+  s396 :: SWord16 = s114 + s220+  s397 :: SBool = s88 /= s396+  s398 :: SWord16 = s66 + s214+  s399 :: SBool = s11 /= s398+  s400 :: SBool = s9 /= s398+  s401 :: SBool = s7 /= s398+  s402 :: SBool = s5 /= s398+  s403 :: SBool = s3 /= s398+  s404 :: SWord16 = s123 + s220+  s405 :: SBool = s88 /= s404+  s406 :: SWord16 = s66 + s222+  s407 :: SBool = s11 /= s406+  s408 :: SBool = s9 /= s406+  s409 :: SBool = s7 /= s406+  s410 :: SBool = s5 /= s406+  s411 :: SBool = s3 /= s406+  s412 :: SWord16 = s123 + s228+  s413 :: SBool = s88 /= s412+  s414 :: SWord16 = s54 + s238+  s415 :: SBool = s11 /= s414+  s416 :: SBool = s9 /= s414+  s417 :: SBool = s7 /= s414+  s418 :: SBool = s5 /= s414+  s419 :: SBool = s3 /= s414+  s420 :: SWord16 = s114 + s244+  s421 :: SBool = s88 /= s420+  s422 :: SWord16 = s66 + s238+  s423 :: SBool = s11 /= s422+  s424 :: SBool = s9 /= s422+  s425 :: SBool = s7 /= s422+  s426 :: SBool = s5 /= s422+  s427 :: SBool = s3 /= s422+  s428 :: SWord16 = s123 + s244+  s429 :: SBool = s88 /= s428+  s430 :: SWord16 = s66 + s246+  s431 :: SBool = s11 /= s430+  s432 :: SBool = s9 /= s430+  s433 :: SBool = s7 /= s430+  s434 :: SBool = s5 /= s430+  s435 :: SBool = s3 /= s430+  s436 :: SWord16 = s123 + s252+  s437 :: SBool = s88 /= s436+  s438 :: SWord16 = s66 + s262+  s439 :: SBool = s11 /= s438+  s440 :: SBool = s9 /= s438+  s441 :: SBool = s7 /= s438+  s442 :: SBool = s5 /= s438+  s443 :: SBool = s3 /= s438+  s444 :: SWord16 = s123 + s268+  s445 :: SBool = s88 /= s444+  s446 :: SWord16 = s54 + s286+  s447 :: SBool = s11 /= s446+  s448 :: SBool = s9 /= s446+  s449 :: SBool = s7 /= s446+  s450 :: SBool = s5 /= s446+  s451 :: SBool = s3 /= s446+  s452 :: SWord16 = s114 + s292+  s453 :: SBool = s88 /= s452+  s454 :: SWord16 = s66 + s286+  s455 :: SBool = s11 /= s454+  s456 :: SBool = s9 /= s454+  s457 :: SBool = s7 /= s454+  s458 :: SBool = s5 /= s454+  s459 :: SBool = s3 /= s454+  s460 :: SWord16 = s123 + s292+  s461 :: SBool = s88 /= s460+  s462 :: SWord16 = s66 + s294+  s463 :: SBool = s11 /= s462+  s464 :: SBool = s9 /= s462+  s465 :: SBool = s7 /= s462+  s466 :: SBool = s5 /= s462+  s467 :: SBool = s3 /= s462+  s468 :: SWord16 = s123 + s300+  s469 :: SBool = s88 /= s468+  s470 :: SWord16 = s66 + s310+  s471 :: SBool = s11 /= s470+  s472 :: SBool = s9 /= s470+  s473 :: SBool = s7 /= s470+  s474 :: SBool = s5 /= s470+  s475 :: SBool = s3 /= s470+  s476 :: SWord16 = s123 + s316+  s477 :: SBool = s88 /= s476+  s478 :: SWord16 = s66 + s334+  s479 :: SBool = s11 /= s478+  s480 :: SBool = s9 /= s478+  s481 :: SBool = s7 /= s478+  s482 :: SBool = s5 /= s478+  s483 :: SBool = s3 /= s478+  s484 :: SWord16 = s123 + s340+  s485 :: SBool = s88 /= s484+  s486 :: SWord16 = s54 + s366+  s487 :: SBool = s11 /= s486+  s488 :: SBool = s9 /= s486+  s489 :: SBool = s7 /= s486+  s490 :: SBool = s5 /= s486+  s491 :: SBool = s3 /= s486+  s492 :: SWord16 = s114 + s372+  s493 :: SBool = s88 /= s492+  s494 :: SWord16 = s66 + s366+  s495 :: SBool = s11 /= s494+  s496 :: SBool = s9 /= s494+  s497 :: SBool = s7 /= s494+  s498 :: SBool = s5 /= s494+  s499 :: SBool = s3 /= s494+  s500 :: SWord16 = s123 + s372+  s501 :: SBool = s88 /= s500+  s502 :: SWord16 = s66 + s374+  s503 :: SBool = s11 /= s502+  s504 :: SBool = s9 /= s502+  s505 :: SBool = s7 /= s502+  s506 :: SBool = s5 /= s502+  s507 :: SBool = s3 /= s502+  s508 :: SWord16 = s123 + s380+  s509 :: SBool = s88 /= s508+  s510 :: SWord16 = s66 + s390+  s511 :: SBool = s11 /= s510+  s512 :: SBool = s9 /= s510+  s513 :: SBool = s7 /= s510+  s514 :: SBool = s5 /= s510+  s515 :: SBool = s3 /= s510+  s516 :: SWord16 = s123 + s396+  s517 :: SBool = s88 /= s516+  s518 :: SWord16 = s66 + s414+  s519 :: SBool = s11 /= s518+  s520 :: SBool = s9 /= s518+  s521 :: SBool = s7 /= s518+  s522 :: SBool = s5 /= s518+  s523 :: SBool = s3 /= s518+  s524 :: SWord16 = s123 + s420+  s525 :: SBool = s88 /= s524+  s526 :: SWord16 = s66 + s446+  s527 :: SBool = s11 /= s526+  s528 :: SBool = s9 /= s526+  s529 :: SBool = s7 /= s526+  s530 :: SBool = s5 /= s526+  s531 :: SBool = s3 /= s526+  s532 :: SWord16 = s123 + s452+  s533 :: SBool = s88 /= s532+  s534 :: SWord16 = s66 + s486+  s535 :: SBool = s11 /= s534+  s536 :: SBool = s9 /= s534+  s537 :: SBool = s7 /= s534+  s538 :: SBool = s5 /= s534+  s539 :: SBool = s3 /= s534+  s540 :: SWord16 = s123 + s492+  s541 :: SBool = s88 /= s540+  s542 :: SBool = s0 >= s18+  s543 :: SBool = s18 >= s30+  s544 :: SBool = s30 >= s42+  s545 :: SBool = s42 >= s54+  s546 :: SBool = s54 >= s66+  s547 :: SBool = s545 & s546+  s548 :: SBool = s544 & s547+  s549 :: SBool = s543 & s548+  s550 :: SBool = s542 & s549+  s552 :: SBool = s534 == s551+CONSTRAINTS+  s17+  s29+  s41+  s53+  s65+  s77+  s79+  s80+  s81+  s82+  s83+  s89+  s91+  s92+  s93+  s94+  s95+  s98+  s100+  s101+  s102+  s103+  s104+  s107+  s109+  s110+  s111+  s112+  s113+  s116+  s118+  s119+  s120+  s121+  s122+  s125+  s127+  s128+  s129+  s130+  s131+  s133+  s135+  s136+  s137+  s138+  s139+  s141+  s143+  s144+  s145+  s146+  s147+  s149+  s151+  s152+  s153+  s154+  s155+  s157+  s159+  s160+  s161+  s162+  s163+  s165+  s167+  s168+  s169+  s170+  s171+  s173+  s175+  s176+  s177+  s178+  s179+  s181+  s183+  s184+  s185+  s186+  s187+  s189+  s191+  s192+  s193+  s194+  s195+  s197+  s199+  s200+  s201+  s202+  s203+  s205+  s207+  s208+  s209+  s210+  s211+  s213+  s215+  s216+  s217+  s218+  s219+  s221+  s223+  s224+  s225+  s226+  s227+  s229+  s231+  s232+  s233+  s234+  s235+  s237+  s239+  s240+  s241+  s242+  s243+  s245+  s247+  s248+  s249+  s250+  s251+  s253+  s255+  s256+  s257+  s258+  s259+  s261+  s263+  s264+  s265+  s266+  s267+  s269+  s271+  s272+  s273+  s274+  s275+  s277+  s279+  s280+  s281+  s282+  s283+  s285+  s287+  s288+  s289+  s290+  s291+  s293+  s295+  s296+  s297+  s298+  s299+  s301+  s303+  s304+  s305+  s306+  s307+  s309+  s311+  s312+  s313+  s314+  s315+  s317+  s319+  s320+  s321+  s322+  s323+  s325+  s327+  s328+  s329+  s330+  s331+  s333+  s335+  s336+  s337+  s338+  s339+  s341+  s343+  s344+  s345+  s346+  s347+  s349+  s351+  s352+  s353+  s354+  s355+  s357+  s359+  s360+  s361+  s362+  s363+  s365+  s367+  s368+  s369+  s370+  s371+  s373+  s375+  s376+  s377+  s378+  s379+  s381+  s383+  s384+  s385+  s386+  s387+  s389+  s391+  s392+  s393+  s394+  s395+  s397+  s399+  s400+  s401+  s402+  s403+  s405+  s407+  s408+  s409+  s410+  s411+  s413+  s415+  s416+  s417+  s418+  s419+  s421+  s423+  s424+  s425+  s426+  s427+  s429+  s431+  s432+  s433+  s434+  s435+  s437+  s439+  s440+  s441+  s442+  s443+  s445+  s447+  s448+  s449+  s450+  s451+  s453+  s455+  s456+  s457+  s458+  s459+  s461+  s463+  s464+  s465+  s466+  s467+  s469+  s471+  s472+  s473+  s474+  s475+  s477+  s479+  s480+  s481+  s482+  s483+  s485+  s487+  s488+  s489+  s490+  s491+  s493+  s495+  s496+  s497+  s498+  s499+  s501+  s503+  s504+  s505+  s506+  s507+  s509+  s511+  s512+  s513+  s514+  s515+  s517+  s519+  s520+  s521+  s522+  s523+  s525+  s527+  s528+  s529+  s530+  s531+  s533+  s535+  s536+  s537+  s538+  s539+  s541+  s550+ASSERTIONS+OUTPUTS+  s552
+ SBVTestSuite/GoldFiles/combined1.gold view
@@ -0,0 +1,6 @@+Optimal model:+  x     = 3 :: Integer+  y     = 2 :: Integer+  z     = 4 :: Integer+  max_x = 3 :: Integer+  max_y = 2 :: Integer
+ SBVTestSuite/GoldFiles/combined2.gold view
@@ -0,0 +1,7 @@+Optimal model:+  a      =  True :: Bool+  b      = False :: Bool+  c      =  True :: Bool+  soft_a =  True :: Bool+  soft_b = False :: Bool+  soft_c =  True :: Bool
+ SBVTestSuite/GoldFiles/counts.gold view
@@ -0,0 +1,1705 @@+INPUTS+  s0 :: SWord8+  s1 :: SWord8+  s2 :: SWord8+  s3 :: SWord8+  s4 :: SWord8+  s5 :: SWord8+  s6 :: SWord8+  s7 :: SWord8+  s8 :: SWord8+  s9 :: SWord8+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s10 = 10 :: Word8+  s12 = 0 :: Word8+  s32 = 2 :: Word8+  s33 = 1 :: Word8+  s35 = 100 :: Word8+  s555 = 3 :: Word8+  s716 = 4 :: Word8+  s877 = 5 :: Word8+  s1038 = 6 :: Word8+  s1199 = 7 :: Word8+  s1360 = 8 :: Word8+  s1521 = 9 :: Word8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s11 :: SBool = s9 < s10+  s13 :: SBool = s9 == s12+  s14 :: SBool = s8 < s10+  s15 :: SBool = s8 == s12+  s16 :: SBool = s7 < s10+  s17 :: SBool = s7 == s12+  s18 :: SBool = s6 < s10+  s19 :: SBool = s6 == s12+  s20 :: SBool = s5 < s10+  s21 :: SBool = s5 == s12+  s22 :: SBool = s4 < s10+  s23 :: SBool = s4 == s12+  s24 :: SBool = s3 < s10+  s25 :: SBool = s3 == s12+  s26 :: SBool = s2 < s10+  s27 :: SBool = s2 == s12+  s28 :: SBool = s1 < s10+  s29 :: SBool = s1 == s12+  s30 :: SBool = s0 < s10+  s31 :: SBool = s0 == s12+  s34 :: SWord8 = if s31 then s32 else s33+  s36 :: SBool = s0 < s35+  s37 :: SWord8 = s0 rem s10+  s38 :: SBool = s12 == s37+  s39 :: SWord8 = s0 quot s10+  s40 :: SWord8 = s39 rem s10+  s41 :: SBool = s12 == s40+  s42 :: SWord8 = if s41 then s32 else s33+  s43 :: SWord8 = s33 + s42+  s44 :: SWord8 = if s38 then s43 else s42+  s45 :: SWord8 = s39 quot s10+  s46 :: SBool = s12 == s45+  s47 :: SWord8 = if s46 then s32 else s33+  s48 :: SWord8 = s33 + s47+  s49 :: SWord8 = if s41 then s48 else s47+  s50 :: SWord8 = s33 + s49+  s51 :: SWord8 = if s38 then s50 else s49+  s52 :: SWord8 = if s36 then s44 else s51+  s53 :: SWord8 = if s30 then s34 else s52+  s54 :: SWord8 = s33 + s53+  s55 :: SWord8 = if s29 then s54 else s53+  s56 :: SBool = s1 < s35+  s57 :: SWord8 = s1 rem s10+  s58 :: SBool = s12 == s57+  s59 :: SWord8 = s1 quot s10+  s60 :: SWord8 = s59 rem s10+  s61 :: SBool = s12 == s60+  s62 :: SWord8 = if s61 then s54 else s53+  s63 :: SWord8 = s33 + s62+  s64 :: SWord8 = if s58 then s63 else s62+  s65 :: SWord8 = s59 quot s10+  s66 :: SBool = s12 == s65+  s67 :: SWord8 = if s66 then s54 else s53+  s68 :: SWord8 = s33 + s67+  s69 :: SWord8 = if s61 then s68 else s67+  s70 :: SWord8 = s33 + s69+  s71 :: SWord8 = if s58 then s70 else s69+  s72 :: SWord8 = if s56 then s64 else s71+  s73 :: SWord8 = if s28 then s55 else s72+  s74 :: SWord8 = s33 + s73+  s75 :: SWord8 = if s27 then s74 else s73+  s76 :: SBool = s2 < s35+  s77 :: SWord8 = s2 rem s10+  s78 :: SBool = s12 == s77+  s79 :: SWord8 = s2 quot s10+  s80 :: SWord8 = s79 rem s10+  s81 :: SBool = s12 == s80+  s82 :: SWord8 = if s81 then s74 else s73+  s83 :: SWord8 = s33 + s82+  s84 :: SWord8 = if s78 then s83 else s82+  s85 :: SWord8 = s79 quot s10+  s86 :: SBool = s12 == s85+  s87 :: SWord8 = if s86 then s74 else s73+  s88 :: SWord8 = s33 + s87+  s89 :: SWord8 = if s81 then s88 else s87+  s90 :: SWord8 = s33 + s89+  s91 :: SWord8 = if s78 then s90 else s89+  s92 :: SWord8 = if s76 then s84 else s91+  s93 :: SWord8 = if s26 then s75 else s92+  s94 :: SWord8 = s33 + s93+  s95 :: SWord8 = if s25 then s94 else s93+  s96 :: SBool = s3 < s35+  s97 :: SWord8 = s3 rem s10+  s98 :: SBool = s12 == s97+  s99 :: SWord8 = s3 quot s10+  s100 :: SWord8 = s99 rem s10+  s101 :: SBool = s12 == s100+  s102 :: SWord8 = if s101 then s94 else s93+  s103 :: SWord8 = s33 + s102+  s104 :: SWord8 = if s98 then s103 else s102+  s105 :: SWord8 = s99 quot s10+  s106 :: SBool = s12 == s105+  s107 :: SWord8 = if s106 then s94 else s93+  s108 :: SWord8 = s33 + s107+  s109 :: SWord8 = if s101 then s108 else s107+  s110 :: SWord8 = s33 + s109+  s111 :: SWord8 = if s98 then s110 else s109+  s112 :: SWord8 = if s96 then s104 else s111+  s113 :: SWord8 = if s24 then s95 else s112+  s114 :: SWord8 = s33 + s113+  s115 :: SWord8 = if s23 then s114 else s113+  s116 :: SBool = s4 < s35+  s117 :: SWord8 = s4 rem s10+  s118 :: SBool = s12 == s117+  s119 :: SWord8 = s4 quot s10+  s120 :: SWord8 = s119 rem s10+  s121 :: SBool = s12 == s120+  s122 :: SWord8 = if s121 then s114 else s113+  s123 :: SWord8 = s33 + s122+  s124 :: SWord8 = if s118 then s123 else s122+  s125 :: SWord8 = s119 quot s10+  s126 :: SBool = s12 == s125+  s127 :: SWord8 = if s126 then s114 else s113+  s128 :: SWord8 = s33 + s127+  s129 :: SWord8 = if s121 then s128 else s127+  s130 :: SWord8 = s33 + s129+  s131 :: SWord8 = if s118 then s130 else s129+  s132 :: SWord8 = if s116 then s124 else s131+  s133 :: SWord8 = if s22 then s115 else s132+  s134 :: SWord8 = s33 + s133+  s135 :: SWord8 = if s21 then s134 else s133+  s136 :: SBool = s5 < s35+  s137 :: SWord8 = s5 rem s10+  s138 :: SBool = s12 == s137+  s139 :: SWord8 = s5 quot s10+  s140 :: SWord8 = s139 rem s10+  s141 :: SBool = s12 == s140+  s142 :: SWord8 = if s141 then s134 else s133+  s143 :: SWord8 = s33 + s142+  s144 :: SWord8 = if s138 then s143 else s142+  s145 :: SWord8 = s139 quot s10+  s146 :: SBool = s12 == s145+  s147 :: SWord8 = if s146 then s134 else s133+  s148 :: SWord8 = s33 + s147+  s149 :: SWord8 = if s141 then s148 else s147+  s150 :: SWord8 = s33 + s149+  s151 :: SWord8 = if s138 then s150 else s149+  s152 :: SWord8 = if s136 then s144 else s151+  s153 :: SWord8 = if s20 then s135 else s152+  s154 :: SWord8 = s33 + s153+  s155 :: SWord8 = if s19 then s154 else s153+  s156 :: SBool = s6 < s35+  s157 :: SWord8 = s6 rem s10+  s158 :: SBool = s12 == s157+  s159 :: SWord8 = s6 quot s10+  s160 :: SWord8 = s159 rem s10+  s161 :: SBool = s12 == s160+  s162 :: SWord8 = if s161 then s154 else s153+  s163 :: SWord8 = s33 + s162+  s164 :: SWord8 = if s158 then s163 else s162+  s165 :: SWord8 = s159 quot s10+  s166 :: SBool = s12 == s165+  s167 :: SWord8 = if s166 then s154 else s153+  s168 :: SWord8 = s33 + s167+  s169 :: SWord8 = if s161 then s168 else s167+  s170 :: SWord8 = s33 + s169+  s171 :: SWord8 = if s158 then s170 else s169+  s172 :: SWord8 = if s156 then s164 else s171+  s173 :: SWord8 = if s18 then s155 else s172+  s174 :: SWord8 = s33 + s173+  s175 :: SWord8 = if s17 then s174 else s173+  s176 :: SBool = s7 < s35+  s177 :: SWord8 = s7 rem s10+  s178 :: SBool = s12 == s177+  s179 :: SWord8 = s7 quot s10+  s180 :: SWord8 = s179 rem s10+  s181 :: SBool = s12 == s180+  s182 :: SWord8 = if s181 then s174 else s173+  s183 :: SWord8 = s33 + s182+  s184 :: SWord8 = if s178 then s183 else s182+  s185 :: SWord8 = s179 quot s10+  s186 :: SBool = s12 == s185+  s187 :: SWord8 = if s186 then s174 else s173+  s188 :: SWord8 = s33 + s187+  s189 :: SWord8 = if s181 then s188 else s187+  s190 :: SWord8 = s33 + s189+  s191 :: SWord8 = if s178 then s190 else s189+  s192 :: SWord8 = if s176 then s184 else s191+  s193 :: SWord8 = if s16 then s175 else s192+  s194 :: SWord8 = s33 + s193+  s195 :: SWord8 = if s15 then s194 else s193+  s196 :: SBool = s8 < s35+  s197 :: SWord8 = s8 rem s10+  s198 :: SBool = s12 == s197+  s199 :: SWord8 = s8 quot s10+  s200 :: SWord8 = s199 rem s10+  s201 :: SBool = s12 == s200+  s202 :: SWord8 = if s201 then s194 else s193+  s203 :: SWord8 = s33 + s202+  s204 :: SWord8 = if s198 then s203 else s202+  s205 :: SWord8 = s199 quot s10+  s206 :: SBool = s12 == s205+  s207 :: SWord8 = if s206 then s194 else s193+  s208 :: SWord8 = s33 + s207+  s209 :: SWord8 = if s201 then s208 else s207+  s210 :: SWord8 = s33 + s209+  s211 :: SWord8 = if s198 then s210 else s209+  s212 :: SWord8 = if s196 then s204 else s211+  s213 :: SWord8 = if s14 then s195 else s212+  s214 :: SWord8 = s33 + s213+  s215 :: SWord8 = if s13 then s214 else s213+  s216 :: SBool = s9 < s35+  s217 :: SWord8 = s9 rem s10+  s218 :: SBool = s12 == s217+  s219 :: SWord8 = s9 quot s10+  s220 :: SWord8 = s219 rem s10+  s221 :: SBool = s12 == s220+  s222 :: SWord8 = if s221 then s214 else s213+  s223 :: SWord8 = s33 + s222+  s224 :: SWord8 = if s218 then s223 else s222+  s225 :: SWord8 = s219 quot s10+  s226 :: SBool = s12 == s225+  s227 :: SWord8 = if s226 then s214 else s213+  s228 :: SWord8 = s33 + s227+  s229 :: SWord8 = if s221 then s228 else s227+  s230 :: SWord8 = s33 + s229+  s231 :: SWord8 = if s218 then s230 else s229+  s232 :: SWord8 = if s216 then s224 else s231+  s233 :: SWord8 = if s11 then s215 else s232+  s234 :: SBool = s0 == s233+  s235 :: SBool = s9 == s33+  s236 :: SBool = s8 == s33+  s237 :: SBool = s7 == s33+  s238 :: SBool = s6 == s33+  s239 :: SBool = s5 == s33+  s240 :: SBool = s4 == s33+  s241 :: SBool = s3 == s33+  s242 :: SBool = s2 == s33+  s243 :: SBool = s1 == s33+  s244 :: SBool = s0 == s33+  s245 :: SWord8 = if s244 then s32 else s33+  s246 :: SBool = s33 == s37+  s247 :: SBool = s33 == s40+  s248 :: SWord8 = if s247 then s32 else s33+  s249 :: SWord8 = s33 + s248+  s250 :: SWord8 = if s246 then s249 else s248+  s251 :: SBool = s33 == s45+  s252 :: SWord8 = if s251 then s32 else s33+  s253 :: SWord8 = s33 + s252+  s254 :: SWord8 = if s247 then s253 else s252+  s255 :: SWord8 = s33 + s254+  s256 :: SWord8 = if s246 then s255 else s254+  s257 :: SWord8 = if s36 then s250 else s256+  s258 :: SWord8 = if s30 then s245 else s257+  s259 :: SWord8 = s33 + s258+  s260 :: SWord8 = if s243 then s259 else s258+  s261 :: SBool = s33 == s57+  s262 :: SBool = s33 == s60+  s263 :: SWord8 = if s262 then s259 else s258+  s264 :: SWord8 = s33 + s263+  s265 :: SWord8 = if s261 then s264 else s263+  s266 :: SBool = s33 == s65+  s267 :: SWord8 = if s266 then s259 else s258+  s268 :: SWord8 = s33 + s267+  s269 :: SWord8 = if s262 then s268 else s267+  s270 :: SWord8 = s33 + s269+  s271 :: SWord8 = if s261 then s270 else s269+  s272 :: SWord8 = if s56 then s265 else s271+  s273 :: SWord8 = if s28 then s260 else s272+  s274 :: SWord8 = s33 + s273+  s275 :: SWord8 = if s242 then s274 else s273+  s276 :: SBool = s33 == s77+  s277 :: SBool = s33 == s80+  s278 :: SWord8 = if s277 then s274 else s273+  s279 :: SWord8 = s33 + s278+  s280 :: SWord8 = if s276 then s279 else s278+  s281 :: SBool = s33 == s85+  s282 :: SWord8 = if s281 then s274 else s273+  s283 :: SWord8 = s33 + s282+  s284 :: SWord8 = if s277 then s283 else s282+  s285 :: SWord8 = s33 + s284+  s286 :: SWord8 = if s276 then s285 else s284+  s287 :: SWord8 = if s76 then s280 else s286+  s288 :: SWord8 = if s26 then s275 else s287+  s289 :: SWord8 = s33 + s288+  s290 :: SWord8 = if s241 then s289 else s288+  s291 :: SBool = s33 == s97+  s292 :: SBool = s33 == s100+  s293 :: SWord8 = if s292 then s289 else s288+  s294 :: SWord8 = s33 + s293+  s295 :: SWord8 = if s291 then s294 else s293+  s296 :: SBool = s33 == s105+  s297 :: SWord8 = if s296 then s289 else s288+  s298 :: SWord8 = s33 + s297+  s299 :: SWord8 = if s292 then s298 else s297+  s300 :: SWord8 = s33 + s299+  s301 :: SWord8 = if s291 then s300 else s299+  s302 :: SWord8 = if s96 then s295 else s301+  s303 :: SWord8 = if s24 then s290 else s302+  s304 :: SWord8 = s33 + s303+  s305 :: SWord8 = if s240 then s304 else s303+  s306 :: SBool = s33 == s117+  s307 :: SBool = s33 == s120+  s308 :: SWord8 = if s307 then s304 else s303+  s309 :: SWord8 = s33 + s308+  s310 :: SWord8 = if s306 then s309 else s308+  s311 :: SBool = s33 == s125+  s312 :: SWord8 = if s311 then s304 else s303+  s313 :: SWord8 = s33 + s312+  s314 :: SWord8 = if s307 then s313 else s312+  s315 :: SWord8 = s33 + s314+  s316 :: SWord8 = if s306 then s315 else s314+  s317 :: SWord8 = if s116 then s310 else s316+  s318 :: SWord8 = if s22 then s305 else s317+  s319 :: SWord8 = s33 + s318+  s320 :: SWord8 = if s239 then s319 else s318+  s321 :: SBool = s33 == s137+  s322 :: SBool = s33 == s140+  s323 :: SWord8 = if s322 then s319 else s318+  s324 :: SWord8 = s33 + s323+  s325 :: SWord8 = if s321 then s324 else s323+  s326 :: SBool = s33 == s145+  s327 :: SWord8 = if s326 then s319 else s318+  s328 :: SWord8 = s33 + s327+  s329 :: SWord8 = if s322 then s328 else s327+  s330 :: SWord8 = s33 + s329+  s331 :: SWord8 = if s321 then s330 else s329+  s332 :: SWord8 = if s136 then s325 else s331+  s333 :: SWord8 = if s20 then s320 else s332+  s334 :: SWord8 = s33 + s333+  s335 :: SWord8 = if s238 then s334 else s333+  s336 :: SBool = s33 == s157+  s337 :: SBool = s33 == s160+  s338 :: SWord8 = if s337 then s334 else s333+  s339 :: SWord8 = s33 + s338+  s340 :: SWord8 = if s336 then s339 else s338+  s341 :: SBool = s33 == s165+  s342 :: SWord8 = if s341 then s334 else s333+  s343 :: SWord8 = s33 + s342+  s344 :: SWord8 = if s337 then s343 else s342+  s345 :: SWord8 = s33 + s344+  s346 :: SWord8 = if s336 then s345 else s344+  s347 :: SWord8 = if s156 then s340 else s346+  s348 :: SWord8 = if s18 then s335 else s347+  s349 :: SWord8 = s33 + s348+  s350 :: SWord8 = if s237 then s349 else s348+  s351 :: SBool = s33 == s177+  s352 :: SBool = s33 == s180+  s353 :: SWord8 = if s352 then s349 else s348+  s354 :: SWord8 = s33 + s353+  s355 :: SWord8 = if s351 then s354 else s353+  s356 :: SBool = s33 == s185+  s357 :: SWord8 = if s356 then s349 else s348+  s358 :: SWord8 = s33 + s357+  s359 :: SWord8 = if s352 then s358 else s357+  s360 :: SWord8 = s33 + s359+  s361 :: SWord8 = if s351 then s360 else s359+  s362 :: SWord8 = if s176 then s355 else s361+  s363 :: SWord8 = if s16 then s350 else s362+  s364 :: SWord8 = s33 + s363+  s365 :: SWord8 = if s236 then s364 else s363+  s366 :: SBool = s33 == s197+  s367 :: SBool = s33 == s200+  s368 :: SWord8 = if s367 then s364 else s363+  s369 :: SWord8 = s33 + s368+  s370 :: SWord8 = if s366 then s369 else s368+  s371 :: SBool = s33 == s205+  s372 :: SWord8 = if s371 then s364 else s363+  s373 :: SWord8 = s33 + s372+  s374 :: SWord8 = if s367 then s373 else s372+  s375 :: SWord8 = s33 + s374+  s376 :: SWord8 = if s366 then s375 else s374+  s377 :: SWord8 = if s196 then s370 else s376+  s378 :: SWord8 = if s14 then s365 else s377+  s379 :: SWord8 = s33 + s378+  s380 :: SWord8 = if s235 then s379 else s378+  s381 :: SBool = s33 == s217+  s382 :: SBool = s33 == s220+  s383 :: SWord8 = if s382 then s379 else s378+  s384 :: SWord8 = s33 + s383+  s385 :: SWord8 = if s381 then s384 else s383+  s386 :: SBool = s33 == s225+  s387 :: SWord8 = if s386 then s379 else s378+  s388 :: SWord8 = s33 + s387+  s389 :: SWord8 = if s382 then s388 else s387+  s390 :: SWord8 = s33 + s389+  s391 :: SWord8 = if s381 then s390 else s389+  s392 :: SWord8 = if s216 then s385 else s391+  s393 :: SWord8 = if s11 then s380 else s392+  s394 :: SBool = s1 == s393+  s395 :: SBool = s9 == s32+  s396 :: SBool = s8 == s32+  s397 :: SBool = s7 == s32+  s398 :: SBool = s6 == s32+  s399 :: SBool = s5 == s32+  s400 :: SBool = s4 == s32+  s401 :: SBool = s3 == s32+  s402 :: SBool = s2 == s32+  s403 :: SBool = s1 == s32+  s404 :: SBool = s0 == s32+  s405 :: SWord8 = if s404 then s32 else s33+  s406 :: SBool = s32 == s37+  s407 :: SBool = s32 == s40+  s408 :: SWord8 = if s407 then s32 else s33+  s409 :: SWord8 = s33 + s408+  s410 :: SWord8 = if s406 then s409 else s408+  s411 :: SBool = s32 == s45+  s412 :: SWord8 = if s411 then s32 else s33+  s413 :: SWord8 = s33 + s412+  s414 :: SWord8 = if s407 then s413 else s412+  s415 :: SWord8 = s33 + s414+  s416 :: SWord8 = if s406 then s415 else s414+  s417 :: SWord8 = if s36 then s410 else s416+  s418 :: SWord8 = if s30 then s405 else s417+  s419 :: SWord8 = s33 + s418+  s420 :: SWord8 = if s403 then s419 else s418+  s421 :: SBool = s32 == s57+  s422 :: SBool = s32 == s60+  s423 :: SWord8 = if s422 then s419 else s418+  s424 :: SWord8 = s33 + s423+  s425 :: SWord8 = if s421 then s424 else s423+  s426 :: SBool = s32 == s65+  s427 :: SWord8 = if s426 then s419 else s418+  s428 :: SWord8 = s33 + s427+  s429 :: SWord8 = if s422 then s428 else s427+  s430 :: SWord8 = s33 + s429+  s431 :: SWord8 = if s421 then s430 else s429+  s432 :: SWord8 = if s56 then s425 else s431+  s433 :: SWord8 = if s28 then s420 else s432+  s434 :: SWord8 = s33 + s433+  s435 :: SWord8 = if s402 then s434 else s433+  s436 :: SBool = s32 == s77+  s437 :: SBool = s32 == s80+  s438 :: SWord8 = if s437 then s434 else s433+  s439 :: SWord8 = s33 + s438+  s440 :: SWord8 = if s436 then s439 else s438+  s441 :: SBool = s32 == s85+  s442 :: SWord8 = if s441 then s434 else s433+  s443 :: SWord8 = s33 + s442+  s444 :: SWord8 = if s437 then s443 else s442+  s445 :: SWord8 = s33 + s444+  s446 :: SWord8 = if s436 then s445 else s444+  s447 :: SWord8 = if s76 then s440 else s446+  s448 :: SWord8 = if s26 then s435 else s447+  s449 :: SWord8 = s33 + s448+  s450 :: SWord8 = if s401 then s449 else s448+  s451 :: SBool = s32 == s97+  s452 :: SBool = s32 == s100+  s453 :: SWord8 = if s452 then s449 else s448+  s454 :: SWord8 = s33 + s453+  s455 :: SWord8 = if s451 then s454 else s453+  s456 :: SBool = s32 == s105+  s457 :: SWord8 = if s456 then s449 else s448+  s458 :: SWord8 = s33 + s457+  s459 :: SWord8 = if s452 then s458 else s457+  s460 :: SWord8 = s33 + s459+  s461 :: SWord8 = if s451 then s460 else s459+  s462 :: SWord8 = if s96 then s455 else s461+  s463 :: SWord8 = if s24 then s450 else s462+  s464 :: SWord8 = s33 + s463+  s465 :: SWord8 = if s400 then s464 else s463+  s466 :: SBool = s32 == s117+  s467 :: SBool = s32 == s120+  s468 :: SWord8 = if s467 then s464 else s463+  s469 :: SWord8 = s33 + s468+  s470 :: SWord8 = if s466 then s469 else s468+  s471 :: SBool = s32 == s125+  s472 :: SWord8 = if s471 then s464 else s463+  s473 :: SWord8 = s33 + s472+  s474 :: SWord8 = if s467 then s473 else s472+  s475 :: SWord8 = s33 + s474+  s476 :: SWord8 = if s466 then s475 else s474+  s477 :: SWord8 = if s116 then s470 else s476+  s478 :: SWord8 = if s22 then s465 else s477+  s479 :: SWord8 = s33 + s478+  s480 :: SWord8 = if s399 then s479 else s478+  s481 :: SBool = s32 == s137+  s482 :: SBool = s32 == s140+  s483 :: SWord8 = if s482 then s479 else s478+  s484 :: SWord8 = s33 + s483+  s485 :: SWord8 = if s481 then s484 else s483+  s486 :: SBool = s32 == s145+  s487 :: SWord8 = if s486 then s479 else s478+  s488 :: SWord8 = s33 + s487+  s489 :: SWord8 = if s482 then s488 else s487+  s490 :: SWord8 = s33 + s489+  s491 :: SWord8 = if s481 then s490 else s489+  s492 :: SWord8 = if s136 then s485 else s491+  s493 :: SWord8 = if s20 then s480 else s492+  s494 :: SWord8 = s33 + s493+  s495 :: SWord8 = if s398 then s494 else s493+  s496 :: SBool = s32 == s157+  s497 :: SBool = s32 == s160+  s498 :: SWord8 = if s497 then s494 else s493+  s499 :: SWord8 = s33 + s498+  s500 :: SWord8 = if s496 then s499 else s498+  s501 :: SBool = s32 == s165+  s502 :: SWord8 = if s501 then s494 else s493+  s503 :: SWord8 = s33 + s502+  s504 :: SWord8 = if s497 then s503 else s502+  s505 :: SWord8 = s33 + s504+  s506 :: SWord8 = if s496 then s505 else s504+  s507 :: SWord8 = if s156 then s500 else s506+  s508 :: SWord8 = if s18 then s495 else s507+  s509 :: SWord8 = s33 + s508+  s510 :: SWord8 = if s397 then s509 else s508+  s511 :: SBool = s32 == s177+  s512 :: SBool = s32 == s180+  s513 :: SWord8 = if s512 then s509 else s508+  s514 :: SWord8 = s33 + s513+  s515 :: SWord8 = if s511 then s514 else s513+  s516 :: SBool = s32 == s185+  s517 :: SWord8 = if s516 then s509 else s508+  s518 :: SWord8 = s33 + s517+  s519 :: SWord8 = if s512 then s518 else s517+  s520 :: SWord8 = s33 + s519+  s521 :: SWord8 = if s511 then s520 else s519+  s522 :: SWord8 = if s176 then s515 else s521+  s523 :: SWord8 = if s16 then s510 else s522+  s524 :: SWord8 = s33 + s523+  s525 :: SWord8 = if s396 then s524 else s523+  s526 :: SBool = s32 == s197+  s527 :: SBool = s32 == s200+  s528 :: SWord8 = if s527 then s524 else s523+  s529 :: SWord8 = s33 + s528+  s530 :: SWord8 = if s526 then s529 else s528+  s531 :: SBool = s32 == s205+  s532 :: SWord8 = if s531 then s524 else s523+  s533 :: SWord8 = s33 + s532+  s534 :: SWord8 = if s527 then s533 else s532+  s535 :: SWord8 = s33 + s534+  s536 :: SWord8 = if s526 then s535 else s534+  s537 :: SWord8 = if s196 then s530 else s536+  s538 :: SWord8 = if s14 then s525 else s537+  s539 :: SWord8 = s33 + s538+  s540 :: SWord8 = if s395 then s539 else s538+  s541 :: SBool = s32 == s217+  s542 :: SBool = s32 == s220+  s543 :: SWord8 = if s542 then s539 else s538+  s544 :: SWord8 = s33 + s543+  s545 :: SWord8 = if s541 then s544 else s543+  s546 :: SBool = s32 == s225+  s547 :: SWord8 = if s546 then s539 else s538+  s548 :: SWord8 = s33 + s547+  s549 :: SWord8 = if s542 then s548 else s547+  s550 :: SWord8 = s33 + s549+  s551 :: SWord8 = if s541 then s550 else s549+  s552 :: SWord8 = if s216 then s545 else s551+  s553 :: SWord8 = if s11 then s540 else s552+  s554 :: SBool = s2 == s553+  s556 :: SBool = s9 == s555+  s557 :: SBool = s8 == s555+  s558 :: SBool = s7 == s555+  s559 :: SBool = s6 == s555+  s560 :: SBool = s5 == s555+  s561 :: SBool = s4 == s555+  s562 :: SBool = s3 == s555+  s563 :: SBool = s2 == s555+  s564 :: SBool = s1 == s555+  s565 :: SBool = s0 == s555+  s566 :: SWord8 = if s565 then s32 else s33+  s567 :: SBool = s37 == s555+  s568 :: SBool = s40 == s555+  s569 :: SWord8 = if s568 then s32 else s33+  s570 :: SWord8 = s33 + s569+  s571 :: SWord8 = if s567 then s570 else s569+  s572 :: SBool = s45 == s555+  s573 :: SWord8 = if s572 then s32 else s33+  s574 :: SWord8 = s33 + s573+  s575 :: SWord8 = if s568 then s574 else s573+  s576 :: SWord8 = s33 + s575+  s577 :: SWord8 = if s567 then s576 else s575+  s578 :: SWord8 = if s36 then s571 else s577+  s579 :: SWord8 = if s30 then s566 else s578+  s580 :: SWord8 = s33 + s579+  s581 :: SWord8 = if s564 then s580 else s579+  s582 :: SBool = s57 == s555+  s583 :: SBool = s60 == s555+  s584 :: SWord8 = if s583 then s580 else s579+  s585 :: SWord8 = s33 + s584+  s586 :: SWord8 = if s582 then s585 else s584+  s587 :: SBool = s65 == s555+  s588 :: SWord8 = if s587 then s580 else s579+  s589 :: SWord8 = s33 + s588+  s590 :: SWord8 = if s583 then s589 else s588+  s591 :: SWord8 = s33 + s590+  s592 :: SWord8 = if s582 then s591 else s590+  s593 :: SWord8 = if s56 then s586 else s592+  s594 :: SWord8 = if s28 then s581 else s593+  s595 :: SWord8 = s33 + s594+  s596 :: SWord8 = if s563 then s595 else s594+  s597 :: SBool = s77 == s555+  s598 :: SBool = s80 == s555+  s599 :: SWord8 = if s598 then s595 else s594+  s600 :: SWord8 = s33 + s599+  s601 :: SWord8 = if s597 then s600 else s599+  s602 :: SBool = s85 == s555+  s603 :: SWord8 = if s602 then s595 else s594+  s604 :: SWord8 = s33 + s603+  s605 :: SWord8 = if s598 then s604 else s603+  s606 :: SWord8 = s33 + s605+  s607 :: SWord8 = if s597 then s606 else s605+  s608 :: SWord8 = if s76 then s601 else s607+  s609 :: SWord8 = if s26 then s596 else s608+  s610 :: SWord8 = s33 + s609+  s611 :: SWord8 = if s562 then s610 else s609+  s612 :: SBool = s97 == s555+  s613 :: SBool = s100 == s555+  s614 :: SWord8 = if s613 then s610 else s609+  s615 :: SWord8 = s33 + s614+  s616 :: SWord8 = if s612 then s615 else s614+  s617 :: SBool = s105 == s555+  s618 :: SWord8 = if s617 then s610 else s609+  s619 :: SWord8 = s33 + s618+  s620 :: SWord8 = if s613 then s619 else s618+  s621 :: SWord8 = s33 + s620+  s622 :: SWord8 = if s612 then s621 else s620+  s623 :: SWord8 = if s96 then s616 else s622+  s624 :: SWord8 = if s24 then s611 else s623+  s625 :: SWord8 = s33 + s624+  s626 :: SWord8 = if s561 then s625 else s624+  s627 :: SBool = s117 == s555+  s628 :: SBool = s120 == s555+  s629 :: SWord8 = if s628 then s625 else s624+  s630 :: SWord8 = s33 + s629+  s631 :: SWord8 = if s627 then s630 else s629+  s632 :: SBool = s125 == s555+  s633 :: SWord8 = if s632 then s625 else s624+  s634 :: SWord8 = s33 + s633+  s635 :: SWord8 = if s628 then s634 else s633+  s636 :: SWord8 = s33 + s635+  s637 :: SWord8 = if s627 then s636 else s635+  s638 :: SWord8 = if s116 then s631 else s637+  s639 :: SWord8 = if s22 then s626 else s638+  s640 :: SWord8 = s33 + s639+  s641 :: SWord8 = if s560 then s640 else s639+  s642 :: SBool = s137 == s555+  s643 :: SBool = s140 == s555+  s644 :: SWord8 = if s643 then s640 else s639+  s645 :: SWord8 = s33 + s644+  s646 :: SWord8 = if s642 then s645 else s644+  s647 :: SBool = s145 == s555+  s648 :: SWord8 = if s647 then s640 else s639+  s649 :: SWord8 = s33 + s648+  s650 :: SWord8 = if s643 then s649 else s648+  s651 :: SWord8 = s33 + s650+  s652 :: SWord8 = if s642 then s651 else s650+  s653 :: SWord8 = if s136 then s646 else s652+  s654 :: SWord8 = if s20 then s641 else s653+  s655 :: SWord8 = s33 + s654+  s656 :: SWord8 = if s559 then s655 else s654+  s657 :: SBool = s157 == s555+  s658 :: SBool = s160 == s555+  s659 :: SWord8 = if s658 then s655 else s654+  s660 :: SWord8 = s33 + s659+  s661 :: SWord8 = if s657 then s660 else s659+  s662 :: SBool = s165 == s555+  s663 :: SWord8 = if s662 then s655 else s654+  s664 :: SWord8 = s33 + s663+  s665 :: SWord8 = if s658 then s664 else s663+  s666 :: SWord8 = s33 + s665+  s667 :: SWord8 = if s657 then s666 else s665+  s668 :: SWord8 = if s156 then s661 else s667+  s669 :: SWord8 = if s18 then s656 else s668+  s670 :: SWord8 = s33 + s669+  s671 :: SWord8 = if s558 then s670 else s669+  s672 :: SBool = s177 == s555+  s673 :: SBool = s180 == s555+  s674 :: SWord8 = if s673 then s670 else s669+  s675 :: SWord8 = s33 + s674+  s676 :: SWord8 = if s672 then s675 else s674+  s677 :: SBool = s185 == s555+  s678 :: SWord8 = if s677 then s670 else s669+  s679 :: SWord8 = s33 + s678+  s680 :: SWord8 = if s673 then s679 else s678+  s681 :: SWord8 = s33 + s680+  s682 :: SWord8 = if s672 then s681 else s680+  s683 :: SWord8 = if s176 then s676 else s682+  s684 :: SWord8 = if s16 then s671 else s683+  s685 :: SWord8 = s33 + s684+  s686 :: SWord8 = if s557 then s685 else s684+  s687 :: SBool = s197 == s555+  s688 :: SBool = s200 == s555+  s689 :: SWord8 = if s688 then s685 else s684+  s690 :: SWord8 = s33 + s689+  s691 :: SWord8 = if s687 then s690 else s689+  s692 :: SBool = s205 == s555+  s693 :: SWord8 = if s692 then s685 else s684+  s694 :: SWord8 = s33 + s693+  s695 :: SWord8 = if s688 then s694 else s693+  s696 :: SWord8 = s33 + s695+  s697 :: SWord8 = if s687 then s696 else s695+  s698 :: SWord8 = if s196 then s691 else s697+  s699 :: SWord8 = if s14 then s686 else s698+  s700 :: SWord8 = s33 + s699+  s701 :: SWord8 = if s556 then s700 else s699+  s702 :: SBool = s217 == s555+  s703 :: SBool = s220 == s555+  s704 :: SWord8 = if s703 then s700 else s699+  s705 :: SWord8 = s33 + s704+  s706 :: SWord8 = if s702 then s705 else s704+  s707 :: SBool = s225 == s555+  s708 :: SWord8 = if s707 then s700 else s699+  s709 :: SWord8 = s33 + s708+  s710 :: SWord8 = if s703 then s709 else s708+  s711 :: SWord8 = s33 + s710+  s712 :: SWord8 = if s702 then s711 else s710+  s713 :: SWord8 = if s216 then s706 else s712+  s714 :: SWord8 = if s11 then s701 else s713+  s715 :: SBool = s3 == s714+  s717 :: SBool = s9 == s716+  s718 :: SBool = s8 == s716+  s719 :: SBool = s7 == s716+  s720 :: SBool = s6 == s716+  s721 :: SBool = s5 == s716+  s722 :: SBool = s4 == s716+  s723 :: SBool = s3 == s716+  s724 :: SBool = s2 == s716+  s725 :: SBool = s1 == s716+  s726 :: SBool = s0 == s716+  s727 :: SWord8 = if s726 then s32 else s33+  s728 :: SBool = s37 == s716+  s729 :: SBool = s40 == s716+  s730 :: SWord8 = if s729 then s32 else s33+  s731 :: SWord8 = s33 + s730+  s732 :: SWord8 = if s728 then s731 else s730+  s733 :: SBool = s45 == s716+  s734 :: SWord8 = if s733 then s32 else s33+  s735 :: SWord8 = s33 + s734+  s736 :: SWord8 = if s729 then s735 else s734+  s737 :: SWord8 = s33 + s736+  s738 :: SWord8 = if s728 then s737 else s736+  s739 :: SWord8 = if s36 then s732 else s738+  s740 :: SWord8 = if s30 then s727 else s739+  s741 :: SWord8 = s33 + s740+  s742 :: SWord8 = if s725 then s741 else s740+  s743 :: SBool = s57 == s716+  s744 :: SBool = s60 == s716+  s745 :: SWord8 = if s744 then s741 else s740+  s746 :: SWord8 = s33 + s745+  s747 :: SWord8 = if s743 then s746 else s745+  s748 :: SBool = s65 == s716+  s749 :: SWord8 = if s748 then s741 else s740+  s750 :: SWord8 = s33 + s749+  s751 :: SWord8 = if s744 then s750 else s749+  s752 :: SWord8 = s33 + s751+  s753 :: SWord8 = if s743 then s752 else s751+  s754 :: SWord8 = if s56 then s747 else s753+  s755 :: SWord8 = if s28 then s742 else s754+  s756 :: SWord8 = s33 + s755+  s757 :: SWord8 = if s724 then s756 else s755+  s758 :: SBool = s77 == s716+  s759 :: SBool = s80 == s716+  s760 :: SWord8 = if s759 then s756 else s755+  s761 :: SWord8 = s33 + s760+  s762 :: SWord8 = if s758 then s761 else s760+  s763 :: SBool = s85 == s716+  s764 :: SWord8 = if s763 then s756 else s755+  s765 :: SWord8 = s33 + s764+  s766 :: SWord8 = if s759 then s765 else s764+  s767 :: SWord8 = s33 + s766+  s768 :: SWord8 = if s758 then s767 else s766+  s769 :: SWord8 = if s76 then s762 else s768+  s770 :: SWord8 = if s26 then s757 else s769+  s771 :: SWord8 = s33 + s770+  s772 :: SWord8 = if s723 then s771 else s770+  s773 :: SBool = s97 == s716+  s774 :: SBool = s100 == s716+  s775 :: SWord8 = if s774 then s771 else s770+  s776 :: SWord8 = s33 + s775+  s777 :: SWord8 = if s773 then s776 else s775+  s778 :: SBool = s105 == s716+  s779 :: SWord8 = if s778 then s771 else s770+  s780 :: SWord8 = s33 + s779+  s781 :: SWord8 = if s774 then s780 else s779+  s782 :: SWord8 = s33 + s781+  s783 :: SWord8 = if s773 then s782 else s781+  s784 :: SWord8 = if s96 then s777 else s783+  s785 :: SWord8 = if s24 then s772 else s784+  s786 :: SWord8 = s33 + s785+  s787 :: SWord8 = if s722 then s786 else s785+  s788 :: SBool = s117 == s716+  s789 :: SBool = s120 == s716+  s790 :: SWord8 = if s789 then s786 else s785+  s791 :: SWord8 = s33 + s790+  s792 :: SWord8 = if s788 then s791 else s790+  s793 :: SBool = s125 == s716+  s794 :: SWord8 = if s793 then s786 else s785+  s795 :: SWord8 = s33 + s794+  s796 :: SWord8 = if s789 then s795 else s794+  s797 :: SWord8 = s33 + s796+  s798 :: SWord8 = if s788 then s797 else s796+  s799 :: SWord8 = if s116 then s792 else s798+  s800 :: SWord8 = if s22 then s787 else s799+  s801 :: SWord8 = s33 + s800+  s802 :: SWord8 = if s721 then s801 else s800+  s803 :: SBool = s137 == s716+  s804 :: SBool = s140 == s716+  s805 :: SWord8 = if s804 then s801 else s800+  s806 :: SWord8 = s33 + s805+  s807 :: SWord8 = if s803 then s806 else s805+  s808 :: SBool = s145 == s716+  s809 :: SWord8 = if s808 then s801 else s800+  s810 :: SWord8 = s33 + s809+  s811 :: SWord8 = if s804 then s810 else s809+  s812 :: SWord8 = s33 + s811+  s813 :: SWord8 = if s803 then s812 else s811+  s814 :: SWord8 = if s136 then s807 else s813+  s815 :: SWord8 = if s20 then s802 else s814+  s816 :: SWord8 = s33 + s815+  s817 :: SWord8 = if s720 then s816 else s815+  s818 :: SBool = s157 == s716+  s819 :: SBool = s160 == s716+  s820 :: SWord8 = if s819 then s816 else s815+  s821 :: SWord8 = s33 + s820+  s822 :: SWord8 = if s818 then s821 else s820+  s823 :: SBool = s165 == s716+  s824 :: SWord8 = if s823 then s816 else s815+  s825 :: SWord8 = s33 + s824+  s826 :: SWord8 = if s819 then s825 else s824+  s827 :: SWord8 = s33 + s826+  s828 :: SWord8 = if s818 then s827 else s826+  s829 :: SWord8 = if s156 then s822 else s828+  s830 :: SWord8 = if s18 then s817 else s829+  s831 :: SWord8 = s33 + s830+  s832 :: SWord8 = if s719 then s831 else s830+  s833 :: SBool = s177 == s716+  s834 :: SBool = s180 == s716+  s835 :: SWord8 = if s834 then s831 else s830+  s836 :: SWord8 = s33 + s835+  s837 :: SWord8 = if s833 then s836 else s835+  s838 :: SBool = s185 == s716+  s839 :: SWord8 = if s838 then s831 else s830+  s840 :: SWord8 = s33 + s839+  s841 :: SWord8 = if s834 then s840 else s839+  s842 :: SWord8 = s33 + s841+  s843 :: SWord8 = if s833 then s842 else s841+  s844 :: SWord8 = if s176 then s837 else s843+  s845 :: SWord8 = if s16 then s832 else s844+  s846 :: SWord8 = s33 + s845+  s847 :: SWord8 = if s718 then s846 else s845+  s848 :: SBool = s197 == s716+  s849 :: SBool = s200 == s716+  s850 :: SWord8 = if s849 then s846 else s845+  s851 :: SWord8 = s33 + s850+  s852 :: SWord8 = if s848 then s851 else s850+  s853 :: SBool = s205 == s716+  s854 :: SWord8 = if s853 then s846 else s845+  s855 :: SWord8 = s33 + s854+  s856 :: SWord8 = if s849 then s855 else s854+  s857 :: SWord8 = s33 + s856+  s858 :: SWord8 = if s848 then s857 else s856+  s859 :: SWord8 = if s196 then s852 else s858+  s860 :: SWord8 = if s14 then s847 else s859+  s861 :: SWord8 = s33 + s860+  s862 :: SWord8 = if s717 then s861 else s860+  s863 :: SBool = s217 == s716+  s864 :: SBool = s220 == s716+  s865 :: SWord8 = if s864 then s861 else s860+  s866 :: SWord8 = s33 + s865+  s867 :: SWord8 = if s863 then s866 else s865+  s868 :: SBool = s225 == s716+  s869 :: SWord8 = if s868 then s861 else s860+  s870 :: SWord8 = s33 + s869+  s871 :: SWord8 = if s864 then s870 else s869+  s872 :: SWord8 = s33 + s871+  s873 :: SWord8 = if s863 then s872 else s871+  s874 :: SWord8 = if s216 then s867 else s873+  s875 :: SWord8 = if s11 then s862 else s874+  s876 :: SBool = s4 == s875+  s878 :: SBool = s9 == s877+  s879 :: SBool = s8 == s877+  s880 :: SBool = s7 == s877+  s881 :: SBool = s6 == s877+  s882 :: SBool = s5 == s877+  s883 :: SBool = s4 == s877+  s884 :: SBool = s3 == s877+  s885 :: SBool = s2 == s877+  s886 :: SBool = s1 == s877+  s887 :: SBool = s0 == s877+  s888 :: SWord8 = if s887 then s32 else s33+  s889 :: SBool = s37 == s877+  s890 :: SBool = s40 == s877+  s891 :: SWord8 = if s890 then s32 else s33+  s892 :: SWord8 = s33 + s891+  s893 :: SWord8 = if s889 then s892 else s891+  s894 :: SBool = s45 == s877+  s895 :: SWord8 = if s894 then s32 else s33+  s896 :: SWord8 = s33 + s895+  s897 :: SWord8 = if s890 then s896 else s895+  s898 :: SWord8 = s33 + s897+  s899 :: SWord8 = if s889 then s898 else s897+  s900 :: SWord8 = if s36 then s893 else s899+  s901 :: SWord8 = if s30 then s888 else s900+  s902 :: SWord8 = s33 + s901+  s903 :: SWord8 = if s886 then s902 else s901+  s904 :: SBool = s57 == s877+  s905 :: SBool = s60 == s877+  s906 :: SWord8 = if s905 then s902 else s901+  s907 :: SWord8 = s33 + s906+  s908 :: SWord8 = if s904 then s907 else s906+  s909 :: SBool = s65 == s877+  s910 :: SWord8 = if s909 then s902 else s901+  s911 :: SWord8 = s33 + s910+  s912 :: SWord8 = if s905 then s911 else s910+  s913 :: SWord8 = s33 + s912+  s914 :: SWord8 = if s904 then s913 else s912+  s915 :: SWord8 = if s56 then s908 else s914+  s916 :: SWord8 = if s28 then s903 else s915+  s917 :: SWord8 = s33 + s916+  s918 :: SWord8 = if s885 then s917 else s916+  s919 :: SBool = s77 == s877+  s920 :: SBool = s80 == s877+  s921 :: SWord8 = if s920 then s917 else s916+  s922 :: SWord8 = s33 + s921+  s923 :: SWord8 = if s919 then s922 else s921+  s924 :: SBool = s85 == s877+  s925 :: SWord8 = if s924 then s917 else s916+  s926 :: SWord8 = s33 + s925+  s927 :: SWord8 = if s920 then s926 else s925+  s928 :: SWord8 = s33 + s927+  s929 :: SWord8 = if s919 then s928 else s927+  s930 :: SWord8 = if s76 then s923 else s929+  s931 :: SWord8 = if s26 then s918 else s930+  s932 :: SWord8 = s33 + s931+  s933 :: SWord8 = if s884 then s932 else s931+  s934 :: SBool = s97 == s877+  s935 :: SBool = s100 == s877+  s936 :: SWord8 = if s935 then s932 else s931+  s937 :: SWord8 = s33 + s936+  s938 :: SWord8 = if s934 then s937 else s936+  s939 :: SBool = s105 == s877+  s940 :: SWord8 = if s939 then s932 else s931+  s941 :: SWord8 = s33 + s940+  s942 :: SWord8 = if s935 then s941 else s940+  s943 :: SWord8 = s33 + s942+  s944 :: SWord8 = if s934 then s943 else s942+  s945 :: SWord8 = if s96 then s938 else s944+  s946 :: SWord8 = if s24 then s933 else s945+  s947 :: SWord8 = s33 + s946+  s948 :: SWord8 = if s883 then s947 else s946+  s949 :: SBool = s117 == s877+  s950 :: SBool = s120 == s877+  s951 :: SWord8 = if s950 then s947 else s946+  s952 :: SWord8 = s33 + s951+  s953 :: SWord8 = if s949 then s952 else s951+  s954 :: SBool = s125 == s877+  s955 :: SWord8 = if s954 then s947 else s946+  s956 :: SWord8 = s33 + s955+  s957 :: SWord8 = if s950 then s956 else s955+  s958 :: SWord8 = s33 + s957+  s959 :: SWord8 = if s949 then s958 else s957+  s960 :: SWord8 = if s116 then s953 else s959+  s961 :: SWord8 = if s22 then s948 else s960+  s962 :: SWord8 = s33 + s961+  s963 :: SWord8 = if s882 then s962 else s961+  s964 :: SBool = s137 == s877+  s965 :: SBool = s140 == s877+  s966 :: SWord8 = if s965 then s962 else s961+  s967 :: SWord8 = s33 + s966+  s968 :: SWord8 = if s964 then s967 else s966+  s969 :: SBool = s145 == s877+  s970 :: SWord8 = if s969 then s962 else s961+  s971 :: SWord8 = s33 + s970+  s972 :: SWord8 = if s965 then s971 else s970+  s973 :: SWord8 = s33 + s972+  s974 :: SWord8 = if s964 then s973 else s972+  s975 :: SWord8 = if s136 then s968 else s974+  s976 :: SWord8 = if s20 then s963 else s975+  s977 :: SWord8 = s33 + s976+  s978 :: SWord8 = if s881 then s977 else s976+  s979 :: SBool = s157 == s877+  s980 :: SBool = s160 == s877+  s981 :: SWord8 = if s980 then s977 else s976+  s982 :: SWord8 = s33 + s981+  s983 :: SWord8 = if s979 then s982 else s981+  s984 :: SBool = s165 == s877+  s985 :: SWord8 = if s984 then s977 else s976+  s986 :: SWord8 = s33 + s985+  s987 :: SWord8 = if s980 then s986 else s985+  s988 :: SWord8 = s33 + s987+  s989 :: SWord8 = if s979 then s988 else s987+  s990 :: SWord8 = if s156 then s983 else s989+  s991 :: SWord8 = if s18 then s978 else s990+  s992 :: SWord8 = s33 + s991+  s993 :: SWord8 = if s880 then s992 else s991+  s994 :: SBool = s177 == s877+  s995 :: SBool = s180 == s877+  s996 :: SWord8 = if s995 then s992 else s991+  s997 :: SWord8 = s33 + s996+  s998 :: SWord8 = if s994 then s997 else s996+  s999 :: SBool = s185 == s877+  s1000 :: SWord8 = if s999 then s992 else s991+  s1001 :: SWord8 = s33 + s1000+  s1002 :: SWord8 = if s995 then s1001 else s1000+  s1003 :: SWord8 = s33 + s1002+  s1004 :: SWord8 = if s994 then s1003 else s1002+  s1005 :: SWord8 = if s176 then s998 else s1004+  s1006 :: SWord8 = if s16 then s993 else s1005+  s1007 :: SWord8 = s33 + s1006+  s1008 :: SWord8 = if s879 then s1007 else s1006+  s1009 :: SBool = s197 == s877+  s1010 :: SBool = s200 == s877+  s1011 :: SWord8 = if s1010 then s1007 else s1006+  s1012 :: SWord8 = s33 + s1011+  s1013 :: SWord8 = if s1009 then s1012 else s1011+  s1014 :: SBool = s205 == s877+  s1015 :: SWord8 = if s1014 then s1007 else s1006+  s1016 :: SWord8 = s33 + s1015+  s1017 :: SWord8 = if s1010 then s1016 else s1015+  s1018 :: SWord8 = s33 + s1017+  s1019 :: SWord8 = if s1009 then s1018 else s1017+  s1020 :: SWord8 = if s196 then s1013 else s1019+  s1021 :: SWord8 = if s14 then s1008 else s1020+  s1022 :: SWord8 = s33 + s1021+  s1023 :: SWord8 = if s878 then s1022 else s1021+  s1024 :: SBool = s217 == s877+  s1025 :: SBool = s220 == s877+  s1026 :: SWord8 = if s1025 then s1022 else s1021+  s1027 :: SWord8 = s33 + s1026+  s1028 :: SWord8 = if s1024 then s1027 else s1026+  s1029 :: SBool = s225 == s877+  s1030 :: SWord8 = if s1029 then s1022 else s1021+  s1031 :: SWord8 = s33 + s1030+  s1032 :: SWord8 = if s1025 then s1031 else s1030+  s1033 :: SWord8 = s33 + s1032+  s1034 :: SWord8 = if s1024 then s1033 else s1032+  s1035 :: SWord8 = if s216 then s1028 else s1034+  s1036 :: SWord8 = if s11 then s1023 else s1035+  s1037 :: SBool = s5 == s1036+  s1039 :: SBool = s9 == s1038+  s1040 :: SBool = s8 == s1038+  s1041 :: SBool = s7 == s1038+  s1042 :: SBool = s6 == s1038+  s1043 :: SBool = s5 == s1038+  s1044 :: SBool = s4 == s1038+  s1045 :: SBool = s3 == s1038+  s1046 :: SBool = s2 == s1038+  s1047 :: SBool = s1 == s1038+  s1048 :: SBool = s0 == s1038+  s1049 :: SWord8 = if s1048 then s32 else s33+  s1050 :: SBool = s37 == s1038+  s1051 :: SBool = s40 == s1038+  s1052 :: SWord8 = if s1051 then s32 else s33+  s1053 :: SWord8 = s33 + s1052+  s1054 :: SWord8 = if s1050 then s1053 else s1052+  s1055 :: SBool = s45 == s1038+  s1056 :: SWord8 = if s1055 then s32 else s33+  s1057 :: SWord8 = s33 + s1056+  s1058 :: SWord8 = if s1051 then s1057 else s1056+  s1059 :: SWord8 = s33 + s1058+  s1060 :: SWord8 = if s1050 then s1059 else s1058+  s1061 :: SWord8 = if s36 then s1054 else s1060+  s1062 :: SWord8 = if s30 then s1049 else s1061+  s1063 :: SWord8 = s33 + s1062+  s1064 :: SWord8 = if s1047 then s1063 else s1062+  s1065 :: SBool = s57 == s1038+  s1066 :: SBool = s60 == s1038+  s1067 :: SWord8 = if s1066 then s1063 else s1062+  s1068 :: SWord8 = s33 + s1067+  s1069 :: SWord8 = if s1065 then s1068 else s1067+  s1070 :: SBool = s65 == s1038+  s1071 :: SWord8 = if s1070 then s1063 else s1062+  s1072 :: SWord8 = s33 + s1071+  s1073 :: SWord8 = if s1066 then s1072 else s1071+  s1074 :: SWord8 = s33 + s1073+  s1075 :: SWord8 = if s1065 then s1074 else s1073+  s1076 :: SWord8 = if s56 then s1069 else s1075+  s1077 :: SWord8 = if s28 then s1064 else s1076+  s1078 :: SWord8 = s33 + s1077+  s1079 :: SWord8 = if s1046 then s1078 else s1077+  s1080 :: SBool = s77 == s1038+  s1081 :: SBool = s80 == s1038+  s1082 :: SWord8 = if s1081 then s1078 else s1077+  s1083 :: SWord8 = s33 + s1082+  s1084 :: SWord8 = if s1080 then s1083 else s1082+  s1085 :: SBool = s85 == s1038+  s1086 :: SWord8 = if s1085 then s1078 else s1077+  s1087 :: SWord8 = s33 + s1086+  s1088 :: SWord8 = if s1081 then s1087 else s1086+  s1089 :: SWord8 = s33 + s1088+  s1090 :: SWord8 = if s1080 then s1089 else s1088+  s1091 :: SWord8 = if s76 then s1084 else s1090+  s1092 :: SWord8 = if s26 then s1079 else s1091+  s1093 :: SWord8 = s33 + s1092+  s1094 :: SWord8 = if s1045 then s1093 else s1092+  s1095 :: SBool = s97 == s1038+  s1096 :: SBool = s100 == s1038+  s1097 :: SWord8 = if s1096 then s1093 else s1092+  s1098 :: SWord8 = s33 + s1097+  s1099 :: SWord8 = if s1095 then s1098 else s1097+  s1100 :: SBool = s105 == s1038+  s1101 :: SWord8 = if s1100 then s1093 else s1092+  s1102 :: SWord8 = s33 + s1101+  s1103 :: SWord8 = if s1096 then s1102 else s1101+  s1104 :: SWord8 = s33 + s1103+  s1105 :: SWord8 = if s1095 then s1104 else s1103+  s1106 :: SWord8 = if s96 then s1099 else s1105+  s1107 :: SWord8 = if s24 then s1094 else s1106+  s1108 :: SWord8 = s33 + s1107+  s1109 :: SWord8 = if s1044 then s1108 else s1107+  s1110 :: SBool = s117 == s1038+  s1111 :: SBool = s120 == s1038+  s1112 :: SWord8 = if s1111 then s1108 else s1107+  s1113 :: SWord8 = s33 + s1112+  s1114 :: SWord8 = if s1110 then s1113 else s1112+  s1115 :: SBool = s125 == s1038+  s1116 :: SWord8 = if s1115 then s1108 else s1107+  s1117 :: SWord8 = s33 + s1116+  s1118 :: SWord8 = if s1111 then s1117 else s1116+  s1119 :: SWord8 = s33 + s1118+  s1120 :: SWord8 = if s1110 then s1119 else s1118+  s1121 :: SWord8 = if s116 then s1114 else s1120+  s1122 :: SWord8 = if s22 then s1109 else s1121+  s1123 :: SWord8 = s33 + s1122+  s1124 :: SWord8 = if s1043 then s1123 else s1122+  s1125 :: SBool = s137 == s1038+  s1126 :: SBool = s140 == s1038+  s1127 :: SWord8 = if s1126 then s1123 else s1122+  s1128 :: SWord8 = s33 + s1127+  s1129 :: SWord8 = if s1125 then s1128 else s1127+  s1130 :: SBool = s145 == s1038+  s1131 :: SWord8 = if s1130 then s1123 else s1122+  s1132 :: SWord8 = s33 + s1131+  s1133 :: SWord8 = if s1126 then s1132 else s1131+  s1134 :: SWord8 = s33 + s1133+  s1135 :: SWord8 = if s1125 then s1134 else s1133+  s1136 :: SWord8 = if s136 then s1129 else s1135+  s1137 :: SWord8 = if s20 then s1124 else s1136+  s1138 :: SWord8 = s33 + s1137+  s1139 :: SWord8 = if s1042 then s1138 else s1137+  s1140 :: SBool = s157 == s1038+  s1141 :: SBool = s160 == s1038+  s1142 :: SWord8 = if s1141 then s1138 else s1137+  s1143 :: SWord8 = s33 + s1142+  s1144 :: SWord8 = if s1140 then s1143 else s1142+  s1145 :: SBool = s165 == s1038+  s1146 :: SWord8 = if s1145 then s1138 else s1137+  s1147 :: SWord8 = s33 + s1146+  s1148 :: SWord8 = if s1141 then s1147 else s1146+  s1149 :: SWord8 = s33 + s1148+  s1150 :: SWord8 = if s1140 then s1149 else s1148+  s1151 :: SWord8 = if s156 then s1144 else s1150+  s1152 :: SWord8 = if s18 then s1139 else s1151+  s1153 :: SWord8 = s33 + s1152+  s1154 :: SWord8 = if s1041 then s1153 else s1152+  s1155 :: SBool = s177 == s1038+  s1156 :: SBool = s180 == s1038+  s1157 :: SWord8 = if s1156 then s1153 else s1152+  s1158 :: SWord8 = s33 + s1157+  s1159 :: SWord8 = if s1155 then s1158 else s1157+  s1160 :: SBool = s185 == s1038+  s1161 :: SWord8 = if s1160 then s1153 else s1152+  s1162 :: SWord8 = s33 + s1161+  s1163 :: SWord8 = if s1156 then s1162 else s1161+  s1164 :: SWord8 = s33 + s1163+  s1165 :: SWord8 = if s1155 then s1164 else s1163+  s1166 :: SWord8 = if s176 then s1159 else s1165+  s1167 :: SWord8 = if s16 then s1154 else s1166+  s1168 :: SWord8 = s33 + s1167+  s1169 :: SWord8 = if s1040 then s1168 else s1167+  s1170 :: SBool = s197 == s1038+  s1171 :: SBool = s200 == s1038+  s1172 :: SWord8 = if s1171 then s1168 else s1167+  s1173 :: SWord8 = s33 + s1172+  s1174 :: SWord8 = if s1170 then s1173 else s1172+  s1175 :: SBool = s205 == s1038+  s1176 :: SWord8 = if s1175 then s1168 else s1167+  s1177 :: SWord8 = s33 + s1176+  s1178 :: SWord8 = if s1171 then s1177 else s1176+  s1179 :: SWord8 = s33 + s1178+  s1180 :: SWord8 = if s1170 then s1179 else s1178+  s1181 :: SWord8 = if s196 then s1174 else s1180+  s1182 :: SWord8 = if s14 then s1169 else s1181+  s1183 :: SWord8 = s33 + s1182+  s1184 :: SWord8 = if s1039 then s1183 else s1182+  s1185 :: SBool = s217 == s1038+  s1186 :: SBool = s220 == s1038+  s1187 :: SWord8 = if s1186 then s1183 else s1182+  s1188 :: SWord8 = s33 + s1187+  s1189 :: SWord8 = if s1185 then s1188 else s1187+  s1190 :: SBool = s225 == s1038+  s1191 :: SWord8 = if s1190 then s1183 else s1182+  s1192 :: SWord8 = s33 + s1191+  s1193 :: SWord8 = if s1186 then s1192 else s1191+  s1194 :: SWord8 = s33 + s1193+  s1195 :: SWord8 = if s1185 then s1194 else s1193+  s1196 :: SWord8 = if s216 then s1189 else s1195+  s1197 :: SWord8 = if s11 then s1184 else s1196+  s1198 :: SBool = s6 == s1197+  s1200 :: SBool = s9 == s1199+  s1201 :: SBool = s8 == s1199+  s1202 :: SBool = s7 == s1199+  s1203 :: SBool = s6 == s1199+  s1204 :: SBool = s5 == s1199+  s1205 :: SBool = s4 == s1199+  s1206 :: SBool = s3 == s1199+  s1207 :: SBool = s2 == s1199+  s1208 :: SBool = s1 == s1199+  s1209 :: SBool = s0 == s1199+  s1210 :: SWord8 = if s1209 then s32 else s33+  s1211 :: SBool = s37 == s1199+  s1212 :: SBool = s40 == s1199+  s1213 :: SWord8 = if s1212 then s32 else s33+  s1214 :: SWord8 = s33 + s1213+  s1215 :: SWord8 = if s1211 then s1214 else s1213+  s1216 :: SBool = s45 == s1199+  s1217 :: SWord8 = if s1216 then s32 else s33+  s1218 :: SWord8 = s33 + s1217+  s1219 :: SWord8 = if s1212 then s1218 else s1217+  s1220 :: SWord8 = s33 + s1219+  s1221 :: SWord8 = if s1211 then s1220 else s1219+  s1222 :: SWord8 = if s36 then s1215 else s1221+  s1223 :: SWord8 = if s30 then s1210 else s1222+  s1224 :: SWord8 = s33 + s1223+  s1225 :: SWord8 = if s1208 then s1224 else s1223+  s1226 :: SBool = s57 == s1199+  s1227 :: SBool = s60 == s1199+  s1228 :: SWord8 = if s1227 then s1224 else s1223+  s1229 :: SWord8 = s33 + s1228+  s1230 :: SWord8 = if s1226 then s1229 else s1228+  s1231 :: SBool = s65 == s1199+  s1232 :: SWord8 = if s1231 then s1224 else s1223+  s1233 :: SWord8 = s33 + s1232+  s1234 :: SWord8 = if s1227 then s1233 else s1232+  s1235 :: SWord8 = s33 + s1234+  s1236 :: SWord8 = if s1226 then s1235 else s1234+  s1237 :: SWord8 = if s56 then s1230 else s1236+  s1238 :: SWord8 = if s28 then s1225 else s1237+  s1239 :: SWord8 = s33 + s1238+  s1240 :: SWord8 = if s1207 then s1239 else s1238+  s1241 :: SBool = s77 == s1199+  s1242 :: SBool = s80 == s1199+  s1243 :: SWord8 = if s1242 then s1239 else s1238+  s1244 :: SWord8 = s33 + s1243+  s1245 :: SWord8 = if s1241 then s1244 else s1243+  s1246 :: SBool = s85 == s1199+  s1247 :: SWord8 = if s1246 then s1239 else s1238+  s1248 :: SWord8 = s33 + s1247+  s1249 :: SWord8 = if s1242 then s1248 else s1247+  s1250 :: SWord8 = s33 + s1249+  s1251 :: SWord8 = if s1241 then s1250 else s1249+  s1252 :: SWord8 = if s76 then s1245 else s1251+  s1253 :: SWord8 = if s26 then s1240 else s1252+  s1254 :: SWord8 = s33 + s1253+  s1255 :: SWord8 = if s1206 then s1254 else s1253+  s1256 :: SBool = s97 == s1199+  s1257 :: SBool = s100 == s1199+  s1258 :: SWord8 = if s1257 then s1254 else s1253+  s1259 :: SWord8 = s33 + s1258+  s1260 :: SWord8 = if s1256 then s1259 else s1258+  s1261 :: SBool = s105 == s1199+  s1262 :: SWord8 = if s1261 then s1254 else s1253+  s1263 :: SWord8 = s33 + s1262+  s1264 :: SWord8 = if s1257 then s1263 else s1262+  s1265 :: SWord8 = s33 + s1264+  s1266 :: SWord8 = if s1256 then s1265 else s1264+  s1267 :: SWord8 = if s96 then s1260 else s1266+  s1268 :: SWord8 = if s24 then s1255 else s1267+  s1269 :: SWord8 = s33 + s1268+  s1270 :: SWord8 = if s1205 then s1269 else s1268+  s1271 :: SBool = s117 == s1199+  s1272 :: SBool = s120 == s1199+  s1273 :: SWord8 = if s1272 then s1269 else s1268+  s1274 :: SWord8 = s33 + s1273+  s1275 :: SWord8 = if s1271 then s1274 else s1273+  s1276 :: SBool = s125 == s1199+  s1277 :: SWord8 = if s1276 then s1269 else s1268+  s1278 :: SWord8 = s33 + s1277+  s1279 :: SWord8 = if s1272 then s1278 else s1277+  s1280 :: SWord8 = s33 + s1279+  s1281 :: SWord8 = if s1271 then s1280 else s1279+  s1282 :: SWord8 = if s116 then s1275 else s1281+  s1283 :: SWord8 = if s22 then s1270 else s1282+  s1284 :: SWord8 = s33 + s1283+  s1285 :: SWord8 = if s1204 then s1284 else s1283+  s1286 :: SBool = s137 == s1199+  s1287 :: SBool = s140 == s1199+  s1288 :: SWord8 = if s1287 then s1284 else s1283+  s1289 :: SWord8 = s33 + s1288+  s1290 :: SWord8 = if s1286 then s1289 else s1288+  s1291 :: SBool = s145 == s1199+  s1292 :: SWord8 = if s1291 then s1284 else s1283+  s1293 :: SWord8 = s33 + s1292+  s1294 :: SWord8 = if s1287 then s1293 else s1292+  s1295 :: SWord8 = s33 + s1294+  s1296 :: SWord8 = if s1286 then s1295 else s1294+  s1297 :: SWord8 = if s136 then s1290 else s1296+  s1298 :: SWord8 = if s20 then s1285 else s1297+  s1299 :: SWord8 = s33 + s1298+  s1300 :: SWord8 = if s1203 then s1299 else s1298+  s1301 :: SBool = s157 == s1199+  s1302 :: SBool = s160 == s1199+  s1303 :: SWord8 = if s1302 then s1299 else s1298+  s1304 :: SWord8 = s33 + s1303+  s1305 :: SWord8 = if s1301 then s1304 else s1303+  s1306 :: SBool = s165 == s1199+  s1307 :: SWord8 = if s1306 then s1299 else s1298+  s1308 :: SWord8 = s33 + s1307+  s1309 :: SWord8 = if s1302 then s1308 else s1307+  s1310 :: SWord8 = s33 + s1309+  s1311 :: SWord8 = if s1301 then s1310 else s1309+  s1312 :: SWord8 = if s156 then s1305 else s1311+  s1313 :: SWord8 = if s18 then s1300 else s1312+  s1314 :: SWord8 = s33 + s1313+  s1315 :: SWord8 = if s1202 then s1314 else s1313+  s1316 :: SBool = s177 == s1199+  s1317 :: SBool = s180 == s1199+  s1318 :: SWord8 = if s1317 then s1314 else s1313+  s1319 :: SWord8 = s33 + s1318+  s1320 :: SWord8 = if s1316 then s1319 else s1318+  s1321 :: SBool = s185 == s1199+  s1322 :: SWord8 = if s1321 then s1314 else s1313+  s1323 :: SWord8 = s33 + s1322+  s1324 :: SWord8 = if s1317 then s1323 else s1322+  s1325 :: SWord8 = s33 + s1324+  s1326 :: SWord8 = if s1316 then s1325 else s1324+  s1327 :: SWord8 = if s176 then s1320 else s1326+  s1328 :: SWord8 = if s16 then s1315 else s1327+  s1329 :: SWord8 = s33 + s1328+  s1330 :: SWord8 = if s1201 then s1329 else s1328+  s1331 :: SBool = s197 == s1199+  s1332 :: SBool = s200 == s1199+  s1333 :: SWord8 = if s1332 then s1329 else s1328+  s1334 :: SWord8 = s33 + s1333+  s1335 :: SWord8 = if s1331 then s1334 else s1333+  s1336 :: SBool = s205 == s1199+  s1337 :: SWord8 = if s1336 then s1329 else s1328+  s1338 :: SWord8 = s33 + s1337+  s1339 :: SWord8 = if s1332 then s1338 else s1337+  s1340 :: SWord8 = s33 + s1339+  s1341 :: SWord8 = if s1331 then s1340 else s1339+  s1342 :: SWord8 = if s196 then s1335 else s1341+  s1343 :: SWord8 = if s14 then s1330 else s1342+  s1344 :: SWord8 = s33 + s1343+  s1345 :: SWord8 = if s1200 then s1344 else s1343+  s1346 :: SBool = s217 == s1199+  s1347 :: SBool = s220 == s1199+  s1348 :: SWord8 = if s1347 then s1344 else s1343+  s1349 :: SWord8 = s33 + s1348+  s1350 :: SWord8 = if s1346 then s1349 else s1348+  s1351 :: SBool = s225 == s1199+  s1352 :: SWord8 = if s1351 then s1344 else s1343+  s1353 :: SWord8 = s33 + s1352+  s1354 :: SWord8 = if s1347 then s1353 else s1352+  s1355 :: SWord8 = s33 + s1354+  s1356 :: SWord8 = if s1346 then s1355 else s1354+  s1357 :: SWord8 = if s216 then s1350 else s1356+  s1358 :: SWord8 = if s11 then s1345 else s1357+  s1359 :: SBool = s7 == s1358+  s1361 :: SBool = s9 == s1360+  s1362 :: SBool = s8 == s1360+  s1363 :: SBool = s7 == s1360+  s1364 :: SBool = s6 == s1360+  s1365 :: SBool = s5 == s1360+  s1366 :: SBool = s4 == s1360+  s1367 :: SBool = s3 == s1360+  s1368 :: SBool = s2 == s1360+  s1369 :: SBool = s1 == s1360+  s1370 :: SBool = s0 == s1360+  s1371 :: SWord8 = if s1370 then s32 else s33+  s1372 :: SBool = s37 == s1360+  s1373 :: SBool = s40 == s1360+  s1374 :: SWord8 = if s1373 then s32 else s33+  s1375 :: SWord8 = s33 + s1374+  s1376 :: SWord8 = if s1372 then s1375 else s1374+  s1377 :: SBool = s45 == s1360+  s1378 :: SWord8 = if s1377 then s32 else s33+  s1379 :: SWord8 = s33 + s1378+  s1380 :: SWord8 = if s1373 then s1379 else s1378+  s1381 :: SWord8 = s33 + s1380+  s1382 :: SWord8 = if s1372 then s1381 else s1380+  s1383 :: SWord8 = if s36 then s1376 else s1382+  s1384 :: SWord8 = if s30 then s1371 else s1383+  s1385 :: SWord8 = s33 + s1384+  s1386 :: SWord8 = if s1369 then s1385 else s1384+  s1387 :: SBool = s57 == s1360+  s1388 :: SBool = s60 == s1360+  s1389 :: SWord8 = if s1388 then s1385 else s1384+  s1390 :: SWord8 = s33 + s1389+  s1391 :: SWord8 = if s1387 then s1390 else s1389+  s1392 :: SBool = s65 == s1360+  s1393 :: SWord8 = if s1392 then s1385 else s1384+  s1394 :: SWord8 = s33 + s1393+  s1395 :: SWord8 = if s1388 then s1394 else s1393+  s1396 :: SWord8 = s33 + s1395+  s1397 :: SWord8 = if s1387 then s1396 else s1395+  s1398 :: SWord8 = if s56 then s1391 else s1397+  s1399 :: SWord8 = if s28 then s1386 else s1398+  s1400 :: SWord8 = s33 + s1399+  s1401 :: SWord8 = if s1368 then s1400 else s1399+  s1402 :: SBool = s77 == s1360+  s1403 :: SBool = s80 == s1360+  s1404 :: SWord8 = if s1403 then s1400 else s1399+  s1405 :: SWord8 = s33 + s1404+  s1406 :: SWord8 = if s1402 then s1405 else s1404+  s1407 :: SBool = s85 == s1360+  s1408 :: SWord8 = if s1407 then s1400 else s1399+  s1409 :: SWord8 = s33 + s1408+  s1410 :: SWord8 = if s1403 then s1409 else s1408+  s1411 :: SWord8 = s33 + s1410+  s1412 :: SWord8 = if s1402 then s1411 else s1410+  s1413 :: SWord8 = if s76 then s1406 else s1412+  s1414 :: SWord8 = if s26 then s1401 else s1413+  s1415 :: SWord8 = s33 + s1414+  s1416 :: SWord8 = if s1367 then s1415 else s1414+  s1417 :: SBool = s97 == s1360+  s1418 :: SBool = s100 == s1360+  s1419 :: SWord8 = if s1418 then s1415 else s1414+  s1420 :: SWord8 = s33 + s1419+  s1421 :: SWord8 = if s1417 then s1420 else s1419+  s1422 :: SBool = s105 == s1360+  s1423 :: SWord8 = if s1422 then s1415 else s1414+  s1424 :: SWord8 = s33 + s1423+  s1425 :: SWord8 = if s1418 then s1424 else s1423+  s1426 :: SWord8 = s33 + s1425+  s1427 :: SWord8 = if s1417 then s1426 else s1425+  s1428 :: SWord8 = if s96 then s1421 else s1427+  s1429 :: SWord8 = if s24 then s1416 else s1428+  s1430 :: SWord8 = s33 + s1429+  s1431 :: SWord8 = if s1366 then s1430 else s1429+  s1432 :: SBool = s117 == s1360+  s1433 :: SBool = s120 == s1360+  s1434 :: SWord8 = if s1433 then s1430 else s1429+  s1435 :: SWord8 = s33 + s1434+  s1436 :: SWord8 = if s1432 then s1435 else s1434+  s1437 :: SBool = s125 == s1360+  s1438 :: SWord8 = if s1437 then s1430 else s1429+  s1439 :: SWord8 = s33 + s1438+  s1440 :: SWord8 = if s1433 then s1439 else s1438+  s1441 :: SWord8 = s33 + s1440+  s1442 :: SWord8 = if s1432 then s1441 else s1440+  s1443 :: SWord8 = if s116 then s1436 else s1442+  s1444 :: SWord8 = if s22 then s1431 else s1443+  s1445 :: SWord8 = s33 + s1444+  s1446 :: SWord8 = if s1365 then s1445 else s1444+  s1447 :: SBool = s137 == s1360+  s1448 :: SBool = s140 == s1360+  s1449 :: SWord8 = if s1448 then s1445 else s1444+  s1450 :: SWord8 = s33 + s1449+  s1451 :: SWord8 = if s1447 then s1450 else s1449+  s1452 :: SBool = s145 == s1360+  s1453 :: SWord8 = if s1452 then s1445 else s1444+  s1454 :: SWord8 = s33 + s1453+  s1455 :: SWord8 = if s1448 then s1454 else s1453+  s1456 :: SWord8 = s33 + s1455+  s1457 :: SWord8 = if s1447 then s1456 else s1455+  s1458 :: SWord8 = if s136 then s1451 else s1457+  s1459 :: SWord8 = if s20 then s1446 else s1458+  s1460 :: SWord8 = s33 + s1459+  s1461 :: SWord8 = if s1364 then s1460 else s1459+  s1462 :: SBool = s157 == s1360+  s1463 :: SBool = s160 == s1360+  s1464 :: SWord8 = if s1463 then s1460 else s1459+  s1465 :: SWord8 = s33 + s1464+  s1466 :: SWord8 = if s1462 then s1465 else s1464+  s1467 :: SBool = s165 == s1360+  s1468 :: SWord8 = if s1467 then s1460 else s1459+  s1469 :: SWord8 = s33 + s1468+  s1470 :: SWord8 = if s1463 then s1469 else s1468+  s1471 :: SWord8 = s33 + s1470+  s1472 :: SWord8 = if s1462 then s1471 else s1470+  s1473 :: SWord8 = if s156 then s1466 else s1472+  s1474 :: SWord8 = if s18 then s1461 else s1473+  s1475 :: SWord8 = s33 + s1474+  s1476 :: SWord8 = if s1363 then s1475 else s1474+  s1477 :: SBool = s177 == s1360+  s1478 :: SBool = s180 == s1360+  s1479 :: SWord8 = if s1478 then s1475 else s1474+  s1480 :: SWord8 = s33 + s1479+  s1481 :: SWord8 = if s1477 then s1480 else s1479+  s1482 :: SBool = s185 == s1360+  s1483 :: SWord8 = if s1482 then s1475 else s1474+  s1484 :: SWord8 = s33 + s1483+  s1485 :: SWord8 = if s1478 then s1484 else s1483+  s1486 :: SWord8 = s33 + s1485+  s1487 :: SWord8 = if s1477 then s1486 else s1485+  s1488 :: SWord8 = if s176 then s1481 else s1487+  s1489 :: SWord8 = if s16 then s1476 else s1488+  s1490 :: SWord8 = s33 + s1489+  s1491 :: SWord8 = if s1362 then s1490 else s1489+  s1492 :: SBool = s197 == s1360+  s1493 :: SBool = s200 == s1360+  s1494 :: SWord8 = if s1493 then s1490 else s1489+  s1495 :: SWord8 = s33 + s1494+  s1496 :: SWord8 = if s1492 then s1495 else s1494+  s1497 :: SBool = s205 == s1360+  s1498 :: SWord8 = if s1497 then s1490 else s1489+  s1499 :: SWord8 = s33 + s1498+  s1500 :: SWord8 = if s1493 then s1499 else s1498+  s1501 :: SWord8 = s33 + s1500+  s1502 :: SWord8 = if s1492 then s1501 else s1500+  s1503 :: SWord8 = if s196 then s1496 else s1502+  s1504 :: SWord8 = if s14 then s1491 else s1503+  s1505 :: SWord8 = s33 + s1504+  s1506 :: SWord8 = if s1361 then s1505 else s1504+  s1507 :: SBool = s217 == s1360+  s1508 :: SBool = s220 == s1360+  s1509 :: SWord8 = if s1508 then s1505 else s1504+  s1510 :: SWord8 = s33 + s1509+  s1511 :: SWord8 = if s1507 then s1510 else s1509+  s1512 :: SBool = s225 == s1360+  s1513 :: SWord8 = if s1512 then s1505 else s1504+  s1514 :: SWord8 = s33 + s1513+  s1515 :: SWord8 = if s1508 then s1514 else s1513+  s1516 :: SWord8 = s33 + s1515+  s1517 :: SWord8 = if s1507 then s1516 else s1515+  s1518 :: SWord8 = if s216 then s1511 else s1517+  s1519 :: SWord8 = if s11 then s1506 else s1518+  s1520 :: SBool = s8 == s1519+  s1522 :: SBool = s9 == s1521+  s1523 :: SBool = s8 == s1521+  s1524 :: SBool = s7 == s1521+  s1525 :: SBool = s6 == s1521+  s1526 :: SBool = s5 == s1521+  s1527 :: SBool = s4 == s1521+  s1528 :: SBool = s3 == s1521+  s1529 :: SBool = s2 == s1521+  s1530 :: SBool = s1 == s1521+  s1531 :: SBool = s0 == s1521+  s1532 :: SWord8 = if s1531 then s32 else s33+  s1533 :: SBool = s37 == s1521+  s1534 :: SBool = s40 == s1521+  s1535 :: SWord8 = if s1534 then s32 else s33+  s1536 :: SWord8 = s33 + s1535+  s1537 :: SWord8 = if s1533 then s1536 else s1535+  s1538 :: SBool = s45 == s1521+  s1539 :: SWord8 = if s1538 then s32 else s33+  s1540 :: SWord8 = s33 + s1539+  s1541 :: SWord8 = if s1534 then s1540 else s1539+  s1542 :: SWord8 = s33 + s1541+  s1543 :: SWord8 = if s1533 then s1542 else s1541+  s1544 :: SWord8 = if s36 then s1537 else s1543+  s1545 :: SWord8 = if s30 then s1532 else s1544+  s1546 :: SWord8 = s33 + s1545+  s1547 :: SWord8 = if s1530 then s1546 else s1545+  s1548 :: SBool = s57 == s1521+  s1549 :: SBool = s60 == s1521+  s1550 :: SWord8 = if s1549 then s1546 else s1545+  s1551 :: SWord8 = s33 + s1550+  s1552 :: SWord8 = if s1548 then s1551 else s1550+  s1553 :: SBool = s65 == s1521+  s1554 :: SWord8 = if s1553 then s1546 else s1545+  s1555 :: SWord8 = s33 + s1554+  s1556 :: SWord8 = if s1549 then s1555 else s1554+  s1557 :: SWord8 = s33 + s1556+  s1558 :: SWord8 = if s1548 then s1557 else s1556+  s1559 :: SWord8 = if s56 then s1552 else s1558+  s1560 :: SWord8 = if s28 then s1547 else s1559+  s1561 :: SWord8 = s33 + s1560+  s1562 :: SWord8 = if s1529 then s1561 else s1560+  s1563 :: SBool = s77 == s1521+  s1564 :: SBool = s80 == s1521+  s1565 :: SWord8 = if s1564 then s1561 else s1560+  s1566 :: SWord8 = s33 + s1565+  s1567 :: SWord8 = if s1563 then s1566 else s1565+  s1568 :: SBool = s85 == s1521+  s1569 :: SWord8 = if s1568 then s1561 else s1560+  s1570 :: SWord8 = s33 + s1569+  s1571 :: SWord8 = if s1564 then s1570 else s1569+  s1572 :: SWord8 = s33 + s1571+  s1573 :: SWord8 = if s1563 then s1572 else s1571+  s1574 :: SWord8 = if s76 then s1567 else s1573+  s1575 :: SWord8 = if s26 then s1562 else s1574+  s1576 :: SWord8 = s33 + s1575+  s1577 :: SWord8 = if s1528 then s1576 else s1575+  s1578 :: SBool = s97 == s1521+  s1579 :: SBool = s100 == s1521+  s1580 :: SWord8 = if s1579 then s1576 else s1575+  s1581 :: SWord8 = s33 + s1580+  s1582 :: SWord8 = if s1578 then s1581 else s1580+  s1583 :: SBool = s105 == s1521+  s1584 :: SWord8 = if s1583 then s1576 else s1575+  s1585 :: SWord8 = s33 + s1584+  s1586 :: SWord8 = if s1579 then s1585 else s1584+  s1587 :: SWord8 = s33 + s1586+  s1588 :: SWord8 = if s1578 then s1587 else s1586+  s1589 :: SWord8 = if s96 then s1582 else s1588+  s1590 :: SWord8 = if s24 then s1577 else s1589+  s1591 :: SWord8 = s33 + s1590+  s1592 :: SWord8 = if s1527 then s1591 else s1590+  s1593 :: SBool = s117 == s1521+  s1594 :: SBool = s120 == s1521+  s1595 :: SWord8 = if s1594 then s1591 else s1590+  s1596 :: SWord8 = s33 + s1595+  s1597 :: SWord8 = if s1593 then s1596 else s1595+  s1598 :: SBool = s125 == s1521+  s1599 :: SWord8 = if s1598 then s1591 else s1590+  s1600 :: SWord8 = s33 + s1599+  s1601 :: SWord8 = if s1594 then s1600 else s1599+  s1602 :: SWord8 = s33 + s1601+  s1603 :: SWord8 = if s1593 then s1602 else s1601+  s1604 :: SWord8 = if s116 then s1597 else s1603+  s1605 :: SWord8 = if s22 then s1592 else s1604+  s1606 :: SWord8 = s33 + s1605+  s1607 :: SWord8 = if s1526 then s1606 else s1605+  s1608 :: SBool = s137 == s1521+  s1609 :: SBool = s140 == s1521+  s1610 :: SWord8 = if s1609 then s1606 else s1605+  s1611 :: SWord8 = s33 + s1610+  s1612 :: SWord8 = if s1608 then s1611 else s1610+  s1613 :: SBool = s145 == s1521+  s1614 :: SWord8 = if s1613 then s1606 else s1605+  s1615 :: SWord8 = s33 + s1614+  s1616 :: SWord8 = if s1609 then s1615 else s1614+  s1617 :: SWord8 = s33 + s1616+  s1618 :: SWord8 = if s1608 then s1617 else s1616+  s1619 :: SWord8 = if s136 then s1612 else s1618+  s1620 :: SWord8 = if s20 then s1607 else s1619+  s1621 :: SWord8 = s33 + s1620+  s1622 :: SWord8 = if s1525 then s1621 else s1620+  s1623 :: SBool = s157 == s1521+  s1624 :: SBool = s160 == s1521+  s1625 :: SWord8 = if s1624 then s1621 else s1620+  s1626 :: SWord8 = s33 + s1625+  s1627 :: SWord8 = if s1623 then s1626 else s1625+  s1628 :: SBool = s165 == s1521+  s1629 :: SWord8 = if s1628 then s1621 else s1620+  s1630 :: SWord8 = s33 + s1629+  s1631 :: SWord8 = if s1624 then s1630 else s1629+  s1632 :: SWord8 = s33 + s1631+  s1633 :: SWord8 = if s1623 then s1632 else s1631+  s1634 :: SWord8 = if s156 then s1627 else s1633+  s1635 :: SWord8 = if s18 then s1622 else s1634+  s1636 :: SWord8 = s33 + s1635+  s1637 :: SWord8 = if s1524 then s1636 else s1635+  s1638 :: SBool = s177 == s1521+  s1639 :: SBool = s180 == s1521+  s1640 :: SWord8 = if s1639 then s1636 else s1635+  s1641 :: SWord8 = s33 + s1640+  s1642 :: SWord8 = if s1638 then s1641 else s1640+  s1643 :: SBool = s185 == s1521+  s1644 :: SWord8 = if s1643 then s1636 else s1635+  s1645 :: SWord8 = s33 + s1644+  s1646 :: SWord8 = if s1639 then s1645 else s1644+  s1647 :: SWord8 = s33 + s1646+  s1648 :: SWord8 = if s1638 then s1647 else s1646+  s1649 :: SWord8 = if s176 then s1642 else s1648+  s1650 :: SWord8 = if s16 then s1637 else s1649+  s1651 :: SWord8 = s33 + s1650+  s1652 :: SWord8 = if s1523 then s1651 else s1650+  s1653 :: SBool = s197 == s1521+  s1654 :: SBool = s200 == s1521+  s1655 :: SWord8 = if s1654 then s1651 else s1650+  s1656 :: SWord8 = s33 + s1655+  s1657 :: SWord8 = if s1653 then s1656 else s1655+  s1658 :: SBool = s205 == s1521+  s1659 :: SWord8 = if s1658 then s1651 else s1650+  s1660 :: SWord8 = s33 + s1659+  s1661 :: SWord8 = if s1654 then s1660 else s1659+  s1662 :: SWord8 = s33 + s1661+  s1663 :: SWord8 = if s1653 then s1662 else s1661+  s1664 :: SWord8 = if s196 then s1657 else s1663+  s1665 :: SWord8 = if s14 then s1652 else s1664+  s1666 :: SWord8 = s33 + s1665+  s1667 :: SWord8 = if s1522 then s1666 else s1665+  s1668 :: SBool = s217 == s1521+  s1669 :: SBool = s220 == s1521+  s1670 :: SWord8 = if s1669 then s1666 else s1665+  s1671 :: SWord8 = s33 + s1670+  s1672 :: SWord8 = if s1668 then s1671 else s1670+  s1673 :: SBool = s225 == s1521+  s1674 :: SWord8 = if s1673 then s1666 else s1665+  s1675 :: SWord8 = s33 + s1674+  s1676 :: SWord8 = if s1669 then s1675 else s1674+  s1677 :: SWord8 = s33 + s1676+  s1678 :: SWord8 = if s1668 then s1677 else s1676+  s1679 :: SWord8 = if s216 then s1672 else s1678+  s1680 :: SWord8 = if s11 then s1667 else s1679+  s1681 :: SBool = s9 == s1680+  s1682 :: SBool = s1520 & s1681+  s1683 :: SBool = s1359 & s1682+  s1684 :: SBool = s1198 & s1683+  s1685 :: SBool = s1037 & s1684+  s1686 :: SBool = s876 & s1685+  s1687 :: SBool = s715 & s1686+  s1688 :: SBool = s554 & s1687+  s1689 :: SBool = s394 & s1688+  s1690 :: SBool = s234 & s1689+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s1690
+ SBVTestSuite/GoldFiles/crcPolyExist.gold view
@@ -0,0 +1,3486 @@+INPUTS+  s0 :: SWord16, existential, aliasing "poly"+  s1 :: SWord32, aliasing "sh"+  s2 :: SWord16, aliasing "sl"+  s3 :: SWord32, aliasing "rh"+  s4 :: SWord16, aliasing "rl"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s6 = 0 :: Word1+  s18 = 1 :: Word8+  s3340 = 0 :: Word8+  s3468 = 4 :: Word8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s5 :: SWord1 = choose [0:0] s0+  s7 :: SBool = s5 /= s6+  s8 :: SBool = s1 == s3+  s9 :: SBool = s2 == s4+  s10 :: SBool = s8 & s9+  s11 :: SBool = ~ s10+  s12 :: SBool = ~ s11+  s13 :: SWord1 = choose [31:31] s1+  s14 :: SBool = s6 /= s13+  s15 :: SWord1 = choose [31:31] s3+  s16 :: SBool = s6 /= s15+  s17 :: SBool = s14 ^ s16+  s19 :: SWord1 = choose [30:30] s1+  s20 :: SBool = s6 /= s19+  s21 :: SWord1 = choose [30:30] s3+  s22 :: SBool = s6 /= s21+  s23 :: SBool = s20 ^ s22+  s24 :: SWord1 = choose [29:29] s1+  s25 :: SBool = s6 /= s24+  s26 :: SWord1 = choose [29:29] s3+  s27 :: SBool = s6 /= s26+  s28 :: SBool = s25 ^ s27+  s29 :: SWord1 = choose [28:28] s1+  s30 :: SBool = s6 /= s29+  s31 :: SWord1 = choose [28:28] s3+  s32 :: SBool = s6 /= s31+  s33 :: SBool = s30 ^ s32+  s34 :: SWord1 = choose [27:27] s1+  s35 :: SBool = s6 /= s34+  s36 :: SWord1 = choose [27:27] s3+  s37 :: SBool = s6 /= s36+  s38 :: SBool = s35 ^ s37+  s39 :: SWord1 = choose [26:26] s1+  s40 :: SBool = s6 /= s39+  s41 :: SWord1 = choose [26:26] s3+  s42 :: SBool = s6 /= s41+  s43 :: SBool = s40 ^ s42+  s44 :: SWord1 = choose [25:25] s1+  s45 :: SBool = s6 /= s44+  s46 :: SWord1 = choose [25:25] s3+  s47 :: SBool = s6 /= s46+  s48 :: SBool = s45 ^ s47+  s49 :: SWord1 = choose [24:24] s1+  s50 :: SBool = s6 /= s49+  s51 :: SWord1 = choose [24:24] s3+  s52 :: SBool = s6 /= s51+  s53 :: SBool = s50 ^ s52+  s54 :: SWord1 = choose [23:23] s1+  s55 :: SBool = s6 /= s54+  s56 :: SWord1 = choose [23:23] s3+  s57 :: SBool = s6 /= s56+  s58 :: SBool = s55 ^ s57+  s59 :: SWord1 = choose [22:22] s1+  s60 :: SBool = s6 /= s59+  s61 :: SWord1 = choose [22:22] s3+  s62 :: SBool = s6 /= s61+  s63 :: SBool = s60 ^ s62+  s64 :: SWord1 = choose [21:21] s1+  s65 :: SBool = s6 /= s64+  s66 :: SWord1 = choose [21:21] s3+  s67 :: SBool = s6 /= s66+  s68 :: SBool = s65 ^ s67+  s69 :: SWord1 = choose [20:20] s1+  s70 :: SBool = s6 /= s69+  s71 :: SWord1 = choose [20:20] s3+  s72 :: SBool = s6 /= s71+  s73 :: SBool = s70 ^ s72+  s74 :: SWord1 = choose [19:19] s1+  s75 :: SBool = s6 /= s74+  s76 :: SWord1 = choose [19:19] s3+  s77 :: SBool = s6 /= s76+  s78 :: SBool = s75 ^ s77+  s79 :: SWord1 = choose [18:18] s1+  s80 :: SBool = s6 /= s79+  s81 :: SWord1 = choose [18:18] s3+  s82 :: SBool = s6 /= s81+  s83 :: SBool = s80 ^ s82+  s84 :: SWord1 = choose [17:17] s1+  s85 :: SBool = s6 /= s84+  s86 :: SWord1 = choose [17:17] s3+  s87 :: SBool = s6 /= s86+  s88 :: SBool = s85 ^ s87+  s89 :: SWord1 = choose [16:16] s1+  s90 :: SBool = s6 /= s89+  s91 :: SWord1 = choose [16:16] s3+  s92 :: SBool = s6 /= s91+  s93 :: SBool = s90 ^ s92+  s94 :: SWord1 = choose [15:15] s1+  s95 :: SBool = s6 /= s94+  s96 :: SWord1 = choose [15:15] s3+  s97 :: SBool = s6 /= s96+  s98 :: SBool = s95 ^ s97+  s99 :: SWord1 = choose [14:14] s1+  s100 :: SBool = s6 /= s99+  s101 :: SWord1 = choose [14:14] s3+  s102 :: SBool = s6 /= s101+  s103 :: SBool = s100 ^ s102+  s104 :: SWord1 = choose [13:13] s1+  s105 :: SBool = s6 /= s104+  s106 :: SWord1 = choose [13:13] s3+  s107 :: SBool = s6 /= s106+  s108 :: SBool = s105 ^ s107+  s109 :: SWord1 = choose [12:12] s1+  s110 :: SBool = s6 /= s109+  s111 :: SWord1 = choose [12:12] s3+  s112 :: SBool = s6 /= s111+  s113 :: SBool = s110 ^ s112+  s114 :: SWord1 = choose [11:11] s1+  s115 :: SBool = s6 /= s114+  s116 :: SWord1 = choose [11:11] s3+  s117 :: SBool = s6 /= s116+  s118 :: SBool = s115 ^ s117+  s119 :: SWord1 = choose [10:10] s1+  s120 :: SBool = s6 /= s119+  s121 :: SWord1 = choose [10:10] s3+  s122 :: SBool = s6 /= s121+  s123 :: SBool = s120 ^ s122+  s124 :: SWord1 = choose [9:9] s1+  s125 :: SBool = s6 /= s124+  s126 :: SWord1 = choose [9:9] s3+  s127 :: SBool = s6 /= s126+  s128 :: SBool = s125 ^ s127+  s129 :: SWord1 = choose [8:8] s1+  s130 :: SBool = s6 /= s129+  s131 :: SWord1 = choose [8:8] s3+  s132 :: SBool = s6 /= s131+  s133 :: SBool = s130 ^ s132+  s134 :: SWord1 = choose [7:7] s1+  s135 :: SBool = s6 /= s134+  s136 :: SWord1 = choose [7:7] s3+  s137 :: SBool = s6 /= s136+  s138 :: SBool = s135 ^ s137+  s139 :: SWord1 = choose [6:6] s1+  s140 :: SBool = s6 /= s139+  s141 :: SWord1 = choose [6:6] s3+  s142 :: SBool = s6 /= s141+  s143 :: SBool = s140 ^ s142+  s144 :: SWord1 = choose [5:5] s1+  s145 :: SBool = s6 /= s144+  s146 :: SWord1 = choose [5:5] s3+  s147 :: SBool = s6 /= s146+  s148 :: SBool = s145 ^ s147+  s149 :: SWord1 = choose [4:4] s1+  s150 :: SBool = s6 /= s149+  s151 :: SWord1 = choose [4:4] s3+  s152 :: SBool = s6 /= s151+  s153 :: SBool = s150 ^ s152+  s154 :: SWord1 = choose [3:3] s1+  s155 :: SBool = s6 /= s154+  s156 :: SWord1 = choose [3:3] s3+  s157 :: SBool = s6 /= s156+  s158 :: SBool = s155 ^ s157+  s159 :: SWord1 = choose [2:2] s1+  s160 :: SBool = s6 /= s159+  s161 :: SWord1 = choose [2:2] s3+  s162 :: SBool = s6 /= s161+  s163 :: SBool = s160 ^ s162+  s164 :: SWord1 = choose [1:1] s1+  s165 :: SBool = s6 /= s164+  s166 :: SWord1 = choose [1:1] s3+  s167 :: SBool = s6 /= s166+  s168 :: SBool = s165 ^ s167+  s169 :: SWord1 = choose [0:0] s1+  s170 :: SBool = s6 /= s169+  s171 :: SWord1 = choose [0:0] s3+  s172 :: SBool = s6 /= s171+  s173 :: SBool = s170 ^ s172+  s174 :: SWord1 = choose [15:15] s2+  s175 :: SBool = s6 /= s174+  s176 :: SWord1 = choose [15:15] s4+  s177 :: SBool = s6 /= s176+  s178 :: SBool = s175 ^ s177+  s179 :: SWord1 = choose [14:14] s2+  s180 :: SBool = s6 /= s179+  s181 :: SWord1 = choose [14:14] s4+  s182 :: SBool = s6 /= s181+  s183 :: SBool = s180 ^ s182+  s184 :: SWord1 = choose [13:13] s2+  s185 :: SBool = s6 /= s184+  s186 :: SWord1 = choose [13:13] s4+  s187 :: SBool = s6 /= s186+  s188 :: SBool = s185 ^ s187+  s189 :: SWord1 = choose [12:12] s2+  s190 :: SBool = s6 /= s189+  s191 :: SWord1 = choose [12:12] s4+  s192 :: SBool = s6 /= s191+  s193 :: SBool = s190 ^ s192+  s194 :: SWord1 = choose [11:11] s2+  s195 :: SBool = s6 /= s194+  s196 :: SWord1 = choose [11:11] s4+  s197 :: SBool = s6 /= s196+  s198 :: SBool = s195 ^ s197+  s199 :: SWord1 = choose [10:10] s2+  s200 :: SBool = s6 /= s199+  s201 :: SWord1 = choose [10:10] s4+  s202 :: SBool = s6 /= s201+  s203 :: SBool = s200 ^ s202+  s204 :: SWord1 = choose [9:9] s2+  s205 :: SBool = s6 /= s204+  s206 :: SWord1 = choose [9:9] s4+  s207 :: SBool = s6 /= s206+  s208 :: SBool = s205 ^ s207+  s209 :: SWord1 = choose [8:8] s2+  s210 :: SBool = s6 /= s209+  s211 :: SWord1 = choose [8:8] s4+  s212 :: SBool = s6 /= s211+  s213 :: SBool = s210 ^ s212+  s214 :: SWord1 = choose [7:7] s2+  s215 :: SBool = s6 /= s214+  s216 :: SWord1 = choose [7:7] s4+  s217 :: SBool = s6 /= s216+  s218 :: SBool = s215 ^ s217+  s219 :: SWord1 = choose [6:6] s2+  s220 :: SBool = s6 /= s219+  s221 :: SWord1 = choose [6:6] s4+  s222 :: SBool = s6 /= s221+  s223 :: SBool = s220 ^ s222+  s224 :: SWord1 = choose [5:5] s2+  s225 :: SBool = s6 /= s224+  s226 :: SWord1 = choose [5:5] s4+  s227 :: SBool = s6 /= s226+  s228 :: SBool = s225 ^ s227+  s229 :: SWord1 = choose [4:4] s2+  s230 :: SBool = s6 /= s229+  s231 :: SWord1 = choose [4:4] s4+  s232 :: SBool = s6 /= s231+  s233 :: SBool = s230 ^ s232+  s234 :: SWord1 = choose [3:3] s2+  s235 :: SBool = s6 /= s234+  s236 :: SWord1 = choose [3:3] s4+  s237 :: SBool = s6 /= s236+  s238 :: SBool = s235 ^ s237+  s239 :: SWord1 = choose [2:2] s2+  s240 :: SBool = s6 /= s239+  s241 :: SWord1 = choose [2:2] s4+  s242 :: SBool = s6 /= s241+  s243 :: SBool = s240 ^ s242+  s244 :: SWord1 = choose [1:1] s2+  s245 :: SBool = s6 /= s244+  s246 :: SWord1 = choose [1:1] s4+  s247 :: SBool = s6 /= s246+  s248 :: SBool = s245 ^ s247+  s249 :: SWord1 = choose [0:0] s2+  s250 :: SBool = s6 /= s249+  s251 :: SWord1 = choose [0:0] s4+  s252 :: SBool = s6 /= s251+  s253 :: SBool = s250 ^ s252+  s254 :: SWord1 = choose [15:15] s0+  s255 :: SBool = s6 /= s254+  s256 :: SBool = s20 ^ s255+  s257 :: SBool = if s14 then s256 else s20+  s258 :: SWord1 = choose [14:14] s0+  s259 :: SBool = s6 /= s258+  s260 :: SBool = s25 ^ s259+  s261 :: SBool = if s14 then s260 else s25+  s262 :: SBool = s255 ^ s261+  s263 :: SBool = if s257 then s262 else s261+  s264 :: SWord1 = choose [13:13] s0+  s265 :: SBool = s6 /= s264+  s266 :: SBool = s30 ^ s265+  s267 :: SBool = if s14 then s266 else s30+  s268 :: SBool = s259 ^ s267+  s269 :: SBool = if s257 then s268 else s267+  s270 :: SBool = s255 ^ s269+  s271 :: SBool = if s263 then s270 else s269+  s272 :: SWord1 = choose [12:12] s0+  s273 :: SBool = s6 /= s272+  s274 :: SBool = s35 ^ s273+  s275 :: SBool = if s14 then s274 else s35+  s276 :: SBool = s265 ^ s275+  s277 :: SBool = if s257 then s276 else s275+  s278 :: SBool = s259 ^ s277+  s279 :: SBool = if s263 then s278 else s277+  s280 :: SBool = s255 ^ s279+  s281 :: SBool = if s271 then s280 else s279+  s282 :: SWord1 = choose [11:11] s0+  s283 :: SBool = s6 /= s282+  s284 :: SBool = s40 ^ s283+  s285 :: SBool = if s14 then s284 else s40+  s286 :: SBool = s273 ^ s285+  s287 :: SBool = if s257 then s286 else s285+  s288 :: SBool = s265 ^ s287+  s289 :: SBool = if s263 then s288 else s287+  s290 :: SBool = s259 ^ s289+  s291 :: SBool = if s271 then s290 else s289+  s292 :: SBool = s255 ^ s291+  s293 :: SBool = if s281 then s292 else s291+  s294 :: SWord1 = choose [10:10] s0+  s295 :: SBool = s6 /= s294+  s296 :: SBool = s45 ^ s295+  s297 :: SBool = if s14 then s296 else s45+  s298 :: SBool = s283 ^ s297+  s299 :: SBool = if s257 then s298 else s297+  s300 :: SBool = s273 ^ s299+  s301 :: SBool = if s263 then s300 else s299+  s302 :: SBool = s265 ^ s301+  s303 :: SBool = if s271 then s302 else s301+  s304 :: SBool = s259 ^ s303+  s305 :: SBool = if s281 then s304 else s303+  s306 :: SBool = s255 ^ s305+  s307 :: SBool = if s293 then s306 else s305+  s308 :: SWord1 = choose [9:9] s0+  s309 :: SBool = s6 /= s308+  s310 :: SBool = s50 ^ s309+  s311 :: SBool = if s14 then s310 else s50+  s312 :: SBool = s295 ^ s311+  s313 :: SBool = if s257 then s312 else s311+  s314 :: SBool = s283 ^ s313+  s315 :: SBool = if s263 then s314 else s313+  s316 :: SBool = s273 ^ s315+  s317 :: SBool = if s271 then s316 else s315+  s318 :: SBool = s265 ^ s317+  s319 :: SBool = if s281 then s318 else s317+  s320 :: SBool = s259 ^ s319+  s321 :: SBool = if s293 then s320 else s319+  s322 :: SBool = s255 ^ s321+  s323 :: SBool = if s307 then s322 else s321+  s324 :: SWord1 = choose [8:8] s0+  s325 :: SBool = s6 /= s324+  s326 :: SBool = s55 ^ s325+  s327 :: SBool = if s14 then s326 else s55+  s328 :: SBool = s309 ^ s327+  s329 :: SBool = if s257 then s328 else s327+  s330 :: SBool = s295 ^ s329+  s331 :: SBool = if s263 then s330 else s329+  s332 :: SBool = s283 ^ s331+  s333 :: SBool = if s271 then s332 else s331+  s334 :: SBool = s273 ^ s333+  s335 :: SBool = if s281 then s334 else s333+  s336 :: SBool = s265 ^ s335+  s337 :: SBool = if s293 then s336 else s335+  s338 :: SBool = s259 ^ s337+  s339 :: SBool = if s307 then s338 else s337+  s340 :: SBool = s255 ^ s339+  s341 :: SBool = if s323 then s340 else s339+  s342 :: SWord1 = choose [7:7] s0+  s343 :: SBool = s6 /= s342+  s344 :: SBool = s60 ^ s343+  s345 :: SBool = if s14 then s344 else s60+  s346 :: SBool = s325 ^ s345+  s347 :: SBool = if s257 then s346 else s345+  s348 :: SBool = s309 ^ s347+  s349 :: SBool = if s263 then s348 else s347+  s350 :: SBool = s295 ^ s349+  s351 :: SBool = if s271 then s350 else s349+  s352 :: SBool = s283 ^ s351+  s353 :: SBool = if s281 then s352 else s351+  s354 :: SBool = s273 ^ s353+  s355 :: SBool = if s293 then s354 else s353+  s356 :: SBool = s265 ^ s355+  s357 :: SBool = if s307 then s356 else s355+  s358 :: SBool = s259 ^ s357+  s359 :: SBool = if s323 then s358 else s357+  s360 :: SBool = s255 ^ s359+  s361 :: SBool = if s341 then s360 else s359+  s362 :: SWord1 = choose [6:6] s0+  s363 :: SBool = s6 /= s362+  s364 :: SBool = s65 ^ s363+  s365 :: SBool = if s14 then s364 else s65+  s366 :: SBool = s343 ^ s365+  s367 :: SBool = if s257 then s366 else s365+  s368 :: SBool = s325 ^ s367+  s369 :: SBool = if s263 then s368 else s367+  s370 :: SBool = s309 ^ s369+  s371 :: SBool = if s271 then s370 else s369+  s372 :: SBool = s295 ^ s371+  s373 :: SBool = if s281 then s372 else s371+  s374 :: SBool = s283 ^ s373+  s375 :: SBool = if s293 then s374 else s373+  s376 :: SBool = s273 ^ s375+  s377 :: SBool = if s307 then s376 else s375+  s378 :: SBool = s265 ^ s377+  s379 :: SBool = if s323 then s378 else s377+  s380 :: SBool = s259 ^ s379+  s381 :: SBool = if s341 then s380 else s379+  s382 :: SBool = s255 ^ s381+  s383 :: SBool = if s361 then s382 else s381+  s384 :: SWord1 = choose [5:5] s0+  s385 :: SBool = s6 /= s384+  s386 :: SBool = s70 ^ s385+  s387 :: SBool = if s14 then s386 else s70+  s388 :: SBool = s363 ^ s387+  s389 :: SBool = if s257 then s388 else s387+  s390 :: SBool = s343 ^ s389+  s391 :: SBool = if s263 then s390 else s389+  s392 :: SBool = s325 ^ s391+  s393 :: SBool = if s271 then s392 else s391+  s394 :: SBool = s309 ^ s393+  s395 :: SBool = if s281 then s394 else s393+  s396 :: SBool = s295 ^ s395+  s397 :: SBool = if s293 then s396 else s395+  s398 :: SBool = s283 ^ s397+  s399 :: SBool = if s307 then s398 else s397+  s400 :: SBool = s273 ^ s399+  s401 :: SBool = if s323 then s400 else s399+  s402 :: SBool = s265 ^ s401+  s403 :: SBool = if s341 then s402 else s401+  s404 :: SBool = s259 ^ s403+  s405 :: SBool = if s361 then s404 else s403+  s406 :: SBool = s255 ^ s405+  s407 :: SBool = if s383 then s406 else s405+  s408 :: SWord1 = choose [4:4] s0+  s409 :: SBool = s6 /= s408+  s410 :: SBool = s75 ^ s409+  s411 :: SBool = if s14 then s410 else s75+  s412 :: SBool = s385 ^ s411+  s413 :: SBool = if s257 then s412 else s411+  s414 :: SBool = s363 ^ s413+  s415 :: SBool = if s263 then s414 else s413+  s416 :: SBool = s343 ^ s415+  s417 :: SBool = if s271 then s416 else s415+  s418 :: SBool = s325 ^ s417+  s419 :: SBool = if s281 then s418 else s417+  s420 :: SBool = s309 ^ s419+  s421 :: SBool = if s293 then s420 else s419+  s422 :: SBool = s295 ^ s421+  s423 :: SBool = if s307 then s422 else s421+  s424 :: SBool = s283 ^ s423+  s425 :: SBool = if s323 then s424 else s423+  s426 :: SBool = s273 ^ s425+  s427 :: SBool = if s341 then s426 else s425+  s428 :: SBool = s265 ^ s427+  s429 :: SBool = if s361 then s428 else s427+  s430 :: SBool = s259 ^ s429+  s431 :: SBool = if s383 then s430 else s429+  s432 :: SBool = s255 ^ s431+  s433 :: SBool = if s407 then s432 else s431+  s434 :: SWord1 = choose [3:3] s0+  s435 :: SBool = s6 /= s434+  s436 :: SBool = s80 ^ s435+  s437 :: SBool = if s14 then s436 else s80+  s438 :: SBool = s409 ^ s437+  s439 :: SBool = if s257 then s438 else s437+  s440 :: SBool = s385 ^ s439+  s441 :: SBool = if s263 then s440 else s439+  s442 :: SBool = s363 ^ s441+  s443 :: SBool = if s271 then s442 else s441+  s444 :: SBool = s343 ^ s443+  s445 :: SBool = if s281 then s444 else s443+  s446 :: SBool = s325 ^ s445+  s447 :: SBool = if s293 then s446 else s445+  s448 :: SBool = s309 ^ s447+  s449 :: SBool = if s307 then s448 else s447+  s450 :: SBool = s295 ^ s449+  s451 :: SBool = if s323 then s450 else s449+  s452 :: SBool = s283 ^ s451+  s453 :: SBool = if s341 then s452 else s451+  s454 :: SBool = s273 ^ s453+  s455 :: SBool = if s361 then s454 else s453+  s456 :: SBool = s265 ^ s455+  s457 :: SBool = if s383 then s456 else s455+  s458 :: SBool = s259 ^ s457+  s459 :: SBool = if s407 then s458 else s457+  s460 :: SBool = s255 ^ s459+  s461 :: SBool = if s433 then s460 else s459+  s462 :: SWord1 = choose [2:2] s0+  s463 :: SBool = s6 /= s462+  s464 :: SBool = s85 ^ s463+  s465 :: SBool = if s14 then s464 else s85+  s466 :: SBool = s435 ^ s465+  s467 :: SBool = if s257 then s466 else s465+  s468 :: SBool = s409 ^ s467+  s469 :: SBool = if s263 then s468 else s467+  s470 :: SBool = s385 ^ s469+  s471 :: SBool = if s271 then s470 else s469+  s472 :: SBool = s363 ^ s471+  s473 :: SBool = if s281 then s472 else s471+  s474 :: SBool = s343 ^ s473+  s475 :: SBool = if s293 then s474 else s473+  s476 :: SBool = s325 ^ s475+  s477 :: SBool = if s307 then s476 else s475+  s478 :: SBool = s309 ^ s477+  s479 :: SBool = if s323 then s478 else s477+  s480 :: SBool = s295 ^ s479+  s481 :: SBool = if s341 then s480 else s479+  s482 :: SBool = s283 ^ s481+  s483 :: SBool = if s361 then s482 else s481+  s484 :: SBool = s273 ^ s483+  s485 :: SBool = if s383 then s484 else s483+  s486 :: SBool = s265 ^ s485+  s487 :: SBool = if s407 then s486 else s485+  s488 :: SBool = s259 ^ s487+  s489 :: SBool = if s433 then s488 else s487+  s490 :: SBool = s255 ^ s489+  s491 :: SBool = if s461 then s490 else s489+  s492 :: SWord1 = choose [1:1] s0+  s493 :: SBool = s6 /= s492+  s494 :: SBool = s90 ^ s493+  s495 :: SBool = if s14 then s494 else s90+  s496 :: SBool = s463 ^ s495+  s497 :: SBool = if s257 then s496 else s495+  s498 :: SBool = s435 ^ s497+  s499 :: SBool = if s263 then s498 else s497+  s500 :: SBool = s409 ^ s499+  s501 :: SBool = if s271 then s500 else s499+  s502 :: SBool = s385 ^ s501+  s503 :: SBool = if s281 then s502 else s501+  s504 :: SBool = s363 ^ s503+  s505 :: SBool = if s293 then s504 else s503+  s506 :: SBool = s343 ^ s505+  s507 :: SBool = if s307 then s506 else s505+  s508 :: SBool = s325 ^ s507+  s509 :: SBool = if s323 then s508 else s507+  s510 :: SBool = s309 ^ s509+  s511 :: SBool = if s341 then s510 else s509+  s512 :: SBool = s295 ^ s511+  s513 :: SBool = if s361 then s512 else s511+  s514 :: SBool = s283 ^ s513+  s515 :: SBool = if s383 then s514 else s513+  s516 :: SBool = s273 ^ s515+  s517 :: SBool = if s407 then s516 else s515+  s518 :: SBool = s265 ^ s517+  s519 :: SBool = if s433 then s518 else s517+  s520 :: SBool = s259 ^ s519+  s521 :: SBool = if s461 then s520 else s519+  s522 :: SBool = s255 ^ s521+  s523 :: SBool = if s491 then s522 else s521+  s524 :: SBool = s7 ^ s95+  s525 :: SBool = if s14 then s524 else s95+  s526 :: SBool = s493 ^ s525+  s527 :: SBool = if s257 then s526 else s525+  s528 :: SBool = s463 ^ s527+  s529 :: SBool = if s263 then s528 else s527+  s530 :: SBool = s435 ^ s529+  s531 :: SBool = if s271 then s530 else s529+  s532 :: SBool = s409 ^ s531+  s533 :: SBool = if s281 then s532 else s531+  s534 :: SBool = s385 ^ s533+  s535 :: SBool = if s293 then s534 else s533+  s536 :: SBool = s363 ^ s535+  s537 :: SBool = if s307 then s536 else s535+  s538 :: SBool = s343 ^ s537+  s539 :: SBool = if s323 then s538 else s537+  s540 :: SBool = s325 ^ s539+  s541 :: SBool = if s341 then s540 else s539+  s542 :: SBool = s309 ^ s541+  s543 :: SBool = if s361 then s542 else s541+  s544 :: SBool = s295 ^ s543+  s545 :: SBool = if s383 then s544 else s543+  s546 :: SBool = s283 ^ s545+  s547 :: SBool = if s407 then s546 else s545+  s548 :: SBool = s273 ^ s547+  s549 :: SBool = if s433 then s548 else s547+  s550 :: SBool = s265 ^ s549+  s551 :: SBool = if s461 then s550 else s549+  s552 :: SBool = s259 ^ s551+  s553 :: SBool = if s491 then s552 else s551+  s554 :: SBool = s255 ^ s553+  s555 :: SBool = if s523 then s554 else s553+  s556 :: SBool = s7 ^ s100+  s557 :: SBool = if s257 then s556 else s100+  s558 :: SBool = s493 ^ s557+  s559 :: SBool = if s263 then s558 else s557+  s560 :: SBool = s463 ^ s559+  s561 :: SBool = if s271 then s560 else s559+  s562 :: SBool = s435 ^ s561+  s563 :: SBool = if s281 then s562 else s561+  s564 :: SBool = s409 ^ s563+  s565 :: SBool = if s293 then s564 else s563+  s566 :: SBool = s385 ^ s565+  s567 :: SBool = if s307 then s566 else s565+  s568 :: SBool = s363 ^ s567+  s569 :: SBool = if s323 then s568 else s567+  s570 :: SBool = s343 ^ s569+  s571 :: SBool = if s341 then s570 else s569+  s572 :: SBool = s325 ^ s571+  s573 :: SBool = if s361 then s572 else s571+  s574 :: SBool = s309 ^ s573+  s575 :: SBool = if s383 then s574 else s573+  s576 :: SBool = s295 ^ s575+  s577 :: SBool = if s407 then s576 else s575+  s578 :: SBool = s283 ^ s577+  s579 :: SBool = if s433 then s578 else s577+  s580 :: SBool = s273 ^ s579+  s581 :: SBool = if s461 then s580 else s579+  s582 :: SBool = s265 ^ s581+  s583 :: SBool = if s491 then s582 else s581+  s584 :: SBool = s259 ^ s583+  s585 :: SBool = if s523 then s584 else s583+  s586 :: SBool = s255 ^ s585+  s587 :: SBool = if s555 then s586 else s585+  s588 :: SBool = s7 ^ s105+  s589 :: SBool = if s263 then s588 else s105+  s590 :: SBool = s493 ^ s589+  s591 :: SBool = if s271 then s590 else s589+  s592 :: SBool = s463 ^ s591+  s593 :: SBool = if s281 then s592 else s591+  s594 :: SBool = s435 ^ s593+  s595 :: SBool = if s293 then s594 else s593+  s596 :: SBool = s409 ^ s595+  s597 :: SBool = if s307 then s596 else s595+  s598 :: SBool = s385 ^ s597+  s599 :: SBool = if s323 then s598 else s597+  s600 :: SBool = s363 ^ s599+  s601 :: SBool = if s341 then s600 else s599+  s602 :: SBool = s343 ^ s601+  s603 :: SBool = if s361 then s602 else s601+  s604 :: SBool = s325 ^ s603+  s605 :: SBool = if s383 then s604 else s603+  s606 :: SBool = s309 ^ s605+  s607 :: SBool = if s407 then s606 else s605+  s608 :: SBool = s295 ^ s607+  s609 :: SBool = if s433 then s608 else s607+  s610 :: SBool = s283 ^ s609+  s611 :: SBool = if s461 then s610 else s609+  s612 :: SBool = s273 ^ s611+  s613 :: SBool = if s491 then s612 else s611+  s614 :: SBool = s265 ^ s613+  s615 :: SBool = if s523 then s614 else s613+  s616 :: SBool = s259 ^ s615+  s617 :: SBool = if s555 then s616 else s615+  s618 :: SBool = s255 ^ s617+  s619 :: SBool = if s587 then s618 else s617+  s620 :: SBool = s7 ^ s110+  s621 :: SBool = if s271 then s620 else s110+  s622 :: SBool = s493 ^ s621+  s623 :: SBool = if s281 then s622 else s621+  s624 :: SBool = s463 ^ s623+  s625 :: SBool = if s293 then s624 else s623+  s626 :: SBool = s435 ^ s625+  s627 :: SBool = if s307 then s626 else s625+  s628 :: SBool = s409 ^ s627+  s629 :: SBool = if s323 then s628 else s627+  s630 :: SBool = s385 ^ s629+  s631 :: SBool = if s341 then s630 else s629+  s632 :: SBool = s363 ^ s631+  s633 :: SBool = if s361 then s632 else s631+  s634 :: SBool = s343 ^ s633+  s635 :: SBool = if s383 then s634 else s633+  s636 :: SBool = s325 ^ s635+  s637 :: SBool = if s407 then s636 else s635+  s638 :: SBool = s309 ^ s637+  s639 :: SBool = if s433 then s638 else s637+  s640 :: SBool = s295 ^ s639+  s641 :: SBool = if s461 then s640 else s639+  s642 :: SBool = s283 ^ s641+  s643 :: SBool = if s491 then s642 else s641+  s644 :: SBool = s273 ^ s643+  s645 :: SBool = if s523 then s644 else s643+  s646 :: SBool = s265 ^ s645+  s647 :: SBool = if s555 then s646 else s645+  s648 :: SBool = s259 ^ s647+  s649 :: SBool = if s587 then s648 else s647+  s650 :: SBool = s255 ^ s649+  s651 :: SBool = if s619 then s650 else s649+  s652 :: SBool = s7 ^ s115+  s653 :: SBool = if s281 then s652 else s115+  s654 :: SBool = s493 ^ s653+  s655 :: SBool = if s293 then s654 else s653+  s656 :: SBool = s463 ^ s655+  s657 :: SBool = if s307 then s656 else s655+  s658 :: SBool = s435 ^ s657+  s659 :: SBool = if s323 then s658 else s657+  s660 :: SBool = s409 ^ s659+  s661 :: SBool = if s341 then s660 else s659+  s662 :: SBool = s385 ^ s661+  s663 :: SBool = if s361 then s662 else s661+  s664 :: SBool = s363 ^ s663+  s665 :: SBool = if s383 then s664 else s663+  s666 :: SBool = s343 ^ s665+  s667 :: SBool = if s407 then s666 else s665+  s668 :: SBool = s325 ^ s667+  s669 :: SBool = if s433 then s668 else s667+  s670 :: SBool = s309 ^ s669+  s671 :: SBool = if s461 then s670 else s669+  s672 :: SBool = s295 ^ s671+  s673 :: SBool = if s491 then s672 else s671+  s674 :: SBool = s283 ^ s673+  s675 :: SBool = if s523 then s674 else s673+  s676 :: SBool = s273 ^ s675+  s677 :: SBool = if s555 then s676 else s675+  s678 :: SBool = s265 ^ s677+  s679 :: SBool = if s587 then s678 else s677+  s680 :: SBool = s259 ^ s679+  s681 :: SBool = if s619 then s680 else s679+  s682 :: SBool = s255 ^ s681+  s683 :: SBool = if s651 then s682 else s681+  s684 :: SBool = s7 ^ s120+  s685 :: SBool = if s293 then s684 else s120+  s686 :: SBool = s493 ^ s685+  s687 :: SBool = if s307 then s686 else s685+  s688 :: SBool = s463 ^ s687+  s689 :: SBool = if s323 then s688 else s687+  s690 :: SBool = s435 ^ s689+  s691 :: SBool = if s341 then s690 else s689+  s692 :: SBool = s409 ^ s691+  s693 :: SBool = if s361 then s692 else s691+  s694 :: SBool = s385 ^ s693+  s695 :: SBool = if s383 then s694 else s693+  s696 :: SBool = s363 ^ s695+  s697 :: SBool = if s407 then s696 else s695+  s698 :: SBool = s343 ^ s697+  s699 :: SBool = if s433 then s698 else s697+  s700 :: SBool = s325 ^ s699+  s701 :: SBool = if s461 then s700 else s699+  s702 :: SBool = s309 ^ s701+  s703 :: SBool = if s491 then s702 else s701+  s704 :: SBool = s295 ^ s703+  s705 :: SBool = if s523 then s704 else s703+  s706 :: SBool = s283 ^ s705+  s707 :: SBool = if s555 then s706 else s705+  s708 :: SBool = s273 ^ s707+  s709 :: SBool = if s587 then s708 else s707+  s710 :: SBool = s265 ^ s709+  s711 :: SBool = if s619 then s710 else s709+  s712 :: SBool = s259 ^ s711+  s713 :: SBool = if s651 then s712 else s711+  s714 :: SBool = s255 ^ s713+  s715 :: SBool = if s683 then s714 else s713+  s716 :: SBool = s7 ^ s125+  s717 :: SBool = if s307 then s716 else s125+  s718 :: SBool = s493 ^ s717+  s719 :: SBool = if s323 then s718 else s717+  s720 :: SBool = s463 ^ s719+  s721 :: SBool = if s341 then s720 else s719+  s722 :: SBool = s435 ^ s721+  s723 :: SBool = if s361 then s722 else s721+  s724 :: SBool = s409 ^ s723+  s725 :: SBool = if s383 then s724 else s723+  s726 :: SBool = s385 ^ s725+  s727 :: SBool = if s407 then s726 else s725+  s728 :: SBool = s363 ^ s727+  s729 :: SBool = if s433 then s728 else s727+  s730 :: SBool = s343 ^ s729+  s731 :: SBool = if s461 then s730 else s729+  s732 :: SBool = s325 ^ s731+  s733 :: SBool = if s491 then s732 else s731+  s734 :: SBool = s309 ^ s733+  s735 :: SBool = if s523 then s734 else s733+  s736 :: SBool = s295 ^ s735+  s737 :: SBool = if s555 then s736 else s735+  s738 :: SBool = s283 ^ s737+  s739 :: SBool = if s587 then s738 else s737+  s740 :: SBool = s273 ^ s739+  s741 :: SBool = if s619 then s740 else s739+  s742 :: SBool = s265 ^ s741+  s743 :: SBool = if s651 then s742 else s741+  s744 :: SBool = s259 ^ s743+  s745 :: SBool = if s683 then s744 else s743+  s746 :: SBool = s255 ^ s745+  s747 :: SBool = if s715 then s746 else s745+  s748 :: SBool = s7 ^ s130+  s749 :: SBool = if s323 then s748 else s130+  s750 :: SBool = s493 ^ s749+  s751 :: SBool = if s341 then s750 else s749+  s752 :: SBool = s463 ^ s751+  s753 :: SBool = if s361 then s752 else s751+  s754 :: SBool = s435 ^ s753+  s755 :: SBool = if s383 then s754 else s753+  s756 :: SBool = s409 ^ s755+  s757 :: SBool = if s407 then s756 else s755+  s758 :: SBool = s385 ^ s757+  s759 :: SBool = if s433 then s758 else s757+  s760 :: SBool = s363 ^ s759+  s761 :: SBool = if s461 then s760 else s759+  s762 :: SBool = s343 ^ s761+  s763 :: SBool = if s491 then s762 else s761+  s764 :: SBool = s325 ^ s763+  s765 :: SBool = if s523 then s764 else s763+  s766 :: SBool = s309 ^ s765+  s767 :: SBool = if s555 then s766 else s765+  s768 :: SBool = s295 ^ s767+  s769 :: SBool = if s587 then s768 else s767+  s770 :: SBool = s283 ^ s769+  s771 :: SBool = if s619 then s770 else s769+  s772 :: SBool = s273 ^ s771+  s773 :: SBool = if s651 then s772 else s771+  s774 :: SBool = s265 ^ s773+  s775 :: SBool = if s683 then s774 else s773+  s776 :: SBool = s259 ^ s775+  s777 :: SBool = if s715 then s776 else s775+  s778 :: SBool = s255 ^ s777+  s779 :: SBool = if s747 then s778 else s777+  s780 :: SBool = s7 ^ s135+  s781 :: SBool = if s341 then s780 else s135+  s782 :: SBool = s493 ^ s781+  s783 :: SBool = if s361 then s782 else s781+  s784 :: SBool = s463 ^ s783+  s785 :: SBool = if s383 then s784 else s783+  s786 :: SBool = s435 ^ s785+  s787 :: SBool = if s407 then s786 else s785+  s788 :: SBool = s409 ^ s787+  s789 :: SBool = if s433 then s788 else s787+  s790 :: SBool = s385 ^ s789+  s791 :: SBool = if s461 then s790 else s789+  s792 :: SBool = s363 ^ s791+  s793 :: SBool = if s491 then s792 else s791+  s794 :: SBool = s343 ^ s793+  s795 :: SBool = if s523 then s794 else s793+  s796 :: SBool = s325 ^ s795+  s797 :: SBool = if s555 then s796 else s795+  s798 :: SBool = s309 ^ s797+  s799 :: SBool = if s587 then s798 else s797+  s800 :: SBool = s295 ^ s799+  s801 :: SBool = if s619 then s800 else s799+  s802 :: SBool = s283 ^ s801+  s803 :: SBool = if s651 then s802 else s801+  s804 :: SBool = s273 ^ s803+  s805 :: SBool = if s683 then s804 else s803+  s806 :: SBool = s265 ^ s805+  s807 :: SBool = if s715 then s806 else s805+  s808 :: SBool = s259 ^ s807+  s809 :: SBool = if s747 then s808 else s807+  s810 :: SBool = s255 ^ s809+  s811 :: SBool = if s779 then s810 else s809+  s812 :: SBool = s7 ^ s140+  s813 :: SBool = if s361 then s812 else s140+  s814 :: SBool = s493 ^ s813+  s815 :: SBool = if s383 then s814 else s813+  s816 :: SBool = s463 ^ s815+  s817 :: SBool = if s407 then s816 else s815+  s818 :: SBool = s435 ^ s817+  s819 :: SBool = if s433 then s818 else s817+  s820 :: SBool = s409 ^ s819+  s821 :: SBool = if s461 then s820 else s819+  s822 :: SBool = s385 ^ s821+  s823 :: SBool = if s491 then s822 else s821+  s824 :: SBool = s363 ^ s823+  s825 :: SBool = if s523 then s824 else s823+  s826 :: SBool = s343 ^ s825+  s827 :: SBool = if s555 then s826 else s825+  s828 :: SBool = s325 ^ s827+  s829 :: SBool = if s587 then s828 else s827+  s830 :: SBool = s309 ^ s829+  s831 :: SBool = if s619 then s830 else s829+  s832 :: SBool = s295 ^ s831+  s833 :: SBool = if s651 then s832 else s831+  s834 :: SBool = s283 ^ s833+  s835 :: SBool = if s683 then s834 else s833+  s836 :: SBool = s273 ^ s835+  s837 :: SBool = if s715 then s836 else s835+  s838 :: SBool = s265 ^ s837+  s839 :: SBool = if s747 then s838 else s837+  s840 :: SBool = s259 ^ s839+  s841 :: SBool = if s779 then s840 else s839+  s842 :: SBool = s255 ^ s841+  s843 :: SBool = if s811 then s842 else s841+  s844 :: SBool = s7 ^ s145+  s845 :: SBool = if s383 then s844 else s145+  s846 :: SBool = s493 ^ s845+  s847 :: SBool = if s407 then s846 else s845+  s848 :: SBool = s463 ^ s847+  s849 :: SBool = if s433 then s848 else s847+  s850 :: SBool = s435 ^ s849+  s851 :: SBool = if s461 then s850 else s849+  s852 :: SBool = s409 ^ s851+  s853 :: SBool = if s491 then s852 else s851+  s854 :: SBool = s385 ^ s853+  s855 :: SBool = if s523 then s854 else s853+  s856 :: SBool = s363 ^ s855+  s857 :: SBool = if s555 then s856 else s855+  s858 :: SBool = s343 ^ s857+  s859 :: SBool = if s587 then s858 else s857+  s860 :: SBool = s325 ^ s859+  s861 :: SBool = if s619 then s860 else s859+  s862 :: SBool = s309 ^ s861+  s863 :: SBool = if s651 then s862 else s861+  s864 :: SBool = s295 ^ s863+  s865 :: SBool = if s683 then s864 else s863+  s866 :: SBool = s283 ^ s865+  s867 :: SBool = if s715 then s866 else s865+  s868 :: SBool = s273 ^ s867+  s869 :: SBool = if s747 then s868 else s867+  s870 :: SBool = s265 ^ s869+  s871 :: SBool = if s779 then s870 else s869+  s872 :: SBool = s259 ^ s871+  s873 :: SBool = if s811 then s872 else s871+  s874 :: SBool = s255 ^ s873+  s875 :: SBool = if s843 then s874 else s873+  s876 :: SBool = s7 ^ s150+  s877 :: SBool = if s407 then s876 else s150+  s878 :: SBool = s493 ^ s877+  s879 :: SBool = if s433 then s878 else s877+  s880 :: SBool = s463 ^ s879+  s881 :: SBool = if s461 then s880 else s879+  s882 :: SBool = s435 ^ s881+  s883 :: SBool = if s491 then s882 else s881+  s884 :: SBool = s409 ^ s883+  s885 :: SBool = if s523 then s884 else s883+  s886 :: SBool = s385 ^ s885+  s887 :: SBool = if s555 then s886 else s885+  s888 :: SBool = s363 ^ s887+  s889 :: SBool = if s587 then s888 else s887+  s890 :: SBool = s343 ^ s889+  s891 :: SBool = if s619 then s890 else s889+  s892 :: SBool = s325 ^ s891+  s893 :: SBool = if s651 then s892 else s891+  s894 :: SBool = s309 ^ s893+  s895 :: SBool = if s683 then s894 else s893+  s896 :: SBool = s295 ^ s895+  s897 :: SBool = if s715 then s896 else s895+  s898 :: SBool = s283 ^ s897+  s899 :: SBool = if s747 then s898 else s897+  s900 :: SBool = s273 ^ s899+  s901 :: SBool = if s779 then s900 else s899+  s902 :: SBool = s265 ^ s901+  s903 :: SBool = if s811 then s902 else s901+  s904 :: SBool = s259 ^ s903+  s905 :: SBool = if s843 then s904 else s903+  s906 :: SBool = s255 ^ s905+  s907 :: SBool = if s875 then s906 else s905+  s908 :: SBool = s7 ^ s155+  s909 :: SBool = if s433 then s908 else s155+  s910 :: SBool = s493 ^ s909+  s911 :: SBool = if s461 then s910 else s909+  s912 :: SBool = s463 ^ s911+  s913 :: SBool = if s491 then s912 else s911+  s914 :: SBool = s435 ^ s913+  s915 :: SBool = if s523 then s914 else s913+  s916 :: SBool = s409 ^ s915+  s917 :: SBool = if s555 then s916 else s915+  s918 :: SBool = s385 ^ s917+  s919 :: SBool = if s587 then s918 else s917+  s920 :: SBool = s363 ^ s919+  s921 :: SBool = if s619 then s920 else s919+  s922 :: SBool = s343 ^ s921+  s923 :: SBool = if s651 then s922 else s921+  s924 :: SBool = s325 ^ s923+  s925 :: SBool = if s683 then s924 else s923+  s926 :: SBool = s309 ^ s925+  s927 :: SBool = if s715 then s926 else s925+  s928 :: SBool = s295 ^ s927+  s929 :: SBool = if s747 then s928 else s927+  s930 :: SBool = s283 ^ s929+  s931 :: SBool = if s779 then s930 else s929+  s932 :: SBool = s273 ^ s931+  s933 :: SBool = if s811 then s932 else s931+  s934 :: SBool = s265 ^ s933+  s935 :: SBool = if s843 then s934 else s933+  s936 :: SBool = s259 ^ s935+  s937 :: SBool = if s875 then s936 else s935+  s938 :: SBool = s255 ^ s937+  s939 :: SBool = if s907 then s938 else s937+  s940 :: SBool = s7 ^ s160+  s941 :: SBool = if s461 then s940 else s160+  s942 :: SBool = s493 ^ s941+  s943 :: SBool = if s491 then s942 else s941+  s944 :: SBool = s463 ^ s943+  s945 :: SBool = if s523 then s944 else s943+  s946 :: SBool = s435 ^ s945+  s947 :: SBool = if s555 then s946 else s945+  s948 :: SBool = s409 ^ s947+  s949 :: SBool = if s587 then s948 else s947+  s950 :: SBool = s385 ^ s949+  s951 :: SBool = if s619 then s950 else s949+  s952 :: SBool = s363 ^ s951+  s953 :: SBool = if s651 then s952 else s951+  s954 :: SBool = s343 ^ s953+  s955 :: SBool = if s683 then s954 else s953+  s956 :: SBool = s325 ^ s955+  s957 :: SBool = if s715 then s956 else s955+  s958 :: SBool = s309 ^ s957+  s959 :: SBool = if s747 then s958 else s957+  s960 :: SBool = s295 ^ s959+  s961 :: SBool = if s779 then s960 else s959+  s962 :: SBool = s283 ^ s961+  s963 :: SBool = if s811 then s962 else s961+  s964 :: SBool = s273 ^ s963+  s965 :: SBool = if s843 then s964 else s963+  s966 :: SBool = s265 ^ s965+  s967 :: SBool = if s875 then s966 else s965+  s968 :: SBool = s259 ^ s967+  s969 :: SBool = if s907 then s968 else s967+  s970 :: SBool = s255 ^ s969+  s971 :: SBool = if s939 then s970 else s969+  s972 :: SBool = s7 ^ s165+  s973 :: SBool = if s491 then s972 else s165+  s974 :: SBool = s493 ^ s973+  s975 :: SBool = if s523 then s974 else s973+  s976 :: SBool = s463 ^ s975+  s977 :: SBool = if s555 then s976 else s975+  s978 :: SBool = s435 ^ s977+  s979 :: SBool = if s587 then s978 else s977+  s980 :: SBool = s409 ^ s979+  s981 :: SBool = if s619 then s980 else s979+  s982 :: SBool = s385 ^ s981+  s983 :: SBool = if s651 then s982 else s981+  s984 :: SBool = s363 ^ s983+  s985 :: SBool = if s683 then s984 else s983+  s986 :: SBool = s343 ^ s985+  s987 :: SBool = if s715 then s986 else s985+  s988 :: SBool = s325 ^ s987+  s989 :: SBool = if s747 then s988 else s987+  s990 :: SBool = s309 ^ s989+  s991 :: SBool = if s779 then s990 else s989+  s992 :: SBool = s295 ^ s991+  s993 :: SBool = if s811 then s992 else s991+  s994 :: SBool = s283 ^ s993+  s995 :: SBool = if s843 then s994 else s993+  s996 :: SBool = s273 ^ s995+  s997 :: SBool = if s875 then s996 else s995+  s998 :: SBool = s265 ^ s997+  s999 :: SBool = if s907 then s998 else s997+  s1000 :: SBool = s259 ^ s999+  s1001 :: SBool = if s939 then s1000 else s999+  s1002 :: SBool = s255 ^ s1001+  s1003 :: SBool = if s971 then s1002 else s1001+  s1004 :: SBool = s7 ^ s170+  s1005 :: SBool = if s523 then s1004 else s170+  s1006 :: SBool = s493 ^ s1005+  s1007 :: SBool = if s555 then s1006 else s1005+  s1008 :: SBool = s463 ^ s1007+  s1009 :: SBool = if s587 then s1008 else s1007+  s1010 :: SBool = s435 ^ s1009+  s1011 :: SBool = if s619 then s1010 else s1009+  s1012 :: SBool = s409 ^ s1011+  s1013 :: SBool = if s651 then s1012 else s1011+  s1014 :: SBool = s385 ^ s1013+  s1015 :: SBool = if s683 then s1014 else s1013+  s1016 :: SBool = s363 ^ s1015+  s1017 :: SBool = if s715 then s1016 else s1015+  s1018 :: SBool = s343 ^ s1017+  s1019 :: SBool = if s747 then s1018 else s1017+  s1020 :: SBool = s325 ^ s1019+  s1021 :: SBool = if s779 then s1020 else s1019+  s1022 :: SBool = s309 ^ s1021+  s1023 :: SBool = if s811 then s1022 else s1021+  s1024 :: SBool = s295 ^ s1023+  s1025 :: SBool = if s843 then s1024 else s1023+  s1026 :: SBool = s283 ^ s1025+  s1027 :: SBool = if s875 then s1026 else s1025+  s1028 :: SBool = s273 ^ s1027+  s1029 :: SBool = if s907 then s1028 else s1027+  s1030 :: SBool = s265 ^ s1029+  s1031 :: SBool = if s939 then s1030 else s1029+  s1032 :: SBool = s259 ^ s1031+  s1033 :: SBool = if s971 then s1032 else s1031+  s1034 :: SBool = s255 ^ s1033+  s1035 :: SBool = if s1003 then s1034 else s1033+  s1036 :: SBool = s7 ^ s175+  s1037 :: SBool = if s555 then s1036 else s175+  s1038 :: SBool = s493 ^ s1037+  s1039 :: SBool = if s587 then s1038 else s1037+  s1040 :: SBool = s463 ^ s1039+  s1041 :: SBool = if s619 then s1040 else s1039+  s1042 :: SBool = s435 ^ s1041+  s1043 :: SBool = if s651 then s1042 else s1041+  s1044 :: SBool = s409 ^ s1043+  s1045 :: SBool = if s683 then s1044 else s1043+  s1046 :: SBool = s385 ^ s1045+  s1047 :: SBool = if s715 then s1046 else s1045+  s1048 :: SBool = s363 ^ s1047+  s1049 :: SBool = if s747 then s1048 else s1047+  s1050 :: SBool = s343 ^ s1049+  s1051 :: SBool = if s779 then s1050 else s1049+  s1052 :: SBool = s325 ^ s1051+  s1053 :: SBool = if s811 then s1052 else s1051+  s1054 :: SBool = s309 ^ s1053+  s1055 :: SBool = if s843 then s1054 else s1053+  s1056 :: SBool = s295 ^ s1055+  s1057 :: SBool = if s875 then s1056 else s1055+  s1058 :: SBool = s283 ^ s1057+  s1059 :: SBool = if s907 then s1058 else s1057+  s1060 :: SBool = s273 ^ s1059+  s1061 :: SBool = if s939 then s1060 else s1059+  s1062 :: SBool = s265 ^ s1061+  s1063 :: SBool = if s971 then s1062 else s1061+  s1064 :: SBool = s259 ^ s1063+  s1065 :: SBool = if s1003 then s1064 else s1063+  s1066 :: SBool = s255 ^ s1065+  s1067 :: SBool = if s1035 then s1066 else s1065+  s1068 :: SBool = s7 ^ s180+  s1069 :: SBool = if s587 then s1068 else s180+  s1070 :: SBool = s493 ^ s1069+  s1071 :: SBool = if s619 then s1070 else s1069+  s1072 :: SBool = s463 ^ s1071+  s1073 :: SBool = if s651 then s1072 else s1071+  s1074 :: SBool = s435 ^ s1073+  s1075 :: SBool = if s683 then s1074 else s1073+  s1076 :: SBool = s409 ^ s1075+  s1077 :: SBool = if s715 then s1076 else s1075+  s1078 :: SBool = s385 ^ s1077+  s1079 :: SBool = if s747 then s1078 else s1077+  s1080 :: SBool = s363 ^ s1079+  s1081 :: SBool = if s779 then s1080 else s1079+  s1082 :: SBool = s343 ^ s1081+  s1083 :: SBool = if s811 then s1082 else s1081+  s1084 :: SBool = s325 ^ s1083+  s1085 :: SBool = if s843 then s1084 else s1083+  s1086 :: SBool = s309 ^ s1085+  s1087 :: SBool = if s875 then s1086 else s1085+  s1088 :: SBool = s295 ^ s1087+  s1089 :: SBool = if s907 then s1088 else s1087+  s1090 :: SBool = s283 ^ s1089+  s1091 :: SBool = if s939 then s1090 else s1089+  s1092 :: SBool = s273 ^ s1091+  s1093 :: SBool = if s971 then s1092 else s1091+  s1094 :: SBool = s265 ^ s1093+  s1095 :: SBool = if s1003 then s1094 else s1093+  s1096 :: SBool = s259 ^ s1095+  s1097 :: SBool = if s1035 then s1096 else s1095+  s1098 :: SBool = s255 ^ s1097+  s1099 :: SBool = if s1067 then s1098 else s1097+  s1100 :: SBool = s7 ^ s185+  s1101 :: SBool = if s619 then s1100 else s185+  s1102 :: SBool = s493 ^ s1101+  s1103 :: SBool = if s651 then s1102 else s1101+  s1104 :: SBool = s463 ^ s1103+  s1105 :: SBool = if s683 then s1104 else s1103+  s1106 :: SBool = s435 ^ s1105+  s1107 :: SBool = if s715 then s1106 else s1105+  s1108 :: SBool = s409 ^ s1107+  s1109 :: SBool = if s747 then s1108 else s1107+  s1110 :: SBool = s385 ^ s1109+  s1111 :: SBool = if s779 then s1110 else s1109+  s1112 :: SBool = s363 ^ s1111+  s1113 :: SBool = if s811 then s1112 else s1111+  s1114 :: SBool = s343 ^ s1113+  s1115 :: SBool = if s843 then s1114 else s1113+  s1116 :: SBool = s325 ^ s1115+  s1117 :: SBool = if s875 then s1116 else s1115+  s1118 :: SBool = s309 ^ s1117+  s1119 :: SBool = if s907 then s1118 else s1117+  s1120 :: SBool = s295 ^ s1119+  s1121 :: SBool = if s939 then s1120 else s1119+  s1122 :: SBool = s283 ^ s1121+  s1123 :: SBool = if s971 then s1122 else s1121+  s1124 :: SBool = s273 ^ s1123+  s1125 :: SBool = if s1003 then s1124 else s1123+  s1126 :: SBool = s265 ^ s1125+  s1127 :: SBool = if s1035 then s1126 else s1125+  s1128 :: SBool = s259 ^ s1127+  s1129 :: SBool = if s1067 then s1128 else s1127+  s1130 :: SBool = s255 ^ s1129+  s1131 :: SBool = if s1099 then s1130 else s1129+  s1132 :: SBool = s7 ^ s190+  s1133 :: SBool = if s651 then s1132 else s190+  s1134 :: SBool = s493 ^ s1133+  s1135 :: SBool = if s683 then s1134 else s1133+  s1136 :: SBool = s463 ^ s1135+  s1137 :: SBool = if s715 then s1136 else s1135+  s1138 :: SBool = s435 ^ s1137+  s1139 :: SBool = if s747 then s1138 else s1137+  s1140 :: SBool = s409 ^ s1139+  s1141 :: SBool = if s779 then s1140 else s1139+  s1142 :: SBool = s385 ^ s1141+  s1143 :: SBool = if s811 then s1142 else s1141+  s1144 :: SBool = s363 ^ s1143+  s1145 :: SBool = if s843 then s1144 else s1143+  s1146 :: SBool = s343 ^ s1145+  s1147 :: SBool = if s875 then s1146 else s1145+  s1148 :: SBool = s325 ^ s1147+  s1149 :: SBool = if s907 then s1148 else s1147+  s1150 :: SBool = s309 ^ s1149+  s1151 :: SBool = if s939 then s1150 else s1149+  s1152 :: SBool = s295 ^ s1151+  s1153 :: SBool = if s971 then s1152 else s1151+  s1154 :: SBool = s283 ^ s1153+  s1155 :: SBool = if s1003 then s1154 else s1153+  s1156 :: SBool = s273 ^ s1155+  s1157 :: SBool = if s1035 then s1156 else s1155+  s1158 :: SBool = s265 ^ s1157+  s1159 :: SBool = if s1067 then s1158 else s1157+  s1160 :: SBool = s259 ^ s1159+  s1161 :: SBool = if s1099 then s1160 else s1159+  s1162 :: SBool = s255 ^ s1161+  s1163 :: SBool = if s1131 then s1162 else s1161+  s1164 :: SBool = s7 ^ s195+  s1165 :: SBool = if s683 then s1164 else s195+  s1166 :: SBool = s493 ^ s1165+  s1167 :: SBool = if s715 then s1166 else s1165+  s1168 :: SBool = s463 ^ s1167+  s1169 :: SBool = if s747 then s1168 else s1167+  s1170 :: SBool = s435 ^ s1169+  s1171 :: SBool = if s779 then s1170 else s1169+  s1172 :: SBool = s409 ^ s1171+  s1173 :: SBool = if s811 then s1172 else s1171+  s1174 :: SBool = s385 ^ s1173+  s1175 :: SBool = if s843 then s1174 else s1173+  s1176 :: SBool = s363 ^ s1175+  s1177 :: SBool = if s875 then s1176 else s1175+  s1178 :: SBool = s343 ^ s1177+  s1179 :: SBool = if s907 then s1178 else s1177+  s1180 :: SBool = s325 ^ s1179+  s1181 :: SBool = if s939 then s1180 else s1179+  s1182 :: SBool = s309 ^ s1181+  s1183 :: SBool = if s971 then s1182 else s1181+  s1184 :: SBool = s295 ^ s1183+  s1185 :: SBool = if s1003 then s1184 else s1183+  s1186 :: SBool = s283 ^ s1185+  s1187 :: SBool = if s1035 then s1186 else s1185+  s1188 :: SBool = s273 ^ s1187+  s1189 :: SBool = if s1067 then s1188 else s1187+  s1190 :: SBool = s265 ^ s1189+  s1191 :: SBool = if s1099 then s1190 else s1189+  s1192 :: SBool = s259 ^ s1191+  s1193 :: SBool = if s1131 then s1192 else s1191+  s1194 :: SBool = s255 ^ s1193+  s1195 :: SBool = if s1163 then s1194 else s1193+  s1196 :: SBool = s7 ^ s200+  s1197 :: SBool = if s715 then s1196 else s200+  s1198 :: SBool = s493 ^ s1197+  s1199 :: SBool = if s747 then s1198 else s1197+  s1200 :: SBool = s463 ^ s1199+  s1201 :: SBool = if s779 then s1200 else s1199+  s1202 :: SBool = s435 ^ s1201+  s1203 :: SBool = if s811 then s1202 else s1201+  s1204 :: SBool = s409 ^ s1203+  s1205 :: SBool = if s843 then s1204 else s1203+  s1206 :: SBool = s385 ^ s1205+  s1207 :: SBool = if s875 then s1206 else s1205+  s1208 :: SBool = s363 ^ s1207+  s1209 :: SBool = if s907 then s1208 else s1207+  s1210 :: SBool = s343 ^ s1209+  s1211 :: SBool = if s939 then s1210 else s1209+  s1212 :: SBool = s325 ^ s1211+  s1213 :: SBool = if s971 then s1212 else s1211+  s1214 :: SBool = s309 ^ s1213+  s1215 :: SBool = if s1003 then s1214 else s1213+  s1216 :: SBool = s295 ^ s1215+  s1217 :: SBool = if s1035 then s1216 else s1215+  s1218 :: SBool = s283 ^ s1217+  s1219 :: SBool = if s1067 then s1218 else s1217+  s1220 :: SBool = s273 ^ s1219+  s1221 :: SBool = if s1099 then s1220 else s1219+  s1222 :: SBool = s265 ^ s1221+  s1223 :: SBool = if s1131 then s1222 else s1221+  s1224 :: SBool = s259 ^ s1223+  s1225 :: SBool = if s1163 then s1224 else s1223+  s1226 :: SBool = s255 ^ s1225+  s1227 :: SBool = if s1195 then s1226 else s1225+  s1228 :: SBool = s7 ^ s205+  s1229 :: SBool = if s747 then s1228 else s205+  s1230 :: SBool = s493 ^ s1229+  s1231 :: SBool = if s779 then s1230 else s1229+  s1232 :: SBool = s463 ^ s1231+  s1233 :: SBool = if s811 then s1232 else s1231+  s1234 :: SBool = s435 ^ s1233+  s1235 :: SBool = if s843 then s1234 else s1233+  s1236 :: SBool = s409 ^ s1235+  s1237 :: SBool = if s875 then s1236 else s1235+  s1238 :: SBool = s385 ^ s1237+  s1239 :: SBool = if s907 then s1238 else s1237+  s1240 :: SBool = s363 ^ s1239+  s1241 :: SBool = if s939 then s1240 else s1239+  s1242 :: SBool = s343 ^ s1241+  s1243 :: SBool = if s971 then s1242 else s1241+  s1244 :: SBool = s325 ^ s1243+  s1245 :: SBool = if s1003 then s1244 else s1243+  s1246 :: SBool = s309 ^ s1245+  s1247 :: SBool = if s1035 then s1246 else s1245+  s1248 :: SBool = s295 ^ s1247+  s1249 :: SBool = if s1067 then s1248 else s1247+  s1250 :: SBool = s283 ^ s1249+  s1251 :: SBool = if s1099 then s1250 else s1249+  s1252 :: SBool = s273 ^ s1251+  s1253 :: SBool = if s1131 then s1252 else s1251+  s1254 :: SBool = s265 ^ s1253+  s1255 :: SBool = if s1163 then s1254 else s1253+  s1256 :: SBool = s259 ^ s1255+  s1257 :: SBool = if s1195 then s1256 else s1255+  s1258 :: SBool = s255 ^ s1257+  s1259 :: SBool = if s1227 then s1258 else s1257+  s1260 :: SBool = s7 ^ s210+  s1261 :: SBool = if s779 then s1260 else s210+  s1262 :: SBool = s493 ^ s1261+  s1263 :: SBool = if s811 then s1262 else s1261+  s1264 :: SBool = s463 ^ s1263+  s1265 :: SBool = if s843 then s1264 else s1263+  s1266 :: SBool = s435 ^ s1265+  s1267 :: SBool = if s875 then s1266 else s1265+  s1268 :: SBool = s409 ^ s1267+  s1269 :: SBool = if s907 then s1268 else s1267+  s1270 :: SBool = s385 ^ s1269+  s1271 :: SBool = if s939 then s1270 else s1269+  s1272 :: SBool = s363 ^ s1271+  s1273 :: SBool = if s971 then s1272 else s1271+  s1274 :: SBool = s343 ^ s1273+  s1275 :: SBool = if s1003 then s1274 else s1273+  s1276 :: SBool = s325 ^ s1275+  s1277 :: SBool = if s1035 then s1276 else s1275+  s1278 :: SBool = s309 ^ s1277+  s1279 :: SBool = if s1067 then s1278 else s1277+  s1280 :: SBool = s295 ^ s1279+  s1281 :: SBool = if s1099 then s1280 else s1279+  s1282 :: SBool = s283 ^ s1281+  s1283 :: SBool = if s1131 then s1282 else s1281+  s1284 :: SBool = s273 ^ s1283+  s1285 :: SBool = if s1163 then s1284 else s1283+  s1286 :: SBool = s265 ^ s1285+  s1287 :: SBool = if s1195 then s1286 else s1285+  s1288 :: SBool = s259 ^ s1287+  s1289 :: SBool = if s1227 then s1288 else s1287+  s1290 :: SBool = s255 ^ s1289+  s1291 :: SBool = if s1259 then s1290 else s1289+  s1292 :: SBool = s7 ^ s215+  s1293 :: SBool = if s811 then s1292 else s215+  s1294 :: SBool = s493 ^ s1293+  s1295 :: SBool = if s843 then s1294 else s1293+  s1296 :: SBool = s463 ^ s1295+  s1297 :: SBool = if s875 then s1296 else s1295+  s1298 :: SBool = s435 ^ s1297+  s1299 :: SBool = if s907 then s1298 else s1297+  s1300 :: SBool = s409 ^ s1299+  s1301 :: SBool = if s939 then s1300 else s1299+  s1302 :: SBool = s385 ^ s1301+  s1303 :: SBool = if s971 then s1302 else s1301+  s1304 :: SBool = s363 ^ s1303+  s1305 :: SBool = if s1003 then s1304 else s1303+  s1306 :: SBool = s343 ^ s1305+  s1307 :: SBool = if s1035 then s1306 else s1305+  s1308 :: SBool = s325 ^ s1307+  s1309 :: SBool = if s1067 then s1308 else s1307+  s1310 :: SBool = s309 ^ s1309+  s1311 :: SBool = if s1099 then s1310 else s1309+  s1312 :: SBool = s295 ^ s1311+  s1313 :: SBool = if s1131 then s1312 else s1311+  s1314 :: SBool = s283 ^ s1313+  s1315 :: SBool = if s1163 then s1314 else s1313+  s1316 :: SBool = s273 ^ s1315+  s1317 :: SBool = if s1195 then s1316 else s1315+  s1318 :: SBool = s265 ^ s1317+  s1319 :: SBool = if s1227 then s1318 else s1317+  s1320 :: SBool = s259 ^ s1319+  s1321 :: SBool = if s1259 then s1320 else s1319+  s1322 :: SBool = s255 ^ s1321+  s1323 :: SBool = if s1291 then s1322 else s1321+  s1324 :: SBool = s7 ^ s220+  s1325 :: SBool = if s843 then s1324 else s220+  s1326 :: SBool = s493 ^ s1325+  s1327 :: SBool = if s875 then s1326 else s1325+  s1328 :: SBool = s463 ^ s1327+  s1329 :: SBool = if s907 then s1328 else s1327+  s1330 :: SBool = s435 ^ s1329+  s1331 :: SBool = if s939 then s1330 else s1329+  s1332 :: SBool = s409 ^ s1331+  s1333 :: SBool = if s971 then s1332 else s1331+  s1334 :: SBool = s385 ^ s1333+  s1335 :: SBool = if s1003 then s1334 else s1333+  s1336 :: SBool = s363 ^ s1335+  s1337 :: SBool = if s1035 then s1336 else s1335+  s1338 :: SBool = s343 ^ s1337+  s1339 :: SBool = if s1067 then s1338 else s1337+  s1340 :: SBool = s325 ^ s1339+  s1341 :: SBool = if s1099 then s1340 else s1339+  s1342 :: SBool = s309 ^ s1341+  s1343 :: SBool = if s1131 then s1342 else s1341+  s1344 :: SBool = s295 ^ s1343+  s1345 :: SBool = if s1163 then s1344 else s1343+  s1346 :: SBool = s283 ^ s1345+  s1347 :: SBool = if s1195 then s1346 else s1345+  s1348 :: SBool = s273 ^ s1347+  s1349 :: SBool = if s1227 then s1348 else s1347+  s1350 :: SBool = s265 ^ s1349+  s1351 :: SBool = if s1259 then s1350 else s1349+  s1352 :: SBool = s259 ^ s1351+  s1353 :: SBool = if s1291 then s1352 else s1351+  s1354 :: SBool = s255 ^ s1353+  s1355 :: SBool = if s1323 then s1354 else s1353+  s1356 :: SBool = s7 ^ s225+  s1357 :: SBool = if s875 then s1356 else s225+  s1358 :: SBool = s493 ^ s1357+  s1359 :: SBool = if s907 then s1358 else s1357+  s1360 :: SBool = s463 ^ s1359+  s1361 :: SBool = if s939 then s1360 else s1359+  s1362 :: SBool = s435 ^ s1361+  s1363 :: SBool = if s971 then s1362 else s1361+  s1364 :: SBool = s409 ^ s1363+  s1365 :: SBool = if s1003 then s1364 else s1363+  s1366 :: SBool = s385 ^ s1365+  s1367 :: SBool = if s1035 then s1366 else s1365+  s1368 :: SBool = s363 ^ s1367+  s1369 :: SBool = if s1067 then s1368 else s1367+  s1370 :: SBool = s343 ^ s1369+  s1371 :: SBool = if s1099 then s1370 else s1369+  s1372 :: SBool = s325 ^ s1371+  s1373 :: SBool = if s1131 then s1372 else s1371+  s1374 :: SBool = s309 ^ s1373+  s1375 :: SBool = if s1163 then s1374 else s1373+  s1376 :: SBool = s295 ^ s1375+  s1377 :: SBool = if s1195 then s1376 else s1375+  s1378 :: SBool = s283 ^ s1377+  s1379 :: SBool = if s1227 then s1378 else s1377+  s1380 :: SBool = s273 ^ s1379+  s1381 :: SBool = if s1259 then s1380 else s1379+  s1382 :: SBool = s265 ^ s1381+  s1383 :: SBool = if s1291 then s1382 else s1381+  s1384 :: SBool = s259 ^ s1383+  s1385 :: SBool = if s1323 then s1384 else s1383+  s1386 :: SBool = s255 ^ s1385+  s1387 :: SBool = if s1355 then s1386 else s1385+  s1388 :: SBool = s7 ^ s230+  s1389 :: SBool = if s907 then s1388 else s230+  s1390 :: SBool = s493 ^ s1389+  s1391 :: SBool = if s939 then s1390 else s1389+  s1392 :: SBool = s463 ^ s1391+  s1393 :: SBool = if s971 then s1392 else s1391+  s1394 :: SBool = s435 ^ s1393+  s1395 :: SBool = if s1003 then s1394 else s1393+  s1396 :: SBool = s409 ^ s1395+  s1397 :: SBool = if s1035 then s1396 else s1395+  s1398 :: SBool = s385 ^ s1397+  s1399 :: SBool = if s1067 then s1398 else s1397+  s1400 :: SBool = s363 ^ s1399+  s1401 :: SBool = if s1099 then s1400 else s1399+  s1402 :: SBool = s343 ^ s1401+  s1403 :: SBool = if s1131 then s1402 else s1401+  s1404 :: SBool = s325 ^ s1403+  s1405 :: SBool = if s1163 then s1404 else s1403+  s1406 :: SBool = s309 ^ s1405+  s1407 :: SBool = if s1195 then s1406 else s1405+  s1408 :: SBool = s295 ^ s1407+  s1409 :: SBool = if s1227 then s1408 else s1407+  s1410 :: SBool = s283 ^ s1409+  s1411 :: SBool = if s1259 then s1410 else s1409+  s1412 :: SBool = s273 ^ s1411+  s1413 :: SBool = if s1291 then s1412 else s1411+  s1414 :: SBool = s265 ^ s1413+  s1415 :: SBool = if s1323 then s1414 else s1413+  s1416 :: SBool = s259 ^ s1415+  s1417 :: SBool = if s1355 then s1416 else s1415+  s1418 :: SBool = s255 ^ s1417+  s1419 :: SBool = if s1387 then s1418 else s1417+  s1420 :: SBool = s7 ^ s235+  s1421 :: SBool = if s939 then s1420 else s235+  s1422 :: SBool = s493 ^ s1421+  s1423 :: SBool = if s971 then s1422 else s1421+  s1424 :: SBool = s463 ^ s1423+  s1425 :: SBool = if s1003 then s1424 else s1423+  s1426 :: SBool = s435 ^ s1425+  s1427 :: SBool = if s1035 then s1426 else s1425+  s1428 :: SBool = s409 ^ s1427+  s1429 :: SBool = if s1067 then s1428 else s1427+  s1430 :: SBool = s385 ^ s1429+  s1431 :: SBool = if s1099 then s1430 else s1429+  s1432 :: SBool = s363 ^ s1431+  s1433 :: SBool = if s1131 then s1432 else s1431+  s1434 :: SBool = s343 ^ s1433+  s1435 :: SBool = if s1163 then s1434 else s1433+  s1436 :: SBool = s325 ^ s1435+  s1437 :: SBool = if s1195 then s1436 else s1435+  s1438 :: SBool = s309 ^ s1437+  s1439 :: SBool = if s1227 then s1438 else s1437+  s1440 :: SBool = s295 ^ s1439+  s1441 :: SBool = if s1259 then s1440 else s1439+  s1442 :: SBool = s283 ^ s1441+  s1443 :: SBool = if s1291 then s1442 else s1441+  s1444 :: SBool = s273 ^ s1443+  s1445 :: SBool = if s1323 then s1444 else s1443+  s1446 :: SBool = s265 ^ s1445+  s1447 :: SBool = if s1355 then s1446 else s1445+  s1448 :: SBool = s259 ^ s1447+  s1449 :: SBool = if s1387 then s1448 else s1447+  s1450 :: SBool = s255 ^ s1449+  s1451 :: SBool = if s1419 then s1450 else s1449+  s1452 :: SBool = s7 ^ s240+  s1453 :: SBool = if s971 then s1452 else s240+  s1454 :: SBool = s493 ^ s1453+  s1455 :: SBool = if s1003 then s1454 else s1453+  s1456 :: SBool = s463 ^ s1455+  s1457 :: SBool = if s1035 then s1456 else s1455+  s1458 :: SBool = s435 ^ s1457+  s1459 :: SBool = if s1067 then s1458 else s1457+  s1460 :: SBool = s409 ^ s1459+  s1461 :: SBool = if s1099 then s1460 else s1459+  s1462 :: SBool = s385 ^ s1461+  s1463 :: SBool = if s1131 then s1462 else s1461+  s1464 :: SBool = s363 ^ s1463+  s1465 :: SBool = if s1163 then s1464 else s1463+  s1466 :: SBool = s343 ^ s1465+  s1467 :: SBool = if s1195 then s1466 else s1465+  s1468 :: SBool = s325 ^ s1467+  s1469 :: SBool = if s1227 then s1468 else s1467+  s1470 :: SBool = s309 ^ s1469+  s1471 :: SBool = if s1259 then s1470 else s1469+  s1472 :: SBool = s295 ^ s1471+  s1473 :: SBool = if s1291 then s1472 else s1471+  s1474 :: SBool = s283 ^ s1473+  s1475 :: SBool = if s1323 then s1474 else s1473+  s1476 :: SBool = s273 ^ s1475+  s1477 :: SBool = if s1355 then s1476 else s1475+  s1478 :: SBool = s265 ^ s1477+  s1479 :: SBool = if s1387 then s1478 else s1477+  s1480 :: SBool = s259 ^ s1479+  s1481 :: SBool = if s1419 then s1480 else s1479+  s1482 :: SBool = s255 ^ s1481+  s1483 :: SBool = if s1451 then s1482 else s1481+  s1484 :: SBool = s7 ^ s245+  s1485 :: SBool = if s1003 then s1484 else s245+  s1486 :: SBool = s493 ^ s1485+  s1487 :: SBool = if s1035 then s1486 else s1485+  s1488 :: SBool = s463 ^ s1487+  s1489 :: SBool = if s1067 then s1488 else s1487+  s1490 :: SBool = s435 ^ s1489+  s1491 :: SBool = if s1099 then s1490 else s1489+  s1492 :: SBool = s409 ^ s1491+  s1493 :: SBool = if s1131 then s1492 else s1491+  s1494 :: SBool = s385 ^ s1493+  s1495 :: SBool = if s1163 then s1494 else s1493+  s1496 :: SBool = s363 ^ s1495+  s1497 :: SBool = if s1195 then s1496 else s1495+  s1498 :: SBool = s343 ^ s1497+  s1499 :: SBool = if s1227 then s1498 else s1497+  s1500 :: SBool = s325 ^ s1499+  s1501 :: SBool = if s1259 then s1500 else s1499+  s1502 :: SBool = s309 ^ s1501+  s1503 :: SBool = if s1291 then s1502 else s1501+  s1504 :: SBool = s295 ^ s1503+  s1505 :: SBool = if s1323 then s1504 else s1503+  s1506 :: SBool = s283 ^ s1505+  s1507 :: SBool = if s1355 then s1506 else s1505+  s1508 :: SBool = s273 ^ s1507+  s1509 :: SBool = if s1387 then s1508 else s1507+  s1510 :: SBool = s265 ^ s1509+  s1511 :: SBool = if s1419 then s1510 else s1509+  s1512 :: SBool = s259 ^ s1511+  s1513 :: SBool = if s1451 then s1512 else s1511+  s1514 :: SBool = s255 ^ s1513+  s1515 :: SBool = if s1483 then s1514 else s1513+  s1516 :: SBool = s7 ^ s250+  s1517 :: SBool = if s1035 then s1516 else s250+  s1518 :: SBool = s493 ^ s1517+  s1519 :: SBool = if s1067 then s1518 else s1517+  s1520 :: SBool = s463 ^ s1519+  s1521 :: SBool = if s1099 then s1520 else s1519+  s1522 :: SBool = s435 ^ s1521+  s1523 :: SBool = if s1131 then s1522 else s1521+  s1524 :: SBool = s409 ^ s1523+  s1525 :: SBool = if s1163 then s1524 else s1523+  s1526 :: SBool = s385 ^ s1525+  s1527 :: SBool = if s1195 then s1526 else s1525+  s1528 :: SBool = s363 ^ s1527+  s1529 :: SBool = if s1227 then s1528 else s1527+  s1530 :: SBool = s343 ^ s1529+  s1531 :: SBool = if s1259 then s1530 else s1529+  s1532 :: SBool = s325 ^ s1531+  s1533 :: SBool = if s1291 then s1532 else s1531+  s1534 :: SBool = s309 ^ s1533+  s1535 :: SBool = if s1323 then s1534 else s1533+  s1536 :: SBool = s295 ^ s1535+  s1537 :: SBool = if s1355 then s1536 else s1535+  s1538 :: SBool = s283 ^ s1537+  s1539 :: SBool = if s1387 then s1538 else s1537+  s1540 :: SBool = s273 ^ s1539+  s1541 :: SBool = if s1419 then s1540 else s1539+  s1542 :: SBool = s265 ^ s1541+  s1543 :: SBool = if s1451 then s1542 else s1541+  s1544 :: SBool = s259 ^ s1543+  s1545 :: SBool = if s1483 then s1544 else s1543+  s1546 :: SBool = s255 ^ s1545+  s1547 :: SBool = if s1515 then s1546 else s1545+  s1548 :: SBool = if s1067 then s7 else s_2+  s1549 :: SBool = s493 ^ s1548+  s1550 :: SBool = if s1099 then s1549 else s1548+  s1551 :: SBool = s463 ^ s1550+  s1552 :: SBool = if s1131 then s1551 else s1550+  s1553 :: SBool = s435 ^ s1552+  s1554 :: SBool = if s1163 then s1553 else s1552+  s1555 :: SBool = s409 ^ s1554+  s1556 :: SBool = if s1195 then s1555 else s1554+  s1557 :: SBool = s385 ^ s1556+  s1558 :: SBool = if s1227 then s1557 else s1556+  s1559 :: SBool = s363 ^ s1558+  s1560 :: SBool = if s1259 then s1559 else s1558+  s1561 :: SBool = s343 ^ s1560+  s1562 :: SBool = if s1291 then s1561 else s1560+  s1563 :: SBool = s325 ^ s1562+  s1564 :: SBool = if s1323 then s1563 else s1562+  s1565 :: SBool = s309 ^ s1564+  s1566 :: SBool = if s1355 then s1565 else s1564+  s1567 :: SBool = s295 ^ s1566+  s1568 :: SBool = if s1387 then s1567 else s1566+  s1569 :: SBool = s283 ^ s1568+  s1570 :: SBool = if s1419 then s1569 else s1568+  s1571 :: SBool = s273 ^ s1570+  s1572 :: SBool = if s1451 then s1571 else s1570+  s1573 :: SBool = s265 ^ s1572+  s1574 :: SBool = if s1483 then s1573 else s1572+  s1575 :: SBool = s259 ^ s1574+  s1576 :: SBool = if s1515 then s1575 else s1574+  s1577 :: SBool = s255 ^ s1576+  s1578 :: SBool = if s1547 then s1577 else s1576+  s1579 :: SBool = s22 ^ s255+  s1580 :: SBool = if s16 then s1579 else s22+  s1581 :: SBool = s27 ^ s259+  s1582 :: SBool = if s16 then s1581 else s27+  s1583 :: SBool = s255 ^ s1582+  s1584 :: SBool = if s1580 then s1583 else s1582+  s1585 :: SBool = s32 ^ s265+  s1586 :: SBool = if s16 then s1585 else s32+  s1587 :: SBool = s259 ^ s1586+  s1588 :: SBool = if s1580 then s1587 else s1586+  s1589 :: SBool = s255 ^ s1588+  s1590 :: SBool = if s1584 then s1589 else s1588+  s1591 :: SBool = s37 ^ s273+  s1592 :: SBool = if s16 then s1591 else s37+  s1593 :: SBool = s265 ^ s1592+  s1594 :: SBool = if s1580 then s1593 else s1592+  s1595 :: SBool = s259 ^ s1594+  s1596 :: SBool = if s1584 then s1595 else s1594+  s1597 :: SBool = s255 ^ s1596+  s1598 :: SBool = if s1590 then s1597 else s1596+  s1599 :: SBool = s42 ^ s283+  s1600 :: SBool = if s16 then s1599 else s42+  s1601 :: SBool = s273 ^ s1600+  s1602 :: SBool = if s1580 then s1601 else s1600+  s1603 :: SBool = s265 ^ s1602+  s1604 :: SBool = if s1584 then s1603 else s1602+  s1605 :: SBool = s259 ^ s1604+  s1606 :: SBool = if s1590 then s1605 else s1604+  s1607 :: SBool = s255 ^ s1606+  s1608 :: SBool = if s1598 then s1607 else s1606+  s1609 :: SBool = s47 ^ s295+  s1610 :: SBool = if s16 then s1609 else s47+  s1611 :: SBool = s283 ^ s1610+  s1612 :: SBool = if s1580 then s1611 else s1610+  s1613 :: SBool = s273 ^ s1612+  s1614 :: SBool = if s1584 then s1613 else s1612+  s1615 :: SBool = s265 ^ s1614+  s1616 :: SBool = if s1590 then s1615 else s1614+  s1617 :: SBool = s259 ^ s1616+  s1618 :: SBool = if s1598 then s1617 else s1616+  s1619 :: SBool = s255 ^ s1618+  s1620 :: SBool = if s1608 then s1619 else s1618+  s1621 :: SBool = s52 ^ s309+  s1622 :: SBool = if s16 then s1621 else s52+  s1623 :: SBool = s295 ^ s1622+  s1624 :: SBool = if s1580 then s1623 else s1622+  s1625 :: SBool = s283 ^ s1624+  s1626 :: SBool = if s1584 then s1625 else s1624+  s1627 :: SBool = s273 ^ s1626+  s1628 :: SBool = if s1590 then s1627 else s1626+  s1629 :: SBool = s265 ^ s1628+  s1630 :: SBool = if s1598 then s1629 else s1628+  s1631 :: SBool = s259 ^ s1630+  s1632 :: SBool = if s1608 then s1631 else s1630+  s1633 :: SBool = s255 ^ s1632+  s1634 :: SBool = if s1620 then s1633 else s1632+  s1635 :: SBool = s57 ^ s325+  s1636 :: SBool = if s16 then s1635 else s57+  s1637 :: SBool = s309 ^ s1636+  s1638 :: SBool = if s1580 then s1637 else s1636+  s1639 :: SBool = s295 ^ s1638+  s1640 :: SBool = if s1584 then s1639 else s1638+  s1641 :: SBool = s283 ^ s1640+  s1642 :: SBool = if s1590 then s1641 else s1640+  s1643 :: SBool = s273 ^ s1642+  s1644 :: SBool = if s1598 then s1643 else s1642+  s1645 :: SBool = s265 ^ s1644+  s1646 :: SBool = if s1608 then s1645 else s1644+  s1647 :: SBool = s259 ^ s1646+  s1648 :: SBool = if s1620 then s1647 else s1646+  s1649 :: SBool = s255 ^ s1648+  s1650 :: SBool = if s1634 then s1649 else s1648+  s1651 :: SBool = s62 ^ s343+  s1652 :: SBool = if s16 then s1651 else s62+  s1653 :: SBool = s325 ^ s1652+  s1654 :: SBool = if s1580 then s1653 else s1652+  s1655 :: SBool = s309 ^ s1654+  s1656 :: SBool = if s1584 then s1655 else s1654+  s1657 :: SBool = s295 ^ s1656+  s1658 :: SBool = if s1590 then s1657 else s1656+  s1659 :: SBool = s283 ^ s1658+  s1660 :: SBool = if s1598 then s1659 else s1658+  s1661 :: SBool = s273 ^ s1660+  s1662 :: SBool = if s1608 then s1661 else s1660+  s1663 :: SBool = s265 ^ s1662+  s1664 :: SBool = if s1620 then s1663 else s1662+  s1665 :: SBool = s259 ^ s1664+  s1666 :: SBool = if s1634 then s1665 else s1664+  s1667 :: SBool = s255 ^ s1666+  s1668 :: SBool = if s1650 then s1667 else s1666+  s1669 :: SBool = s67 ^ s363+  s1670 :: SBool = if s16 then s1669 else s67+  s1671 :: SBool = s343 ^ s1670+  s1672 :: SBool = if s1580 then s1671 else s1670+  s1673 :: SBool = s325 ^ s1672+  s1674 :: SBool = if s1584 then s1673 else s1672+  s1675 :: SBool = s309 ^ s1674+  s1676 :: SBool = if s1590 then s1675 else s1674+  s1677 :: SBool = s295 ^ s1676+  s1678 :: SBool = if s1598 then s1677 else s1676+  s1679 :: SBool = s283 ^ s1678+  s1680 :: SBool = if s1608 then s1679 else s1678+  s1681 :: SBool = s273 ^ s1680+  s1682 :: SBool = if s1620 then s1681 else s1680+  s1683 :: SBool = s265 ^ s1682+  s1684 :: SBool = if s1634 then s1683 else s1682+  s1685 :: SBool = s259 ^ s1684+  s1686 :: SBool = if s1650 then s1685 else s1684+  s1687 :: SBool = s255 ^ s1686+  s1688 :: SBool = if s1668 then s1687 else s1686+  s1689 :: SBool = s72 ^ s385+  s1690 :: SBool = if s16 then s1689 else s72+  s1691 :: SBool = s363 ^ s1690+  s1692 :: SBool = if s1580 then s1691 else s1690+  s1693 :: SBool = s343 ^ s1692+  s1694 :: SBool = if s1584 then s1693 else s1692+  s1695 :: SBool = s325 ^ s1694+  s1696 :: SBool = if s1590 then s1695 else s1694+  s1697 :: SBool = s309 ^ s1696+  s1698 :: SBool = if s1598 then s1697 else s1696+  s1699 :: SBool = s295 ^ s1698+  s1700 :: SBool = if s1608 then s1699 else s1698+  s1701 :: SBool = s283 ^ s1700+  s1702 :: SBool = if s1620 then s1701 else s1700+  s1703 :: SBool = s273 ^ s1702+  s1704 :: SBool = if s1634 then s1703 else s1702+  s1705 :: SBool = s265 ^ s1704+  s1706 :: SBool = if s1650 then s1705 else s1704+  s1707 :: SBool = s259 ^ s1706+  s1708 :: SBool = if s1668 then s1707 else s1706+  s1709 :: SBool = s255 ^ s1708+  s1710 :: SBool = if s1688 then s1709 else s1708+  s1711 :: SBool = s77 ^ s409+  s1712 :: SBool = if s16 then s1711 else s77+  s1713 :: SBool = s385 ^ s1712+  s1714 :: SBool = if s1580 then s1713 else s1712+  s1715 :: SBool = s363 ^ s1714+  s1716 :: SBool = if s1584 then s1715 else s1714+  s1717 :: SBool = s343 ^ s1716+  s1718 :: SBool = if s1590 then s1717 else s1716+  s1719 :: SBool = s325 ^ s1718+  s1720 :: SBool = if s1598 then s1719 else s1718+  s1721 :: SBool = s309 ^ s1720+  s1722 :: SBool = if s1608 then s1721 else s1720+  s1723 :: SBool = s295 ^ s1722+  s1724 :: SBool = if s1620 then s1723 else s1722+  s1725 :: SBool = s283 ^ s1724+  s1726 :: SBool = if s1634 then s1725 else s1724+  s1727 :: SBool = s273 ^ s1726+  s1728 :: SBool = if s1650 then s1727 else s1726+  s1729 :: SBool = s265 ^ s1728+  s1730 :: SBool = if s1668 then s1729 else s1728+  s1731 :: SBool = s259 ^ s1730+  s1732 :: SBool = if s1688 then s1731 else s1730+  s1733 :: SBool = s255 ^ s1732+  s1734 :: SBool = if s1710 then s1733 else s1732+  s1735 :: SBool = s82 ^ s435+  s1736 :: SBool = if s16 then s1735 else s82+  s1737 :: SBool = s409 ^ s1736+  s1738 :: SBool = if s1580 then s1737 else s1736+  s1739 :: SBool = s385 ^ s1738+  s1740 :: SBool = if s1584 then s1739 else s1738+  s1741 :: SBool = s363 ^ s1740+  s1742 :: SBool = if s1590 then s1741 else s1740+  s1743 :: SBool = s343 ^ s1742+  s1744 :: SBool = if s1598 then s1743 else s1742+  s1745 :: SBool = s325 ^ s1744+  s1746 :: SBool = if s1608 then s1745 else s1744+  s1747 :: SBool = s309 ^ s1746+  s1748 :: SBool = if s1620 then s1747 else s1746+  s1749 :: SBool = s295 ^ s1748+  s1750 :: SBool = if s1634 then s1749 else s1748+  s1751 :: SBool = s283 ^ s1750+  s1752 :: SBool = if s1650 then s1751 else s1750+  s1753 :: SBool = s273 ^ s1752+  s1754 :: SBool = if s1668 then s1753 else s1752+  s1755 :: SBool = s265 ^ s1754+  s1756 :: SBool = if s1688 then s1755 else s1754+  s1757 :: SBool = s259 ^ s1756+  s1758 :: SBool = if s1710 then s1757 else s1756+  s1759 :: SBool = s255 ^ s1758+  s1760 :: SBool = if s1734 then s1759 else s1758+  s1761 :: SBool = s87 ^ s463+  s1762 :: SBool = if s16 then s1761 else s87+  s1763 :: SBool = s435 ^ s1762+  s1764 :: SBool = if s1580 then s1763 else s1762+  s1765 :: SBool = s409 ^ s1764+  s1766 :: SBool = if s1584 then s1765 else s1764+  s1767 :: SBool = s385 ^ s1766+  s1768 :: SBool = if s1590 then s1767 else s1766+  s1769 :: SBool = s363 ^ s1768+  s1770 :: SBool = if s1598 then s1769 else s1768+  s1771 :: SBool = s343 ^ s1770+  s1772 :: SBool = if s1608 then s1771 else s1770+  s1773 :: SBool = s325 ^ s1772+  s1774 :: SBool = if s1620 then s1773 else s1772+  s1775 :: SBool = s309 ^ s1774+  s1776 :: SBool = if s1634 then s1775 else s1774+  s1777 :: SBool = s295 ^ s1776+  s1778 :: SBool = if s1650 then s1777 else s1776+  s1779 :: SBool = s283 ^ s1778+  s1780 :: SBool = if s1668 then s1779 else s1778+  s1781 :: SBool = s273 ^ s1780+  s1782 :: SBool = if s1688 then s1781 else s1780+  s1783 :: SBool = s265 ^ s1782+  s1784 :: SBool = if s1710 then s1783 else s1782+  s1785 :: SBool = s259 ^ s1784+  s1786 :: SBool = if s1734 then s1785 else s1784+  s1787 :: SBool = s255 ^ s1786+  s1788 :: SBool = if s1760 then s1787 else s1786+  s1789 :: SBool = s92 ^ s493+  s1790 :: SBool = if s16 then s1789 else s92+  s1791 :: SBool = s463 ^ s1790+  s1792 :: SBool = if s1580 then s1791 else s1790+  s1793 :: SBool = s435 ^ s1792+  s1794 :: SBool = if s1584 then s1793 else s1792+  s1795 :: SBool = s409 ^ s1794+  s1796 :: SBool = if s1590 then s1795 else s1794+  s1797 :: SBool = s385 ^ s1796+  s1798 :: SBool = if s1598 then s1797 else s1796+  s1799 :: SBool = s363 ^ s1798+  s1800 :: SBool = if s1608 then s1799 else s1798+  s1801 :: SBool = s343 ^ s1800+  s1802 :: SBool = if s1620 then s1801 else s1800+  s1803 :: SBool = s325 ^ s1802+  s1804 :: SBool = if s1634 then s1803 else s1802+  s1805 :: SBool = s309 ^ s1804+  s1806 :: SBool = if s1650 then s1805 else s1804+  s1807 :: SBool = s295 ^ s1806+  s1808 :: SBool = if s1668 then s1807 else s1806+  s1809 :: SBool = s283 ^ s1808+  s1810 :: SBool = if s1688 then s1809 else s1808+  s1811 :: SBool = s273 ^ s1810+  s1812 :: SBool = if s1710 then s1811 else s1810+  s1813 :: SBool = s265 ^ s1812+  s1814 :: SBool = if s1734 then s1813 else s1812+  s1815 :: SBool = s259 ^ s1814+  s1816 :: SBool = if s1760 then s1815 else s1814+  s1817 :: SBool = s255 ^ s1816+  s1818 :: SBool = if s1788 then s1817 else s1816+  s1819 :: SBool = s7 ^ s97+  s1820 :: SBool = if s16 then s1819 else s97+  s1821 :: SBool = s493 ^ s1820+  s1822 :: SBool = if s1580 then s1821 else s1820+  s1823 :: SBool = s463 ^ s1822+  s1824 :: SBool = if s1584 then s1823 else s1822+  s1825 :: SBool = s435 ^ s1824+  s1826 :: SBool = if s1590 then s1825 else s1824+  s1827 :: SBool = s409 ^ s1826+  s1828 :: SBool = if s1598 then s1827 else s1826+  s1829 :: SBool = s385 ^ s1828+  s1830 :: SBool = if s1608 then s1829 else s1828+  s1831 :: SBool = s363 ^ s1830+  s1832 :: SBool = if s1620 then s1831 else s1830+  s1833 :: SBool = s343 ^ s1832+  s1834 :: SBool = if s1634 then s1833 else s1832+  s1835 :: SBool = s325 ^ s1834+  s1836 :: SBool = if s1650 then s1835 else s1834+  s1837 :: SBool = s309 ^ s1836+  s1838 :: SBool = if s1668 then s1837 else s1836+  s1839 :: SBool = s295 ^ s1838+  s1840 :: SBool = if s1688 then s1839 else s1838+  s1841 :: SBool = s283 ^ s1840+  s1842 :: SBool = if s1710 then s1841 else s1840+  s1843 :: SBool = s273 ^ s1842+  s1844 :: SBool = if s1734 then s1843 else s1842+  s1845 :: SBool = s265 ^ s1844+  s1846 :: SBool = if s1760 then s1845 else s1844+  s1847 :: SBool = s259 ^ s1846+  s1848 :: SBool = if s1788 then s1847 else s1846+  s1849 :: SBool = s255 ^ s1848+  s1850 :: SBool = if s1818 then s1849 else s1848+  s1851 :: SBool = s7 ^ s102+  s1852 :: SBool = if s1580 then s1851 else s102+  s1853 :: SBool = s493 ^ s1852+  s1854 :: SBool = if s1584 then s1853 else s1852+  s1855 :: SBool = s463 ^ s1854+  s1856 :: SBool = if s1590 then s1855 else s1854+  s1857 :: SBool = s435 ^ s1856+  s1858 :: SBool = if s1598 then s1857 else s1856+  s1859 :: SBool = s409 ^ s1858+  s1860 :: SBool = if s1608 then s1859 else s1858+  s1861 :: SBool = s385 ^ s1860+  s1862 :: SBool = if s1620 then s1861 else s1860+  s1863 :: SBool = s363 ^ s1862+  s1864 :: SBool = if s1634 then s1863 else s1862+  s1865 :: SBool = s343 ^ s1864+  s1866 :: SBool = if s1650 then s1865 else s1864+  s1867 :: SBool = s325 ^ s1866+  s1868 :: SBool = if s1668 then s1867 else s1866+  s1869 :: SBool = s309 ^ s1868+  s1870 :: SBool = if s1688 then s1869 else s1868+  s1871 :: SBool = s295 ^ s1870+  s1872 :: SBool = if s1710 then s1871 else s1870+  s1873 :: SBool = s283 ^ s1872+  s1874 :: SBool = if s1734 then s1873 else s1872+  s1875 :: SBool = s273 ^ s1874+  s1876 :: SBool = if s1760 then s1875 else s1874+  s1877 :: SBool = s265 ^ s1876+  s1878 :: SBool = if s1788 then s1877 else s1876+  s1879 :: SBool = s259 ^ s1878+  s1880 :: SBool = if s1818 then s1879 else s1878+  s1881 :: SBool = s255 ^ s1880+  s1882 :: SBool = if s1850 then s1881 else s1880+  s1883 :: SBool = s7 ^ s107+  s1884 :: SBool = if s1584 then s1883 else s107+  s1885 :: SBool = s493 ^ s1884+  s1886 :: SBool = if s1590 then s1885 else s1884+  s1887 :: SBool = s463 ^ s1886+  s1888 :: SBool = if s1598 then s1887 else s1886+  s1889 :: SBool = s435 ^ s1888+  s1890 :: SBool = if s1608 then s1889 else s1888+  s1891 :: SBool = s409 ^ s1890+  s1892 :: SBool = if s1620 then s1891 else s1890+  s1893 :: SBool = s385 ^ s1892+  s1894 :: SBool = if s1634 then s1893 else s1892+  s1895 :: SBool = s363 ^ s1894+  s1896 :: SBool = if s1650 then s1895 else s1894+  s1897 :: SBool = s343 ^ s1896+  s1898 :: SBool = if s1668 then s1897 else s1896+  s1899 :: SBool = s325 ^ s1898+  s1900 :: SBool = if s1688 then s1899 else s1898+  s1901 :: SBool = s309 ^ s1900+  s1902 :: SBool = if s1710 then s1901 else s1900+  s1903 :: SBool = s295 ^ s1902+  s1904 :: SBool = if s1734 then s1903 else s1902+  s1905 :: SBool = s283 ^ s1904+  s1906 :: SBool = if s1760 then s1905 else s1904+  s1907 :: SBool = s273 ^ s1906+  s1908 :: SBool = if s1788 then s1907 else s1906+  s1909 :: SBool = s265 ^ s1908+  s1910 :: SBool = if s1818 then s1909 else s1908+  s1911 :: SBool = s259 ^ s1910+  s1912 :: SBool = if s1850 then s1911 else s1910+  s1913 :: SBool = s255 ^ s1912+  s1914 :: SBool = if s1882 then s1913 else s1912+  s1915 :: SBool = s7 ^ s112+  s1916 :: SBool = if s1590 then s1915 else s112+  s1917 :: SBool = s493 ^ s1916+  s1918 :: SBool = if s1598 then s1917 else s1916+  s1919 :: SBool = s463 ^ s1918+  s1920 :: SBool = if s1608 then s1919 else s1918+  s1921 :: SBool = s435 ^ s1920+  s1922 :: SBool = if s1620 then s1921 else s1920+  s1923 :: SBool = s409 ^ s1922+  s1924 :: SBool = if s1634 then s1923 else s1922+  s1925 :: SBool = s385 ^ s1924+  s1926 :: SBool = if s1650 then s1925 else s1924+  s1927 :: SBool = s363 ^ s1926+  s1928 :: SBool = if s1668 then s1927 else s1926+  s1929 :: SBool = s343 ^ s1928+  s1930 :: SBool = if s1688 then s1929 else s1928+  s1931 :: SBool = s325 ^ s1930+  s1932 :: SBool = if s1710 then s1931 else s1930+  s1933 :: SBool = s309 ^ s1932+  s1934 :: SBool = if s1734 then s1933 else s1932+  s1935 :: SBool = s295 ^ s1934+  s1936 :: SBool = if s1760 then s1935 else s1934+  s1937 :: SBool = s283 ^ s1936+  s1938 :: SBool = if s1788 then s1937 else s1936+  s1939 :: SBool = s273 ^ s1938+  s1940 :: SBool = if s1818 then s1939 else s1938+  s1941 :: SBool = s265 ^ s1940+  s1942 :: SBool = if s1850 then s1941 else s1940+  s1943 :: SBool = s259 ^ s1942+  s1944 :: SBool = if s1882 then s1943 else s1942+  s1945 :: SBool = s255 ^ s1944+  s1946 :: SBool = if s1914 then s1945 else s1944+  s1947 :: SBool = s7 ^ s117+  s1948 :: SBool = if s1598 then s1947 else s117+  s1949 :: SBool = s493 ^ s1948+  s1950 :: SBool = if s1608 then s1949 else s1948+  s1951 :: SBool = s463 ^ s1950+  s1952 :: SBool = if s1620 then s1951 else s1950+  s1953 :: SBool = s435 ^ s1952+  s1954 :: SBool = if s1634 then s1953 else s1952+  s1955 :: SBool = s409 ^ s1954+  s1956 :: SBool = if s1650 then s1955 else s1954+  s1957 :: SBool = s385 ^ s1956+  s1958 :: SBool = if s1668 then s1957 else s1956+  s1959 :: SBool = s363 ^ s1958+  s1960 :: SBool = if s1688 then s1959 else s1958+  s1961 :: SBool = s343 ^ s1960+  s1962 :: SBool = if s1710 then s1961 else s1960+  s1963 :: SBool = s325 ^ s1962+  s1964 :: SBool = if s1734 then s1963 else s1962+  s1965 :: SBool = s309 ^ s1964+  s1966 :: SBool = if s1760 then s1965 else s1964+  s1967 :: SBool = s295 ^ s1966+  s1968 :: SBool = if s1788 then s1967 else s1966+  s1969 :: SBool = s283 ^ s1968+  s1970 :: SBool = if s1818 then s1969 else s1968+  s1971 :: SBool = s273 ^ s1970+  s1972 :: SBool = if s1850 then s1971 else s1970+  s1973 :: SBool = s265 ^ s1972+  s1974 :: SBool = if s1882 then s1973 else s1972+  s1975 :: SBool = s259 ^ s1974+  s1976 :: SBool = if s1914 then s1975 else s1974+  s1977 :: SBool = s255 ^ s1976+  s1978 :: SBool = if s1946 then s1977 else s1976+  s1979 :: SBool = s7 ^ s122+  s1980 :: SBool = if s1608 then s1979 else s122+  s1981 :: SBool = s493 ^ s1980+  s1982 :: SBool = if s1620 then s1981 else s1980+  s1983 :: SBool = s463 ^ s1982+  s1984 :: SBool = if s1634 then s1983 else s1982+  s1985 :: SBool = s435 ^ s1984+  s1986 :: SBool = if s1650 then s1985 else s1984+  s1987 :: SBool = s409 ^ s1986+  s1988 :: SBool = if s1668 then s1987 else s1986+  s1989 :: SBool = s385 ^ s1988+  s1990 :: SBool = if s1688 then s1989 else s1988+  s1991 :: SBool = s363 ^ s1990+  s1992 :: SBool = if s1710 then s1991 else s1990+  s1993 :: SBool = s343 ^ s1992+  s1994 :: SBool = if s1734 then s1993 else s1992+  s1995 :: SBool = s325 ^ s1994+  s1996 :: SBool = if s1760 then s1995 else s1994+  s1997 :: SBool = s309 ^ s1996+  s1998 :: SBool = if s1788 then s1997 else s1996+  s1999 :: SBool = s295 ^ s1998+  s2000 :: SBool = if s1818 then s1999 else s1998+  s2001 :: SBool = s283 ^ s2000+  s2002 :: SBool = if s1850 then s2001 else s2000+  s2003 :: SBool = s273 ^ s2002+  s2004 :: SBool = if s1882 then s2003 else s2002+  s2005 :: SBool = s265 ^ s2004+  s2006 :: SBool = if s1914 then s2005 else s2004+  s2007 :: SBool = s259 ^ s2006+  s2008 :: SBool = if s1946 then s2007 else s2006+  s2009 :: SBool = s255 ^ s2008+  s2010 :: SBool = if s1978 then s2009 else s2008+  s2011 :: SBool = s7 ^ s127+  s2012 :: SBool = if s1620 then s2011 else s127+  s2013 :: SBool = s493 ^ s2012+  s2014 :: SBool = if s1634 then s2013 else s2012+  s2015 :: SBool = s463 ^ s2014+  s2016 :: SBool = if s1650 then s2015 else s2014+  s2017 :: SBool = s435 ^ s2016+  s2018 :: SBool = if s1668 then s2017 else s2016+  s2019 :: SBool = s409 ^ s2018+  s2020 :: SBool = if s1688 then s2019 else s2018+  s2021 :: SBool = s385 ^ s2020+  s2022 :: SBool = if s1710 then s2021 else s2020+  s2023 :: SBool = s363 ^ s2022+  s2024 :: SBool = if s1734 then s2023 else s2022+  s2025 :: SBool = s343 ^ s2024+  s2026 :: SBool = if s1760 then s2025 else s2024+  s2027 :: SBool = s325 ^ s2026+  s2028 :: SBool = if s1788 then s2027 else s2026+  s2029 :: SBool = s309 ^ s2028+  s2030 :: SBool = if s1818 then s2029 else s2028+  s2031 :: SBool = s295 ^ s2030+  s2032 :: SBool = if s1850 then s2031 else s2030+  s2033 :: SBool = s283 ^ s2032+  s2034 :: SBool = if s1882 then s2033 else s2032+  s2035 :: SBool = s273 ^ s2034+  s2036 :: SBool = if s1914 then s2035 else s2034+  s2037 :: SBool = s265 ^ s2036+  s2038 :: SBool = if s1946 then s2037 else s2036+  s2039 :: SBool = s259 ^ s2038+  s2040 :: SBool = if s1978 then s2039 else s2038+  s2041 :: SBool = s255 ^ s2040+  s2042 :: SBool = if s2010 then s2041 else s2040+  s2043 :: SBool = s7 ^ s132+  s2044 :: SBool = if s1634 then s2043 else s132+  s2045 :: SBool = s493 ^ s2044+  s2046 :: SBool = if s1650 then s2045 else s2044+  s2047 :: SBool = s463 ^ s2046+  s2048 :: SBool = if s1668 then s2047 else s2046+  s2049 :: SBool = s435 ^ s2048+  s2050 :: SBool = if s1688 then s2049 else s2048+  s2051 :: SBool = s409 ^ s2050+  s2052 :: SBool = if s1710 then s2051 else s2050+  s2053 :: SBool = s385 ^ s2052+  s2054 :: SBool = if s1734 then s2053 else s2052+  s2055 :: SBool = s363 ^ s2054+  s2056 :: SBool = if s1760 then s2055 else s2054+  s2057 :: SBool = s343 ^ s2056+  s2058 :: SBool = if s1788 then s2057 else s2056+  s2059 :: SBool = s325 ^ s2058+  s2060 :: SBool = if s1818 then s2059 else s2058+  s2061 :: SBool = s309 ^ s2060+  s2062 :: SBool = if s1850 then s2061 else s2060+  s2063 :: SBool = s295 ^ s2062+  s2064 :: SBool = if s1882 then s2063 else s2062+  s2065 :: SBool = s283 ^ s2064+  s2066 :: SBool = if s1914 then s2065 else s2064+  s2067 :: SBool = s273 ^ s2066+  s2068 :: SBool = if s1946 then s2067 else s2066+  s2069 :: SBool = s265 ^ s2068+  s2070 :: SBool = if s1978 then s2069 else s2068+  s2071 :: SBool = s259 ^ s2070+  s2072 :: SBool = if s2010 then s2071 else s2070+  s2073 :: SBool = s255 ^ s2072+  s2074 :: SBool = if s2042 then s2073 else s2072+  s2075 :: SBool = s7 ^ s137+  s2076 :: SBool = if s1650 then s2075 else s137+  s2077 :: SBool = s493 ^ s2076+  s2078 :: SBool = if s1668 then s2077 else s2076+  s2079 :: SBool = s463 ^ s2078+  s2080 :: SBool = if s1688 then s2079 else s2078+  s2081 :: SBool = s435 ^ s2080+  s2082 :: SBool = if s1710 then s2081 else s2080+  s2083 :: SBool = s409 ^ s2082+  s2084 :: SBool = if s1734 then s2083 else s2082+  s2085 :: SBool = s385 ^ s2084+  s2086 :: SBool = if s1760 then s2085 else s2084+  s2087 :: SBool = s363 ^ s2086+  s2088 :: SBool = if s1788 then s2087 else s2086+  s2089 :: SBool = s343 ^ s2088+  s2090 :: SBool = if s1818 then s2089 else s2088+  s2091 :: SBool = s325 ^ s2090+  s2092 :: SBool = if s1850 then s2091 else s2090+  s2093 :: SBool = s309 ^ s2092+  s2094 :: SBool = if s1882 then s2093 else s2092+  s2095 :: SBool = s295 ^ s2094+  s2096 :: SBool = if s1914 then s2095 else s2094+  s2097 :: SBool = s283 ^ s2096+  s2098 :: SBool = if s1946 then s2097 else s2096+  s2099 :: SBool = s273 ^ s2098+  s2100 :: SBool = if s1978 then s2099 else s2098+  s2101 :: SBool = s265 ^ s2100+  s2102 :: SBool = if s2010 then s2101 else s2100+  s2103 :: SBool = s259 ^ s2102+  s2104 :: SBool = if s2042 then s2103 else s2102+  s2105 :: SBool = s255 ^ s2104+  s2106 :: SBool = if s2074 then s2105 else s2104+  s2107 :: SBool = s7 ^ s142+  s2108 :: SBool = if s1668 then s2107 else s142+  s2109 :: SBool = s493 ^ s2108+  s2110 :: SBool = if s1688 then s2109 else s2108+  s2111 :: SBool = s463 ^ s2110+  s2112 :: SBool = if s1710 then s2111 else s2110+  s2113 :: SBool = s435 ^ s2112+  s2114 :: SBool = if s1734 then s2113 else s2112+  s2115 :: SBool = s409 ^ s2114+  s2116 :: SBool = if s1760 then s2115 else s2114+  s2117 :: SBool = s385 ^ s2116+  s2118 :: SBool = if s1788 then s2117 else s2116+  s2119 :: SBool = s363 ^ s2118+  s2120 :: SBool = if s1818 then s2119 else s2118+  s2121 :: SBool = s343 ^ s2120+  s2122 :: SBool = if s1850 then s2121 else s2120+  s2123 :: SBool = s325 ^ s2122+  s2124 :: SBool = if s1882 then s2123 else s2122+  s2125 :: SBool = s309 ^ s2124+  s2126 :: SBool = if s1914 then s2125 else s2124+  s2127 :: SBool = s295 ^ s2126+  s2128 :: SBool = if s1946 then s2127 else s2126+  s2129 :: SBool = s283 ^ s2128+  s2130 :: SBool = if s1978 then s2129 else s2128+  s2131 :: SBool = s273 ^ s2130+  s2132 :: SBool = if s2010 then s2131 else s2130+  s2133 :: SBool = s265 ^ s2132+  s2134 :: SBool = if s2042 then s2133 else s2132+  s2135 :: SBool = s259 ^ s2134+  s2136 :: SBool = if s2074 then s2135 else s2134+  s2137 :: SBool = s255 ^ s2136+  s2138 :: SBool = if s2106 then s2137 else s2136+  s2139 :: SBool = s7 ^ s147+  s2140 :: SBool = if s1688 then s2139 else s147+  s2141 :: SBool = s493 ^ s2140+  s2142 :: SBool = if s1710 then s2141 else s2140+  s2143 :: SBool = s463 ^ s2142+  s2144 :: SBool = if s1734 then s2143 else s2142+  s2145 :: SBool = s435 ^ s2144+  s2146 :: SBool = if s1760 then s2145 else s2144+  s2147 :: SBool = s409 ^ s2146+  s2148 :: SBool = if s1788 then s2147 else s2146+  s2149 :: SBool = s385 ^ s2148+  s2150 :: SBool = if s1818 then s2149 else s2148+  s2151 :: SBool = s363 ^ s2150+  s2152 :: SBool = if s1850 then s2151 else s2150+  s2153 :: SBool = s343 ^ s2152+  s2154 :: SBool = if s1882 then s2153 else s2152+  s2155 :: SBool = s325 ^ s2154+  s2156 :: SBool = if s1914 then s2155 else s2154+  s2157 :: SBool = s309 ^ s2156+  s2158 :: SBool = if s1946 then s2157 else s2156+  s2159 :: SBool = s295 ^ s2158+  s2160 :: SBool = if s1978 then s2159 else s2158+  s2161 :: SBool = s283 ^ s2160+  s2162 :: SBool = if s2010 then s2161 else s2160+  s2163 :: SBool = s273 ^ s2162+  s2164 :: SBool = if s2042 then s2163 else s2162+  s2165 :: SBool = s265 ^ s2164+  s2166 :: SBool = if s2074 then s2165 else s2164+  s2167 :: SBool = s259 ^ s2166+  s2168 :: SBool = if s2106 then s2167 else s2166+  s2169 :: SBool = s255 ^ s2168+  s2170 :: SBool = if s2138 then s2169 else s2168+  s2171 :: SBool = s7 ^ s152+  s2172 :: SBool = if s1710 then s2171 else s152+  s2173 :: SBool = s493 ^ s2172+  s2174 :: SBool = if s1734 then s2173 else s2172+  s2175 :: SBool = s463 ^ s2174+  s2176 :: SBool = if s1760 then s2175 else s2174+  s2177 :: SBool = s435 ^ s2176+  s2178 :: SBool = if s1788 then s2177 else s2176+  s2179 :: SBool = s409 ^ s2178+  s2180 :: SBool = if s1818 then s2179 else s2178+  s2181 :: SBool = s385 ^ s2180+  s2182 :: SBool = if s1850 then s2181 else s2180+  s2183 :: SBool = s363 ^ s2182+  s2184 :: SBool = if s1882 then s2183 else s2182+  s2185 :: SBool = s343 ^ s2184+  s2186 :: SBool = if s1914 then s2185 else s2184+  s2187 :: SBool = s325 ^ s2186+  s2188 :: SBool = if s1946 then s2187 else s2186+  s2189 :: SBool = s309 ^ s2188+  s2190 :: SBool = if s1978 then s2189 else s2188+  s2191 :: SBool = s295 ^ s2190+  s2192 :: SBool = if s2010 then s2191 else s2190+  s2193 :: SBool = s283 ^ s2192+  s2194 :: SBool = if s2042 then s2193 else s2192+  s2195 :: SBool = s273 ^ s2194+  s2196 :: SBool = if s2074 then s2195 else s2194+  s2197 :: SBool = s265 ^ s2196+  s2198 :: SBool = if s2106 then s2197 else s2196+  s2199 :: SBool = s259 ^ s2198+  s2200 :: SBool = if s2138 then s2199 else s2198+  s2201 :: SBool = s255 ^ s2200+  s2202 :: SBool = if s2170 then s2201 else s2200+  s2203 :: SBool = s7 ^ s157+  s2204 :: SBool = if s1734 then s2203 else s157+  s2205 :: SBool = s493 ^ s2204+  s2206 :: SBool = if s1760 then s2205 else s2204+  s2207 :: SBool = s463 ^ s2206+  s2208 :: SBool = if s1788 then s2207 else s2206+  s2209 :: SBool = s435 ^ s2208+  s2210 :: SBool = if s1818 then s2209 else s2208+  s2211 :: SBool = s409 ^ s2210+  s2212 :: SBool = if s1850 then s2211 else s2210+  s2213 :: SBool = s385 ^ s2212+  s2214 :: SBool = if s1882 then s2213 else s2212+  s2215 :: SBool = s363 ^ s2214+  s2216 :: SBool = if s1914 then s2215 else s2214+  s2217 :: SBool = s343 ^ s2216+  s2218 :: SBool = if s1946 then s2217 else s2216+  s2219 :: SBool = s325 ^ s2218+  s2220 :: SBool = if s1978 then s2219 else s2218+  s2221 :: SBool = s309 ^ s2220+  s2222 :: SBool = if s2010 then s2221 else s2220+  s2223 :: SBool = s295 ^ s2222+  s2224 :: SBool = if s2042 then s2223 else s2222+  s2225 :: SBool = s283 ^ s2224+  s2226 :: SBool = if s2074 then s2225 else s2224+  s2227 :: SBool = s273 ^ s2226+  s2228 :: SBool = if s2106 then s2227 else s2226+  s2229 :: SBool = s265 ^ s2228+  s2230 :: SBool = if s2138 then s2229 else s2228+  s2231 :: SBool = s259 ^ s2230+  s2232 :: SBool = if s2170 then s2231 else s2230+  s2233 :: SBool = s255 ^ s2232+  s2234 :: SBool = if s2202 then s2233 else s2232+  s2235 :: SBool = s7 ^ s162+  s2236 :: SBool = if s1760 then s2235 else s162+  s2237 :: SBool = s493 ^ s2236+  s2238 :: SBool = if s1788 then s2237 else s2236+  s2239 :: SBool = s463 ^ s2238+  s2240 :: SBool = if s1818 then s2239 else s2238+  s2241 :: SBool = s435 ^ s2240+  s2242 :: SBool = if s1850 then s2241 else s2240+  s2243 :: SBool = s409 ^ s2242+  s2244 :: SBool = if s1882 then s2243 else s2242+  s2245 :: SBool = s385 ^ s2244+  s2246 :: SBool = if s1914 then s2245 else s2244+  s2247 :: SBool = s363 ^ s2246+  s2248 :: SBool = if s1946 then s2247 else s2246+  s2249 :: SBool = s343 ^ s2248+  s2250 :: SBool = if s1978 then s2249 else s2248+  s2251 :: SBool = s325 ^ s2250+  s2252 :: SBool = if s2010 then s2251 else s2250+  s2253 :: SBool = s309 ^ s2252+  s2254 :: SBool = if s2042 then s2253 else s2252+  s2255 :: SBool = s295 ^ s2254+  s2256 :: SBool = if s2074 then s2255 else s2254+  s2257 :: SBool = s283 ^ s2256+  s2258 :: SBool = if s2106 then s2257 else s2256+  s2259 :: SBool = s273 ^ s2258+  s2260 :: SBool = if s2138 then s2259 else s2258+  s2261 :: SBool = s265 ^ s2260+  s2262 :: SBool = if s2170 then s2261 else s2260+  s2263 :: SBool = s259 ^ s2262+  s2264 :: SBool = if s2202 then s2263 else s2262+  s2265 :: SBool = s255 ^ s2264+  s2266 :: SBool = if s2234 then s2265 else s2264+  s2267 :: SBool = s7 ^ s167+  s2268 :: SBool = if s1788 then s2267 else s167+  s2269 :: SBool = s493 ^ s2268+  s2270 :: SBool = if s1818 then s2269 else s2268+  s2271 :: SBool = s463 ^ s2270+  s2272 :: SBool = if s1850 then s2271 else s2270+  s2273 :: SBool = s435 ^ s2272+  s2274 :: SBool = if s1882 then s2273 else s2272+  s2275 :: SBool = s409 ^ s2274+  s2276 :: SBool = if s1914 then s2275 else s2274+  s2277 :: SBool = s385 ^ s2276+  s2278 :: SBool = if s1946 then s2277 else s2276+  s2279 :: SBool = s363 ^ s2278+  s2280 :: SBool = if s1978 then s2279 else s2278+  s2281 :: SBool = s343 ^ s2280+  s2282 :: SBool = if s2010 then s2281 else s2280+  s2283 :: SBool = s325 ^ s2282+  s2284 :: SBool = if s2042 then s2283 else s2282+  s2285 :: SBool = s309 ^ s2284+  s2286 :: SBool = if s2074 then s2285 else s2284+  s2287 :: SBool = s295 ^ s2286+  s2288 :: SBool = if s2106 then s2287 else s2286+  s2289 :: SBool = s283 ^ s2288+  s2290 :: SBool = if s2138 then s2289 else s2288+  s2291 :: SBool = s273 ^ s2290+  s2292 :: SBool = if s2170 then s2291 else s2290+  s2293 :: SBool = s265 ^ s2292+  s2294 :: SBool = if s2202 then s2293 else s2292+  s2295 :: SBool = s259 ^ s2294+  s2296 :: SBool = if s2234 then s2295 else s2294+  s2297 :: SBool = s255 ^ s2296+  s2298 :: SBool = if s2266 then s2297 else s2296+  s2299 :: SBool = s7 ^ s172+  s2300 :: SBool = if s1818 then s2299 else s172+  s2301 :: SBool = s493 ^ s2300+  s2302 :: SBool = if s1850 then s2301 else s2300+  s2303 :: SBool = s463 ^ s2302+  s2304 :: SBool = if s1882 then s2303 else s2302+  s2305 :: SBool = s435 ^ s2304+  s2306 :: SBool = if s1914 then s2305 else s2304+  s2307 :: SBool = s409 ^ s2306+  s2308 :: SBool = if s1946 then s2307 else s2306+  s2309 :: SBool = s385 ^ s2308+  s2310 :: SBool = if s1978 then s2309 else s2308+  s2311 :: SBool = s363 ^ s2310+  s2312 :: SBool = if s2010 then s2311 else s2310+  s2313 :: SBool = s343 ^ s2312+  s2314 :: SBool = if s2042 then s2313 else s2312+  s2315 :: SBool = s325 ^ s2314+  s2316 :: SBool = if s2074 then s2315 else s2314+  s2317 :: SBool = s309 ^ s2316+  s2318 :: SBool = if s2106 then s2317 else s2316+  s2319 :: SBool = s295 ^ s2318+  s2320 :: SBool = if s2138 then s2319 else s2318+  s2321 :: SBool = s283 ^ s2320+  s2322 :: SBool = if s2170 then s2321 else s2320+  s2323 :: SBool = s273 ^ s2322+  s2324 :: SBool = if s2202 then s2323 else s2322+  s2325 :: SBool = s265 ^ s2324+  s2326 :: SBool = if s2234 then s2325 else s2324+  s2327 :: SBool = s259 ^ s2326+  s2328 :: SBool = if s2266 then s2327 else s2326+  s2329 :: SBool = s255 ^ s2328+  s2330 :: SBool = if s2298 then s2329 else s2328+  s2331 :: SBool = s7 ^ s177+  s2332 :: SBool = if s1850 then s2331 else s177+  s2333 :: SBool = s493 ^ s2332+  s2334 :: SBool = if s1882 then s2333 else s2332+  s2335 :: SBool = s463 ^ s2334+  s2336 :: SBool = if s1914 then s2335 else s2334+  s2337 :: SBool = s435 ^ s2336+  s2338 :: SBool = if s1946 then s2337 else s2336+  s2339 :: SBool = s409 ^ s2338+  s2340 :: SBool = if s1978 then s2339 else s2338+  s2341 :: SBool = s385 ^ s2340+  s2342 :: SBool = if s2010 then s2341 else s2340+  s2343 :: SBool = s363 ^ s2342+  s2344 :: SBool = if s2042 then s2343 else s2342+  s2345 :: SBool = s343 ^ s2344+  s2346 :: SBool = if s2074 then s2345 else s2344+  s2347 :: SBool = s325 ^ s2346+  s2348 :: SBool = if s2106 then s2347 else s2346+  s2349 :: SBool = s309 ^ s2348+  s2350 :: SBool = if s2138 then s2349 else s2348+  s2351 :: SBool = s295 ^ s2350+  s2352 :: SBool = if s2170 then s2351 else s2350+  s2353 :: SBool = s283 ^ s2352+  s2354 :: SBool = if s2202 then s2353 else s2352+  s2355 :: SBool = s273 ^ s2354+  s2356 :: SBool = if s2234 then s2355 else s2354+  s2357 :: SBool = s265 ^ s2356+  s2358 :: SBool = if s2266 then s2357 else s2356+  s2359 :: SBool = s259 ^ s2358+  s2360 :: SBool = if s2298 then s2359 else s2358+  s2361 :: SBool = s255 ^ s2360+  s2362 :: SBool = if s2330 then s2361 else s2360+  s2363 :: SBool = s7 ^ s182+  s2364 :: SBool = if s1882 then s2363 else s182+  s2365 :: SBool = s493 ^ s2364+  s2366 :: SBool = if s1914 then s2365 else s2364+  s2367 :: SBool = s463 ^ s2366+  s2368 :: SBool = if s1946 then s2367 else s2366+  s2369 :: SBool = s435 ^ s2368+  s2370 :: SBool = if s1978 then s2369 else s2368+  s2371 :: SBool = s409 ^ s2370+  s2372 :: SBool = if s2010 then s2371 else s2370+  s2373 :: SBool = s385 ^ s2372+  s2374 :: SBool = if s2042 then s2373 else s2372+  s2375 :: SBool = s363 ^ s2374+  s2376 :: SBool = if s2074 then s2375 else s2374+  s2377 :: SBool = s343 ^ s2376+  s2378 :: SBool = if s2106 then s2377 else s2376+  s2379 :: SBool = s325 ^ s2378+  s2380 :: SBool = if s2138 then s2379 else s2378+  s2381 :: SBool = s309 ^ s2380+  s2382 :: SBool = if s2170 then s2381 else s2380+  s2383 :: SBool = s295 ^ s2382+  s2384 :: SBool = if s2202 then s2383 else s2382+  s2385 :: SBool = s283 ^ s2384+  s2386 :: SBool = if s2234 then s2385 else s2384+  s2387 :: SBool = s273 ^ s2386+  s2388 :: SBool = if s2266 then s2387 else s2386+  s2389 :: SBool = s265 ^ s2388+  s2390 :: SBool = if s2298 then s2389 else s2388+  s2391 :: SBool = s259 ^ s2390+  s2392 :: SBool = if s2330 then s2391 else s2390+  s2393 :: SBool = s255 ^ s2392+  s2394 :: SBool = if s2362 then s2393 else s2392+  s2395 :: SBool = s7 ^ s187+  s2396 :: SBool = if s1914 then s2395 else s187+  s2397 :: SBool = s493 ^ s2396+  s2398 :: SBool = if s1946 then s2397 else s2396+  s2399 :: SBool = s463 ^ s2398+  s2400 :: SBool = if s1978 then s2399 else s2398+  s2401 :: SBool = s435 ^ s2400+  s2402 :: SBool = if s2010 then s2401 else s2400+  s2403 :: SBool = s409 ^ s2402+  s2404 :: SBool = if s2042 then s2403 else s2402+  s2405 :: SBool = s385 ^ s2404+  s2406 :: SBool = if s2074 then s2405 else s2404+  s2407 :: SBool = s363 ^ s2406+  s2408 :: SBool = if s2106 then s2407 else s2406+  s2409 :: SBool = s343 ^ s2408+  s2410 :: SBool = if s2138 then s2409 else s2408+  s2411 :: SBool = s325 ^ s2410+  s2412 :: SBool = if s2170 then s2411 else s2410+  s2413 :: SBool = s309 ^ s2412+  s2414 :: SBool = if s2202 then s2413 else s2412+  s2415 :: SBool = s295 ^ s2414+  s2416 :: SBool = if s2234 then s2415 else s2414+  s2417 :: SBool = s283 ^ s2416+  s2418 :: SBool = if s2266 then s2417 else s2416+  s2419 :: SBool = s273 ^ s2418+  s2420 :: SBool = if s2298 then s2419 else s2418+  s2421 :: SBool = s265 ^ s2420+  s2422 :: SBool = if s2330 then s2421 else s2420+  s2423 :: SBool = s259 ^ s2422+  s2424 :: SBool = if s2362 then s2423 else s2422+  s2425 :: SBool = s255 ^ s2424+  s2426 :: SBool = if s2394 then s2425 else s2424+  s2427 :: SBool = s7 ^ s192+  s2428 :: SBool = if s1946 then s2427 else s192+  s2429 :: SBool = s493 ^ s2428+  s2430 :: SBool = if s1978 then s2429 else s2428+  s2431 :: SBool = s463 ^ s2430+  s2432 :: SBool = if s2010 then s2431 else s2430+  s2433 :: SBool = s435 ^ s2432+  s2434 :: SBool = if s2042 then s2433 else s2432+  s2435 :: SBool = s409 ^ s2434+  s2436 :: SBool = if s2074 then s2435 else s2434+  s2437 :: SBool = s385 ^ s2436+  s2438 :: SBool = if s2106 then s2437 else s2436+  s2439 :: SBool = s363 ^ s2438+  s2440 :: SBool = if s2138 then s2439 else s2438+  s2441 :: SBool = s343 ^ s2440+  s2442 :: SBool = if s2170 then s2441 else s2440+  s2443 :: SBool = s325 ^ s2442+  s2444 :: SBool = if s2202 then s2443 else s2442+  s2445 :: SBool = s309 ^ s2444+  s2446 :: SBool = if s2234 then s2445 else s2444+  s2447 :: SBool = s295 ^ s2446+  s2448 :: SBool = if s2266 then s2447 else s2446+  s2449 :: SBool = s283 ^ s2448+  s2450 :: SBool = if s2298 then s2449 else s2448+  s2451 :: SBool = s273 ^ s2450+  s2452 :: SBool = if s2330 then s2451 else s2450+  s2453 :: SBool = s265 ^ s2452+  s2454 :: SBool = if s2362 then s2453 else s2452+  s2455 :: SBool = s259 ^ s2454+  s2456 :: SBool = if s2394 then s2455 else s2454+  s2457 :: SBool = s255 ^ s2456+  s2458 :: SBool = if s2426 then s2457 else s2456+  s2459 :: SBool = s7 ^ s197+  s2460 :: SBool = if s1978 then s2459 else s197+  s2461 :: SBool = s493 ^ s2460+  s2462 :: SBool = if s2010 then s2461 else s2460+  s2463 :: SBool = s463 ^ s2462+  s2464 :: SBool = if s2042 then s2463 else s2462+  s2465 :: SBool = s435 ^ s2464+  s2466 :: SBool = if s2074 then s2465 else s2464+  s2467 :: SBool = s409 ^ s2466+  s2468 :: SBool = if s2106 then s2467 else s2466+  s2469 :: SBool = s385 ^ s2468+  s2470 :: SBool = if s2138 then s2469 else s2468+  s2471 :: SBool = s363 ^ s2470+  s2472 :: SBool = if s2170 then s2471 else s2470+  s2473 :: SBool = s343 ^ s2472+  s2474 :: SBool = if s2202 then s2473 else s2472+  s2475 :: SBool = s325 ^ s2474+  s2476 :: SBool = if s2234 then s2475 else s2474+  s2477 :: SBool = s309 ^ s2476+  s2478 :: SBool = if s2266 then s2477 else s2476+  s2479 :: SBool = s295 ^ s2478+  s2480 :: SBool = if s2298 then s2479 else s2478+  s2481 :: SBool = s283 ^ s2480+  s2482 :: SBool = if s2330 then s2481 else s2480+  s2483 :: SBool = s273 ^ s2482+  s2484 :: SBool = if s2362 then s2483 else s2482+  s2485 :: SBool = s265 ^ s2484+  s2486 :: SBool = if s2394 then s2485 else s2484+  s2487 :: SBool = s259 ^ s2486+  s2488 :: SBool = if s2426 then s2487 else s2486+  s2489 :: SBool = s255 ^ s2488+  s2490 :: SBool = if s2458 then s2489 else s2488+  s2491 :: SBool = s7 ^ s202+  s2492 :: SBool = if s2010 then s2491 else s202+  s2493 :: SBool = s493 ^ s2492+  s2494 :: SBool = if s2042 then s2493 else s2492+  s2495 :: SBool = s463 ^ s2494+  s2496 :: SBool = if s2074 then s2495 else s2494+  s2497 :: SBool = s435 ^ s2496+  s2498 :: SBool = if s2106 then s2497 else s2496+  s2499 :: SBool = s409 ^ s2498+  s2500 :: SBool = if s2138 then s2499 else s2498+  s2501 :: SBool = s385 ^ s2500+  s2502 :: SBool = if s2170 then s2501 else s2500+  s2503 :: SBool = s363 ^ s2502+  s2504 :: SBool = if s2202 then s2503 else s2502+  s2505 :: SBool = s343 ^ s2504+  s2506 :: SBool = if s2234 then s2505 else s2504+  s2507 :: SBool = s325 ^ s2506+  s2508 :: SBool = if s2266 then s2507 else s2506+  s2509 :: SBool = s309 ^ s2508+  s2510 :: SBool = if s2298 then s2509 else s2508+  s2511 :: SBool = s295 ^ s2510+  s2512 :: SBool = if s2330 then s2511 else s2510+  s2513 :: SBool = s283 ^ s2512+  s2514 :: SBool = if s2362 then s2513 else s2512+  s2515 :: SBool = s273 ^ s2514+  s2516 :: SBool = if s2394 then s2515 else s2514+  s2517 :: SBool = s265 ^ s2516+  s2518 :: SBool = if s2426 then s2517 else s2516+  s2519 :: SBool = s259 ^ s2518+  s2520 :: SBool = if s2458 then s2519 else s2518+  s2521 :: SBool = s255 ^ s2520+  s2522 :: SBool = if s2490 then s2521 else s2520+  s2523 :: SBool = s7 ^ s207+  s2524 :: SBool = if s2042 then s2523 else s207+  s2525 :: SBool = s493 ^ s2524+  s2526 :: SBool = if s2074 then s2525 else s2524+  s2527 :: SBool = s463 ^ s2526+  s2528 :: SBool = if s2106 then s2527 else s2526+  s2529 :: SBool = s435 ^ s2528+  s2530 :: SBool = if s2138 then s2529 else s2528+  s2531 :: SBool = s409 ^ s2530+  s2532 :: SBool = if s2170 then s2531 else s2530+  s2533 :: SBool = s385 ^ s2532+  s2534 :: SBool = if s2202 then s2533 else s2532+  s2535 :: SBool = s363 ^ s2534+  s2536 :: SBool = if s2234 then s2535 else s2534+  s2537 :: SBool = s343 ^ s2536+  s2538 :: SBool = if s2266 then s2537 else s2536+  s2539 :: SBool = s325 ^ s2538+  s2540 :: SBool = if s2298 then s2539 else s2538+  s2541 :: SBool = s309 ^ s2540+  s2542 :: SBool = if s2330 then s2541 else s2540+  s2543 :: SBool = s295 ^ s2542+  s2544 :: SBool = if s2362 then s2543 else s2542+  s2545 :: SBool = s283 ^ s2544+  s2546 :: SBool = if s2394 then s2545 else s2544+  s2547 :: SBool = s273 ^ s2546+  s2548 :: SBool = if s2426 then s2547 else s2546+  s2549 :: SBool = s265 ^ s2548+  s2550 :: SBool = if s2458 then s2549 else s2548+  s2551 :: SBool = s259 ^ s2550+  s2552 :: SBool = if s2490 then s2551 else s2550+  s2553 :: SBool = s255 ^ s2552+  s2554 :: SBool = if s2522 then s2553 else s2552+  s2555 :: SBool = s7 ^ s212+  s2556 :: SBool = if s2074 then s2555 else s212+  s2557 :: SBool = s493 ^ s2556+  s2558 :: SBool = if s2106 then s2557 else s2556+  s2559 :: SBool = s463 ^ s2558+  s2560 :: SBool = if s2138 then s2559 else s2558+  s2561 :: SBool = s435 ^ s2560+  s2562 :: SBool = if s2170 then s2561 else s2560+  s2563 :: SBool = s409 ^ s2562+  s2564 :: SBool = if s2202 then s2563 else s2562+  s2565 :: SBool = s385 ^ s2564+  s2566 :: SBool = if s2234 then s2565 else s2564+  s2567 :: SBool = s363 ^ s2566+  s2568 :: SBool = if s2266 then s2567 else s2566+  s2569 :: SBool = s343 ^ s2568+  s2570 :: SBool = if s2298 then s2569 else s2568+  s2571 :: SBool = s325 ^ s2570+  s2572 :: SBool = if s2330 then s2571 else s2570+  s2573 :: SBool = s309 ^ s2572+  s2574 :: SBool = if s2362 then s2573 else s2572+  s2575 :: SBool = s295 ^ s2574+  s2576 :: SBool = if s2394 then s2575 else s2574+  s2577 :: SBool = s283 ^ s2576+  s2578 :: SBool = if s2426 then s2577 else s2576+  s2579 :: SBool = s273 ^ s2578+  s2580 :: SBool = if s2458 then s2579 else s2578+  s2581 :: SBool = s265 ^ s2580+  s2582 :: SBool = if s2490 then s2581 else s2580+  s2583 :: SBool = s259 ^ s2582+  s2584 :: SBool = if s2522 then s2583 else s2582+  s2585 :: SBool = s255 ^ s2584+  s2586 :: SBool = if s2554 then s2585 else s2584+  s2587 :: SBool = s7 ^ s217+  s2588 :: SBool = if s2106 then s2587 else s217+  s2589 :: SBool = s493 ^ s2588+  s2590 :: SBool = if s2138 then s2589 else s2588+  s2591 :: SBool = s463 ^ s2590+  s2592 :: SBool = if s2170 then s2591 else s2590+  s2593 :: SBool = s435 ^ s2592+  s2594 :: SBool = if s2202 then s2593 else s2592+  s2595 :: SBool = s409 ^ s2594+  s2596 :: SBool = if s2234 then s2595 else s2594+  s2597 :: SBool = s385 ^ s2596+  s2598 :: SBool = if s2266 then s2597 else s2596+  s2599 :: SBool = s363 ^ s2598+  s2600 :: SBool = if s2298 then s2599 else s2598+  s2601 :: SBool = s343 ^ s2600+  s2602 :: SBool = if s2330 then s2601 else s2600+  s2603 :: SBool = s325 ^ s2602+  s2604 :: SBool = if s2362 then s2603 else s2602+  s2605 :: SBool = s309 ^ s2604+  s2606 :: SBool = if s2394 then s2605 else s2604+  s2607 :: SBool = s295 ^ s2606+  s2608 :: SBool = if s2426 then s2607 else s2606+  s2609 :: SBool = s283 ^ s2608+  s2610 :: SBool = if s2458 then s2609 else s2608+  s2611 :: SBool = s273 ^ s2610+  s2612 :: SBool = if s2490 then s2611 else s2610+  s2613 :: SBool = s265 ^ s2612+  s2614 :: SBool = if s2522 then s2613 else s2612+  s2615 :: SBool = s259 ^ s2614+  s2616 :: SBool = if s2554 then s2615 else s2614+  s2617 :: SBool = s255 ^ s2616+  s2618 :: SBool = if s2586 then s2617 else s2616+  s2619 :: SBool = s7 ^ s222+  s2620 :: SBool = if s2138 then s2619 else s222+  s2621 :: SBool = s493 ^ s2620+  s2622 :: SBool = if s2170 then s2621 else s2620+  s2623 :: SBool = s463 ^ s2622+  s2624 :: SBool = if s2202 then s2623 else s2622+  s2625 :: SBool = s435 ^ s2624+  s2626 :: SBool = if s2234 then s2625 else s2624+  s2627 :: SBool = s409 ^ s2626+  s2628 :: SBool = if s2266 then s2627 else s2626+  s2629 :: SBool = s385 ^ s2628+  s2630 :: SBool = if s2298 then s2629 else s2628+  s2631 :: SBool = s363 ^ s2630+  s2632 :: SBool = if s2330 then s2631 else s2630+  s2633 :: SBool = s343 ^ s2632+  s2634 :: SBool = if s2362 then s2633 else s2632+  s2635 :: SBool = s325 ^ s2634+  s2636 :: SBool = if s2394 then s2635 else s2634+  s2637 :: SBool = s309 ^ s2636+  s2638 :: SBool = if s2426 then s2637 else s2636+  s2639 :: SBool = s295 ^ s2638+  s2640 :: SBool = if s2458 then s2639 else s2638+  s2641 :: SBool = s283 ^ s2640+  s2642 :: SBool = if s2490 then s2641 else s2640+  s2643 :: SBool = s273 ^ s2642+  s2644 :: SBool = if s2522 then s2643 else s2642+  s2645 :: SBool = s265 ^ s2644+  s2646 :: SBool = if s2554 then s2645 else s2644+  s2647 :: SBool = s259 ^ s2646+  s2648 :: SBool = if s2586 then s2647 else s2646+  s2649 :: SBool = s255 ^ s2648+  s2650 :: SBool = if s2618 then s2649 else s2648+  s2651 :: SBool = s7 ^ s227+  s2652 :: SBool = if s2170 then s2651 else s227+  s2653 :: SBool = s493 ^ s2652+  s2654 :: SBool = if s2202 then s2653 else s2652+  s2655 :: SBool = s463 ^ s2654+  s2656 :: SBool = if s2234 then s2655 else s2654+  s2657 :: SBool = s435 ^ s2656+  s2658 :: SBool = if s2266 then s2657 else s2656+  s2659 :: SBool = s409 ^ s2658+  s2660 :: SBool = if s2298 then s2659 else s2658+  s2661 :: SBool = s385 ^ s2660+  s2662 :: SBool = if s2330 then s2661 else s2660+  s2663 :: SBool = s363 ^ s2662+  s2664 :: SBool = if s2362 then s2663 else s2662+  s2665 :: SBool = s343 ^ s2664+  s2666 :: SBool = if s2394 then s2665 else s2664+  s2667 :: SBool = s325 ^ s2666+  s2668 :: SBool = if s2426 then s2667 else s2666+  s2669 :: SBool = s309 ^ s2668+  s2670 :: SBool = if s2458 then s2669 else s2668+  s2671 :: SBool = s295 ^ s2670+  s2672 :: SBool = if s2490 then s2671 else s2670+  s2673 :: SBool = s283 ^ s2672+  s2674 :: SBool = if s2522 then s2673 else s2672+  s2675 :: SBool = s273 ^ s2674+  s2676 :: SBool = if s2554 then s2675 else s2674+  s2677 :: SBool = s265 ^ s2676+  s2678 :: SBool = if s2586 then s2677 else s2676+  s2679 :: SBool = s259 ^ s2678+  s2680 :: SBool = if s2618 then s2679 else s2678+  s2681 :: SBool = s255 ^ s2680+  s2682 :: SBool = if s2650 then s2681 else s2680+  s2683 :: SBool = s7 ^ s232+  s2684 :: SBool = if s2202 then s2683 else s232+  s2685 :: SBool = s493 ^ s2684+  s2686 :: SBool = if s2234 then s2685 else s2684+  s2687 :: SBool = s463 ^ s2686+  s2688 :: SBool = if s2266 then s2687 else s2686+  s2689 :: SBool = s435 ^ s2688+  s2690 :: SBool = if s2298 then s2689 else s2688+  s2691 :: SBool = s409 ^ s2690+  s2692 :: SBool = if s2330 then s2691 else s2690+  s2693 :: SBool = s385 ^ s2692+  s2694 :: SBool = if s2362 then s2693 else s2692+  s2695 :: SBool = s363 ^ s2694+  s2696 :: SBool = if s2394 then s2695 else s2694+  s2697 :: SBool = s343 ^ s2696+  s2698 :: SBool = if s2426 then s2697 else s2696+  s2699 :: SBool = s325 ^ s2698+  s2700 :: SBool = if s2458 then s2699 else s2698+  s2701 :: SBool = s309 ^ s2700+  s2702 :: SBool = if s2490 then s2701 else s2700+  s2703 :: SBool = s295 ^ s2702+  s2704 :: SBool = if s2522 then s2703 else s2702+  s2705 :: SBool = s283 ^ s2704+  s2706 :: SBool = if s2554 then s2705 else s2704+  s2707 :: SBool = s273 ^ s2706+  s2708 :: SBool = if s2586 then s2707 else s2706+  s2709 :: SBool = s265 ^ s2708+  s2710 :: SBool = if s2618 then s2709 else s2708+  s2711 :: SBool = s259 ^ s2710+  s2712 :: SBool = if s2650 then s2711 else s2710+  s2713 :: SBool = s255 ^ s2712+  s2714 :: SBool = if s2682 then s2713 else s2712+  s2715 :: SBool = s7 ^ s237+  s2716 :: SBool = if s2234 then s2715 else s237+  s2717 :: SBool = s493 ^ s2716+  s2718 :: SBool = if s2266 then s2717 else s2716+  s2719 :: SBool = s463 ^ s2718+  s2720 :: SBool = if s2298 then s2719 else s2718+  s2721 :: SBool = s435 ^ s2720+  s2722 :: SBool = if s2330 then s2721 else s2720+  s2723 :: SBool = s409 ^ s2722+  s2724 :: SBool = if s2362 then s2723 else s2722+  s2725 :: SBool = s385 ^ s2724+  s2726 :: SBool = if s2394 then s2725 else s2724+  s2727 :: SBool = s363 ^ s2726+  s2728 :: SBool = if s2426 then s2727 else s2726+  s2729 :: SBool = s343 ^ s2728+  s2730 :: SBool = if s2458 then s2729 else s2728+  s2731 :: SBool = s325 ^ s2730+  s2732 :: SBool = if s2490 then s2731 else s2730+  s2733 :: SBool = s309 ^ s2732+  s2734 :: SBool = if s2522 then s2733 else s2732+  s2735 :: SBool = s295 ^ s2734+  s2736 :: SBool = if s2554 then s2735 else s2734+  s2737 :: SBool = s283 ^ s2736+  s2738 :: SBool = if s2586 then s2737 else s2736+  s2739 :: SBool = s273 ^ s2738+  s2740 :: SBool = if s2618 then s2739 else s2738+  s2741 :: SBool = s265 ^ s2740+  s2742 :: SBool = if s2650 then s2741 else s2740+  s2743 :: SBool = s259 ^ s2742+  s2744 :: SBool = if s2682 then s2743 else s2742+  s2745 :: SBool = s255 ^ s2744+  s2746 :: SBool = if s2714 then s2745 else s2744+  s2747 :: SBool = s7 ^ s242+  s2748 :: SBool = if s2266 then s2747 else s242+  s2749 :: SBool = s493 ^ s2748+  s2750 :: SBool = if s2298 then s2749 else s2748+  s2751 :: SBool = s463 ^ s2750+  s2752 :: SBool = if s2330 then s2751 else s2750+  s2753 :: SBool = s435 ^ s2752+  s2754 :: SBool = if s2362 then s2753 else s2752+  s2755 :: SBool = s409 ^ s2754+  s2756 :: SBool = if s2394 then s2755 else s2754+  s2757 :: SBool = s385 ^ s2756+  s2758 :: SBool = if s2426 then s2757 else s2756+  s2759 :: SBool = s363 ^ s2758+  s2760 :: SBool = if s2458 then s2759 else s2758+  s2761 :: SBool = s343 ^ s2760+  s2762 :: SBool = if s2490 then s2761 else s2760+  s2763 :: SBool = s325 ^ s2762+  s2764 :: SBool = if s2522 then s2763 else s2762+  s2765 :: SBool = s309 ^ s2764+  s2766 :: SBool = if s2554 then s2765 else s2764+  s2767 :: SBool = s295 ^ s2766+  s2768 :: SBool = if s2586 then s2767 else s2766+  s2769 :: SBool = s283 ^ s2768+  s2770 :: SBool = if s2618 then s2769 else s2768+  s2771 :: SBool = s273 ^ s2770+  s2772 :: SBool = if s2650 then s2771 else s2770+  s2773 :: SBool = s265 ^ s2772+  s2774 :: SBool = if s2682 then s2773 else s2772+  s2775 :: SBool = s259 ^ s2774+  s2776 :: SBool = if s2714 then s2775 else s2774+  s2777 :: SBool = s255 ^ s2776+  s2778 :: SBool = if s2746 then s2777 else s2776+  s2779 :: SBool = s7 ^ s247+  s2780 :: SBool = if s2298 then s2779 else s247+  s2781 :: SBool = s493 ^ s2780+  s2782 :: SBool = if s2330 then s2781 else s2780+  s2783 :: SBool = s463 ^ s2782+  s2784 :: SBool = if s2362 then s2783 else s2782+  s2785 :: SBool = s435 ^ s2784+  s2786 :: SBool = if s2394 then s2785 else s2784+  s2787 :: SBool = s409 ^ s2786+  s2788 :: SBool = if s2426 then s2787 else s2786+  s2789 :: SBool = s385 ^ s2788+  s2790 :: SBool = if s2458 then s2789 else s2788+  s2791 :: SBool = s363 ^ s2790+  s2792 :: SBool = if s2490 then s2791 else s2790+  s2793 :: SBool = s343 ^ s2792+  s2794 :: SBool = if s2522 then s2793 else s2792+  s2795 :: SBool = s325 ^ s2794+  s2796 :: SBool = if s2554 then s2795 else s2794+  s2797 :: SBool = s309 ^ s2796+  s2798 :: SBool = if s2586 then s2797 else s2796+  s2799 :: SBool = s295 ^ s2798+  s2800 :: SBool = if s2618 then s2799 else s2798+  s2801 :: SBool = s283 ^ s2800+  s2802 :: SBool = if s2650 then s2801 else s2800+  s2803 :: SBool = s273 ^ s2802+  s2804 :: SBool = if s2682 then s2803 else s2802+  s2805 :: SBool = s265 ^ s2804+  s2806 :: SBool = if s2714 then s2805 else s2804+  s2807 :: SBool = s259 ^ s2806+  s2808 :: SBool = if s2746 then s2807 else s2806+  s2809 :: SBool = s255 ^ s2808+  s2810 :: SBool = if s2778 then s2809 else s2808+  s2811 :: SBool = s7 ^ s252+  s2812 :: SBool = if s2330 then s2811 else s252+  s2813 :: SBool = s493 ^ s2812+  s2814 :: SBool = if s2362 then s2813 else s2812+  s2815 :: SBool = s463 ^ s2814+  s2816 :: SBool = if s2394 then s2815 else s2814+  s2817 :: SBool = s435 ^ s2816+  s2818 :: SBool = if s2426 then s2817 else s2816+  s2819 :: SBool = s409 ^ s2818+  s2820 :: SBool = if s2458 then s2819 else s2818+  s2821 :: SBool = s385 ^ s2820+  s2822 :: SBool = if s2490 then s2821 else s2820+  s2823 :: SBool = s363 ^ s2822+  s2824 :: SBool = if s2522 then s2823 else s2822+  s2825 :: SBool = s343 ^ s2824+  s2826 :: SBool = if s2554 then s2825 else s2824+  s2827 :: SBool = s325 ^ s2826+  s2828 :: SBool = if s2586 then s2827 else s2826+  s2829 :: SBool = s309 ^ s2828+  s2830 :: SBool = if s2618 then s2829 else s2828+  s2831 :: SBool = s295 ^ s2830+  s2832 :: SBool = if s2650 then s2831 else s2830+  s2833 :: SBool = s283 ^ s2832+  s2834 :: SBool = if s2682 then s2833 else s2832+  s2835 :: SBool = s273 ^ s2834+  s2836 :: SBool = if s2714 then s2835 else s2834+  s2837 :: SBool = s265 ^ s2836+  s2838 :: SBool = if s2746 then s2837 else s2836+  s2839 :: SBool = s259 ^ s2838+  s2840 :: SBool = if s2778 then s2839 else s2838+  s2841 :: SBool = s255 ^ s2840+  s2842 :: SBool = if s2810 then s2841 else s2840+  s2843 :: SBool = if s2362 then s7 else s_2+  s2844 :: SBool = s493 ^ s2843+  s2845 :: SBool = if s2394 then s2844 else s2843+  s2846 :: SBool = s463 ^ s2845+  s2847 :: SBool = if s2426 then s2846 else s2845+  s2848 :: SBool = s435 ^ s2847+  s2849 :: SBool = if s2458 then s2848 else s2847+  s2850 :: SBool = s409 ^ s2849+  s2851 :: SBool = if s2490 then s2850 else s2849+  s2852 :: SBool = s385 ^ s2851+  s2853 :: SBool = if s2522 then s2852 else s2851+  s2854 :: SBool = s363 ^ s2853+  s2855 :: SBool = if s2554 then s2854 else s2853+  s2856 :: SBool = s343 ^ s2855+  s2857 :: SBool = if s2586 then s2856 else s2855+  s2858 :: SBool = s325 ^ s2857+  s2859 :: SBool = if s2618 then s2858 else s2857+  s2860 :: SBool = s309 ^ s2859+  s2861 :: SBool = if s2650 then s2860 else s2859+  s2862 :: SBool = s295 ^ s2861+  s2863 :: SBool = if s2682 then s2862 else s2861+  s2864 :: SBool = s283 ^ s2863+  s2865 :: SBool = if s2714 then s2864 else s2863+  s2866 :: SBool = s273 ^ s2865+  s2867 :: SBool = if s2746 then s2866 else s2865+  s2868 :: SBool = s265 ^ s2867+  s2869 :: SBool = if s2778 then s2868 else s2867+  s2870 :: SBool = s259 ^ s2869+  s2871 :: SBool = if s2810 then s2870 else s2869+  s2872 :: SBool = s255 ^ s2871+  s2873 :: SBool = if s2842 then s2872 else s2871+  s2874 :: SBool = s1578 ^ s2873+  s2875 :: SBool = if s1099 then s7 else s_2+  s2876 :: SBool = s493 ^ s2875+  s2877 :: SBool = if s1131 then s2876 else s2875+  s2878 :: SBool = s463 ^ s2877+  s2879 :: SBool = if s1163 then s2878 else s2877+  s2880 :: SBool = s435 ^ s2879+  s2881 :: SBool = if s1195 then s2880 else s2879+  s2882 :: SBool = s409 ^ s2881+  s2883 :: SBool = if s1227 then s2882 else s2881+  s2884 :: SBool = s385 ^ s2883+  s2885 :: SBool = if s1259 then s2884 else s2883+  s2886 :: SBool = s363 ^ s2885+  s2887 :: SBool = if s1291 then s2886 else s2885+  s2888 :: SBool = s343 ^ s2887+  s2889 :: SBool = if s1323 then s2888 else s2887+  s2890 :: SBool = s325 ^ s2889+  s2891 :: SBool = if s1355 then s2890 else s2889+  s2892 :: SBool = s309 ^ s2891+  s2893 :: SBool = if s1387 then s2892 else s2891+  s2894 :: SBool = s295 ^ s2893+  s2895 :: SBool = if s1419 then s2894 else s2893+  s2896 :: SBool = s283 ^ s2895+  s2897 :: SBool = if s1451 then s2896 else s2895+  s2898 :: SBool = s273 ^ s2897+  s2899 :: SBool = if s1483 then s2898 else s2897+  s2900 :: SBool = s265 ^ s2899+  s2901 :: SBool = if s1515 then s2900 else s2899+  s2902 :: SBool = s259 ^ s2901+  s2903 :: SBool = if s1547 then s2902 else s2901+  s2904 :: SBool = if s2394 then s7 else s_2+  s2905 :: SBool = s493 ^ s2904+  s2906 :: SBool = if s2426 then s2905 else s2904+  s2907 :: SBool = s463 ^ s2906+  s2908 :: SBool = if s2458 then s2907 else s2906+  s2909 :: SBool = s435 ^ s2908+  s2910 :: SBool = if s2490 then s2909 else s2908+  s2911 :: SBool = s409 ^ s2910+  s2912 :: SBool = if s2522 then s2911 else s2910+  s2913 :: SBool = s385 ^ s2912+  s2914 :: SBool = if s2554 then s2913 else s2912+  s2915 :: SBool = s363 ^ s2914+  s2916 :: SBool = if s2586 then s2915 else s2914+  s2917 :: SBool = s343 ^ s2916+  s2918 :: SBool = if s2618 then s2917 else s2916+  s2919 :: SBool = s325 ^ s2918+  s2920 :: SBool = if s2650 then s2919 else s2918+  s2921 :: SBool = s309 ^ s2920+  s2922 :: SBool = if s2682 then s2921 else s2920+  s2923 :: SBool = s295 ^ s2922+  s2924 :: SBool = if s2714 then s2923 else s2922+  s2925 :: SBool = s283 ^ s2924+  s2926 :: SBool = if s2746 then s2925 else s2924+  s2927 :: SBool = s273 ^ s2926+  s2928 :: SBool = if s2778 then s2927 else s2926+  s2929 :: SBool = s265 ^ s2928+  s2930 :: SBool = if s2810 then s2929 else s2928+  s2931 :: SBool = s259 ^ s2930+  s2932 :: SBool = if s2842 then s2931 else s2930+  s2933 :: SBool = s2903 ^ s2932+  s2934 :: SBool = if s1131 then s7 else s_2+  s2935 :: SBool = s493 ^ s2934+  s2936 :: SBool = if s1163 then s2935 else s2934+  s2937 :: SBool = s463 ^ s2936+  s2938 :: SBool = if s1195 then s2937 else s2936+  s2939 :: SBool = s435 ^ s2938+  s2940 :: SBool = if s1227 then s2939 else s2938+  s2941 :: SBool = s409 ^ s2940+  s2942 :: SBool = if s1259 then s2941 else s2940+  s2943 :: SBool = s385 ^ s2942+  s2944 :: SBool = if s1291 then s2943 else s2942+  s2945 :: SBool = s363 ^ s2944+  s2946 :: SBool = if s1323 then s2945 else s2944+  s2947 :: SBool = s343 ^ s2946+  s2948 :: SBool = if s1355 then s2947 else s2946+  s2949 :: SBool = s325 ^ s2948+  s2950 :: SBool = if s1387 then s2949 else s2948+  s2951 :: SBool = s309 ^ s2950+  s2952 :: SBool = if s1419 then s2951 else s2950+  s2953 :: SBool = s295 ^ s2952+  s2954 :: SBool = if s1451 then s2953 else s2952+  s2955 :: SBool = s283 ^ s2954+  s2956 :: SBool = if s1483 then s2955 else s2954+  s2957 :: SBool = s273 ^ s2956+  s2958 :: SBool = if s1515 then s2957 else s2956+  s2959 :: SBool = s265 ^ s2958+  s2960 :: SBool = if s1547 then s2959 else s2958+  s2961 :: SBool = if s2426 then s7 else s_2+  s2962 :: SBool = s493 ^ s2961+  s2963 :: SBool = if s2458 then s2962 else s2961+  s2964 :: SBool = s463 ^ s2963+  s2965 :: SBool = if s2490 then s2964 else s2963+  s2966 :: SBool = s435 ^ s2965+  s2967 :: SBool = if s2522 then s2966 else s2965+  s2968 :: SBool = s409 ^ s2967+  s2969 :: SBool = if s2554 then s2968 else s2967+  s2970 :: SBool = s385 ^ s2969+  s2971 :: SBool = if s2586 then s2970 else s2969+  s2972 :: SBool = s363 ^ s2971+  s2973 :: SBool = if s2618 then s2972 else s2971+  s2974 :: SBool = s343 ^ s2973+  s2975 :: SBool = if s2650 then s2974 else s2973+  s2976 :: SBool = s325 ^ s2975+  s2977 :: SBool = if s2682 then s2976 else s2975+  s2978 :: SBool = s309 ^ s2977+  s2979 :: SBool = if s2714 then s2978 else s2977+  s2980 :: SBool = s295 ^ s2979+  s2981 :: SBool = if s2746 then s2980 else s2979+  s2982 :: SBool = s283 ^ s2981+  s2983 :: SBool = if s2778 then s2982 else s2981+  s2984 :: SBool = s273 ^ s2983+  s2985 :: SBool = if s2810 then s2984 else s2983+  s2986 :: SBool = s265 ^ s2985+  s2987 :: SBool = if s2842 then s2986 else s2985+  s2988 :: SBool = s2960 ^ s2987+  s2989 :: SBool = if s1163 then s7 else s_2+  s2990 :: SBool = s493 ^ s2989+  s2991 :: SBool = if s1195 then s2990 else s2989+  s2992 :: SBool = s463 ^ s2991+  s2993 :: SBool = if s1227 then s2992 else s2991+  s2994 :: SBool = s435 ^ s2993+  s2995 :: SBool = if s1259 then s2994 else s2993+  s2996 :: SBool = s409 ^ s2995+  s2997 :: SBool = if s1291 then s2996 else s2995+  s2998 :: SBool = s385 ^ s2997+  s2999 :: SBool = if s1323 then s2998 else s2997+  s3000 :: SBool = s363 ^ s2999+  s3001 :: SBool = if s1355 then s3000 else s2999+  s3002 :: SBool = s343 ^ s3001+  s3003 :: SBool = if s1387 then s3002 else s3001+  s3004 :: SBool = s325 ^ s3003+  s3005 :: SBool = if s1419 then s3004 else s3003+  s3006 :: SBool = s309 ^ s3005+  s3007 :: SBool = if s1451 then s3006 else s3005+  s3008 :: SBool = s295 ^ s3007+  s3009 :: SBool = if s1483 then s3008 else s3007+  s3010 :: SBool = s283 ^ s3009+  s3011 :: SBool = if s1515 then s3010 else s3009+  s3012 :: SBool = s273 ^ s3011+  s3013 :: SBool = if s1547 then s3012 else s3011+  s3014 :: SBool = if s2458 then s7 else s_2+  s3015 :: SBool = s493 ^ s3014+  s3016 :: SBool = if s2490 then s3015 else s3014+  s3017 :: SBool = s463 ^ s3016+  s3018 :: SBool = if s2522 then s3017 else s3016+  s3019 :: SBool = s435 ^ s3018+  s3020 :: SBool = if s2554 then s3019 else s3018+  s3021 :: SBool = s409 ^ s3020+  s3022 :: SBool = if s2586 then s3021 else s3020+  s3023 :: SBool = s385 ^ s3022+  s3024 :: SBool = if s2618 then s3023 else s3022+  s3025 :: SBool = s363 ^ s3024+  s3026 :: SBool = if s2650 then s3025 else s3024+  s3027 :: SBool = s343 ^ s3026+  s3028 :: SBool = if s2682 then s3027 else s3026+  s3029 :: SBool = s325 ^ s3028+  s3030 :: SBool = if s2714 then s3029 else s3028+  s3031 :: SBool = s309 ^ s3030+  s3032 :: SBool = if s2746 then s3031 else s3030+  s3033 :: SBool = s295 ^ s3032+  s3034 :: SBool = if s2778 then s3033 else s3032+  s3035 :: SBool = s283 ^ s3034+  s3036 :: SBool = if s2810 then s3035 else s3034+  s3037 :: SBool = s273 ^ s3036+  s3038 :: SBool = if s2842 then s3037 else s3036+  s3039 :: SBool = s3013 ^ s3038+  s3040 :: SBool = if s1195 then s7 else s_2+  s3041 :: SBool = s493 ^ s3040+  s3042 :: SBool = if s1227 then s3041 else s3040+  s3043 :: SBool = s463 ^ s3042+  s3044 :: SBool = if s1259 then s3043 else s3042+  s3045 :: SBool = s435 ^ s3044+  s3046 :: SBool = if s1291 then s3045 else s3044+  s3047 :: SBool = s409 ^ s3046+  s3048 :: SBool = if s1323 then s3047 else s3046+  s3049 :: SBool = s385 ^ s3048+  s3050 :: SBool = if s1355 then s3049 else s3048+  s3051 :: SBool = s363 ^ s3050+  s3052 :: SBool = if s1387 then s3051 else s3050+  s3053 :: SBool = s343 ^ s3052+  s3054 :: SBool = if s1419 then s3053 else s3052+  s3055 :: SBool = s325 ^ s3054+  s3056 :: SBool = if s1451 then s3055 else s3054+  s3057 :: SBool = s309 ^ s3056+  s3058 :: SBool = if s1483 then s3057 else s3056+  s3059 :: SBool = s295 ^ s3058+  s3060 :: SBool = if s1515 then s3059 else s3058+  s3061 :: SBool = s283 ^ s3060+  s3062 :: SBool = if s1547 then s3061 else s3060+  s3063 :: SBool = if s2490 then s7 else s_2+  s3064 :: SBool = s493 ^ s3063+  s3065 :: SBool = if s2522 then s3064 else s3063+  s3066 :: SBool = s463 ^ s3065+  s3067 :: SBool = if s2554 then s3066 else s3065+  s3068 :: SBool = s435 ^ s3067+  s3069 :: SBool = if s2586 then s3068 else s3067+  s3070 :: SBool = s409 ^ s3069+  s3071 :: SBool = if s2618 then s3070 else s3069+  s3072 :: SBool = s385 ^ s3071+  s3073 :: SBool = if s2650 then s3072 else s3071+  s3074 :: SBool = s363 ^ s3073+  s3075 :: SBool = if s2682 then s3074 else s3073+  s3076 :: SBool = s343 ^ s3075+  s3077 :: SBool = if s2714 then s3076 else s3075+  s3078 :: SBool = s325 ^ s3077+  s3079 :: SBool = if s2746 then s3078 else s3077+  s3080 :: SBool = s309 ^ s3079+  s3081 :: SBool = if s2778 then s3080 else s3079+  s3082 :: SBool = s295 ^ s3081+  s3083 :: SBool = if s2810 then s3082 else s3081+  s3084 :: SBool = s283 ^ s3083+  s3085 :: SBool = if s2842 then s3084 else s3083+  s3086 :: SBool = s3062 ^ s3085+  s3087 :: SBool = if s1227 then s7 else s_2+  s3088 :: SBool = s493 ^ s3087+  s3089 :: SBool = if s1259 then s3088 else s3087+  s3090 :: SBool = s463 ^ s3089+  s3091 :: SBool = if s1291 then s3090 else s3089+  s3092 :: SBool = s435 ^ s3091+  s3093 :: SBool = if s1323 then s3092 else s3091+  s3094 :: SBool = s409 ^ s3093+  s3095 :: SBool = if s1355 then s3094 else s3093+  s3096 :: SBool = s385 ^ s3095+  s3097 :: SBool = if s1387 then s3096 else s3095+  s3098 :: SBool = s363 ^ s3097+  s3099 :: SBool = if s1419 then s3098 else s3097+  s3100 :: SBool = s343 ^ s3099+  s3101 :: SBool = if s1451 then s3100 else s3099+  s3102 :: SBool = s325 ^ s3101+  s3103 :: SBool = if s1483 then s3102 else s3101+  s3104 :: SBool = s309 ^ s3103+  s3105 :: SBool = if s1515 then s3104 else s3103+  s3106 :: SBool = s295 ^ s3105+  s3107 :: SBool = if s1547 then s3106 else s3105+  s3108 :: SBool = if s2522 then s7 else s_2+  s3109 :: SBool = s493 ^ s3108+  s3110 :: SBool = if s2554 then s3109 else s3108+  s3111 :: SBool = s463 ^ s3110+  s3112 :: SBool = if s2586 then s3111 else s3110+  s3113 :: SBool = s435 ^ s3112+  s3114 :: SBool = if s2618 then s3113 else s3112+  s3115 :: SBool = s409 ^ s3114+  s3116 :: SBool = if s2650 then s3115 else s3114+  s3117 :: SBool = s385 ^ s3116+  s3118 :: SBool = if s2682 then s3117 else s3116+  s3119 :: SBool = s363 ^ s3118+  s3120 :: SBool = if s2714 then s3119 else s3118+  s3121 :: SBool = s343 ^ s3120+  s3122 :: SBool = if s2746 then s3121 else s3120+  s3123 :: SBool = s325 ^ s3122+  s3124 :: SBool = if s2778 then s3123 else s3122+  s3125 :: SBool = s309 ^ s3124+  s3126 :: SBool = if s2810 then s3125 else s3124+  s3127 :: SBool = s295 ^ s3126+  s3128 :: SBool = if s2842 then s3127 else s3126+  s3129 :: SBool = s3107 ^ s3128+  s3130 :: SBool = if s1259 then s7 else s_2+  s3131 :: SBool = s493 ^ s3130+  s3132 :: SBool = if s1291 then s3131 else s3130+  s3133 :: SBool = s463 ^ s3132+  s3134 :: SBool = if s1323 then s3133 else s3132+  s3135 :: SBool = s435 ^ s3134+  s3136 :: SBool = if s1355 then s3135 else s3134+  s3137 :: SBool = s409 ^ s3136+  s3138 :: SBool = if s1387 then s3137 else s3136+  s3139 :: SBool = s385 ^ s3138+  s3140 :: SBool = if s1419 then s3139 else s3138+  s3141 :: SBool = s363 ^ s3140+  s3142 :: SBool = if s1451 then s3141 else s3140+  s3143 :: SBool = s343 ^ s3142+  s3144 :: SBool = if s1483 then s3143 else s3142+  s3145 :: SBool = s325 ^ s3144+  s3146 :: SBool = if s1515 then s3145 else s3144+  s3147 :: SBool = s309 ^ s3146+  s3148 :: SBool = if s1547 then s3147 else s3146+  s3149 :: SBool = if s2554 then s7 else s_2+  s3150 :: SBool = s493 ^ s3149+  s3151 :: SBool = if s2586 then s3150 else s3149+  s3152 :: SBool = s463 ^ s3151+  s3153 :: SBool = if s2618 then s3152 else s3151+  s3154 :: SBool = s435 ^ s3153+  s3155 :: SBool = if s2650 then s3154 else s3153+  s3156 :: SBool = s409 ^ s3155+  s3157 :: SBool = if s2682 then s3156 else s3155+  s3158 :: SBool = s385 ^ s3157+  s3159 :: SBool = if s2714 then s3158 else s3157+  s3160 :: SBool = s363 ^ s3159+  s3161 :: SBool = if s2746 then s3160 else s3159+  s3162 :: SBool = s343 ^ s3161+  s3163 :: SBool = if s2778 then s3162 else s3161+  s3164 :: SBool = s325 ^ s3163+  s3165 :: SBool = if s2810 then s3164 else s3163+  s3166 :: SBool = s309 ^ s3165+  s3167 :: SBool = if s2842 then s3166 else s3165+  s3168 :: SBool = s3148 ^ s3167+  s3169 :: SBool = if s1291 then s7 else s_2+  s3170 :: SBool = s493 ^ s3169+  s3171 :: SBool = if s1323 then s3170 else s3169+  s3172 :: SBool = s463 ^ s3171+  s3173 :: SBool = if s1355 then s3172 else s3171+  s3174 :: SBool = s435 ^ s3173+  s3175 :: SBool = if s1387 then s3174 else s3173+  s3176 :: SBool = s409 ^ s3175+  s3177 :: SBool = if s1419 then s3176 else s3175+  s3178 :: SBool = s385 ^ s3177+  s3179 :: SBool = if s1451 then s3178 else s3177+  s3180 :: SBool = s363 ^ s3179+  s3181 :: SBool = if s1483 then s3180 else s3179+  s3182 :: SBool = s343 ^ s3181+  s3183 :: SBool = if s1515 then s3182 else s3181+  s3184 :: SBool = s325 ^ s3183+  s3185 :: SBool = if s1547 then s3184 else s3183+  s3186 :: SBool = if s2586 then s7 else s_2+  s3187 :: SBool = s493 ^ s3186+  s3188 :: SBool = if s2618 then s3187 else s3186+  s3189 :: SBool = s463 ^ s3188+  s3190 :: SBool = if s2650 then s3189 else s3188+  s3191 :: SBool = s435 ^ s3190+  s3192 :: SBool = if s2682 then s3191 else s3190+  s3193 :: SBool = s409 ^ s3192+  s3194 :: SBool = if s2714 then s3193 else s3192+  s3195 :: SBool = s385 ^ s3194+  s3196 :: SBool = if s2746 then s3195 else s3194+  s3197 :: SBool = s363 ^ s3196+  s3198 :: SBool = if s2778 then s3197 else s3196+  s3199 :: SBool = s343 ^ s3198+  s3200 :: SBool = if s2810 then s3199 else s3198+  s3201 :: SBool = s325 ^ s3200+  s3202 :: SBool = if s2842 then s3201 else s3200+  s3203 :: SBool = s3185 ^ s3202+  s3204 :: SBool = if s1323 then s7 else s_2+  s3205 :: SBool = s493 ^ s3204+  s3206 :: SBool = if s1355 then s3205 else s3204+  s3207 :: SBool = s463 ^ s3206+  s3208 :: SBool = if s1387 then s3207 else s3206+  s3209 :: SBool = s435 ^ s3208+  s3210 :: SBool = if s1419 then s3209 else s3208+  s3211 :: SBool = s409 ^ s3210+  s3212 :: SBool = if s1451 then s3211 else s3210+  s3213 :: SBool = s385 ^ s3212+  s3214 :: SBool = if s1483 then s3213 else s3212+  s3215 :: SBool = s363 ^ s3214+  s3216 :: SBool = if s1515 then s3215 else s3214+  s3217 :: SBool = s343 ^ s3216+  s3218 :: SBool = if s1547 then s3217 else s3216+  s3219 :: SBool = if s2618 then s7 else s_2+  s3220 :: SBool = s493 ^ s3219+  s3221 :: SBool = if s2650 then s3220 else s3219+  s3222 :: SBool = s463 ^ s3221+  s3223 :: SBool = if s2682 then s3222 else s3221+  s3224 :: SBool = s435 ^ s3223+  s3225 :: SBool = if s2714 then s3224 else s3223+  s3226 :: SBool = s409 ^ s3225+  s3227 :: SBool = if s2746 then s3226 else s3225+  s3228 :: SBool = s385 ^ s3227+  s3229 :: SBool = if s2778 then s3228 else s3227+  s3230 :: SBool = s363 ^ s3229+  s3231 :: SBool = if s2810 then s3230 else s3229+  s3232 :: SBool = s343 ^ s3231+  s3233 :: SBool = if s2842 then s3232 else s3231+  s3234 :: SBool = s3218 ^ s3233+  s3235 :: SBool = if s1355 then s7 else s_2+  s3236 :: SBool = s493 ^ s3235+  s3237 :: SBool = if s1387 then s3236 else s3235+  s3238 :: SBool = s463 ^ s3237+  s3239 :: SBool = if s1419 then s3238 else s3237+  s3240 :: SBool = s435 ^ s3239+  s3241 :: SBool = if s1451 then s3240 else s3239+  s3242 :: SBool = s409 ^ s3241+  s3243 :: SBool = if s1483 then s3242 else s3241+  s3244 :: SBool = s385 ^ s3243+  s3245 :: SBool = if s1515 then s3244 else s3243+  s3246 :: SBool = s363 ^ s3245+  s3247 :: SBool = if s1547 then s3246 else s3245+  s3248 :: SBool = if s2650 then s7 else s_2+  s3249 :: SBool = s493 ^ s3248+  s3250 :: SBool = if s2682 then s3249 else s3248+  s3251 :: SBool = s463 ^ s3250+  s3252 :: SBool = if s2714 then s3251 else s3250+  s3253 :: SBool = s435 ^ s3252+  s3254 :: SBool = if s2746 then s3253 else s3252+  s3255 :: SBool = s409 ^ s3254+  s3256 :: SBool = if s2778 then s3255 else s3254+  s3257 :: SBool = s385 ^ s3256+  s3258 :: SBool = if s2810 then s3257 else s3256+  s3259 :: SBool = s363 ^ s3258+  s3260 :: SBool = if s2842 then s3259 else s3258+  s3261 :: SBool = s3247 ^ s3260+  s3262 :: SBool = if s1387 then s7 else s_2+  s3263 :: SBool = s493 ^ s3262+  s3264 :: SBool = if s1419 then s3263 else s3262+  s3265 :: SBool = s463 ^ s3264+  s3266 :: SBool = if s1451 then s3265 else s3264+  s3267 :: SBool = s435 ^ s3266+  s3268 :: SBool = if s1483 then s3267 else s3266+  s3269 :: SBool = s409 ^ s3268+  s3270 :: SBool = if s1515 then s3269 else s3268+  s3271 :: SBool = s385 ^ s3270+  s3272 :: SBool = if s1547 then s3271 else s3270+  s3273 :: SBool = if s2682 then s7 else s_2+  s3274 :: SBool = s493 ^ s3273+  s3275 :: SBool = if s2714 then s3274 else s3273+  s3276 :: SBool = s463 ^ s3275+  s3277 :: SBool = if s2746 then s3276 else s3275+  s3278 :: SBool = s435 ^ s3277+  s3279 :: SBool = if s2778 then s3278 else s3277+  s3280 :: SBool = s409 ^ s3279+  s3281 :: SBool = if s2810 then s3280 else s3279+  s3282 :: SBool = s385 ^ s3281+  s3283 :: SBool = if s2842 then s3282 else s3281+  s3284 :: SBool = s3272 ^ s3283+  s3285 :: SBool = if s1419 then s7 else s_2+  s3286 :: SBool = s493 ^ s3285+  s3287 :: SBool = if s1451 then s3286 else s3285+  s3288 :: SBool = s463 ^ s3287+  s3289 :: SBool = if s1483 then s3288 else s3287+  s3290 :: SBool = s435 ^ s3289+  s3291 :: SBool = if s1515 then s3290 else s3289+  s3292 :: SBool = s409 ^ s3291+  s3293 :: SBool = if s1547 then s3292 else s3291+  s3294 :: SBool = if s2714 then s7 else s_2+  s3295 :: SBool = s493 ^ s3294+  s3296 :: SBool = if s2746 then s3295 else s3294+  s3297 :: SBool = s463 ^ s3296+  s3298 :: SBool = if s2778 then s3297 else s3296+  s3299 :: SBool = s435 ^ s3298+  s3300 :: SBool = if s2810 then s3299 else s3298+  s3301 :: SBool = s409 ^ s3300+  s3302 :: SBool = if s2842 then s3301 else s3300+  s3303 :: SBool = s3293 ^ s3302+  s3304 :: SBool = if s1451 then s7 else s_2+  s3305 :: SBool = s493 ^ s3304+  s3306 :: SBool = if s1483 then s3305 else s3304+  s3307 :: SBool = s463 ^ s3306+  s3308 :: SBool = if s1515 then s3307 else s3306+  s3309 :: SBool = s435 ^ s3308+  s3310 :: SBool = if s1547 then s3309 else s3308+  s3311 :: SBool = if s2746 then s7 else s_2+  s3312 :: SBool = s493 ^ s3311+  s3313 :: SBool = if s2778 then s3312 else s3311+  s3314 :: SBool = s463 ^ s3313+  s3315 :: SBool = if s2810 then s3314 else s3313+  s3316 :: SBool = s435 ^ s3315+  s3317 :: SBool = if s2842 then s3316 else s3315+  s3318 :: SBool = s3310 ^ s3317+  s3319 :: SBool = if s1483 then s7 else s_2+  s3320 :: SBool = s493 ^ s3319+  s3321 :: SBool = if s1515 then s3320 else s3319+  s3322 :: SBool = s463 ^ s3321+  s3323 :: SBool = if s1547 then s3322 else s3321+  s3324 :: SBool = if s2778 then s7 else s_2+  s3325 :: SBool = s493 ^ s3324+  s3326 :: SBool = if s2810 then s3325 else s3324+  s3327 :: SBool = s463 ^ s3326+  s3328 :: SBool = if s2842 then s3327 else s3326+  s3329 :: SBool = s3323 ^ s3328+  s3330 :: SBool = if s1515 then s7 else s_2+  s3331 :: SBool = s493 ^ s3330+  s3332 :: SBool = if s1547 then s3331 else s3330+  s3333 :: SBool = if s2810 then s7 else s_2+  s3334 :: SBool = s493 ^ s3333+  s3335 :: SBool = if s2842 then s3334 else s3333+  s3336 :: SBool = s3332 ^ s3335+  s3337 :: SBool = if s1547 then s7 else s_2+  s3338 :: SBool = if s2842 then s7 else s_2+  s3339 :: SBool = s3337 ^ s3338+  s3341 :: SWord8 = if s3339 then s18 else s3340+  s3342 :: SWord8 = s18 + s3341+  s3343 :: SWord8 = if s3336 then s3342 else s3341+  s3344 :: SWord8 = s18 + s3343+  s3345 :: SWord8 = if s3329 then s3344 else s3343+  s3346 :: SWord8 = s18 + s3345+  s3347 :: SWord8 = if s3318 then s3346 else s3345+  s3348 :: SWord8 = s18 + s3347+  s3349 :: SWord8 = if s3303 then s3348 else s3347+  s3350 :: SWord8 = s18 + s3349+  s3351 :: SWord8 = if s3284 then s3350 else s3349+  s3352 :: SWord8 = s18 + s3351+  s3353 :: SWord8 = if s3261 then s3352 else s3351+  s3354 :: SWord8 = s18 + s3353+  s3355 :: SWord8 = if s3234 then s3354 else s3353+  s3356 :: SWord8 = s18 + s3355+  s3357 :: SWord8 = if s3203 then s3356 else s3355+  s3358 :: SWord8 = s18 + s3357+  s3359 :: SWord8 = if s3168 then s3358 else s3357+  s3360 :: SWord8 = s18 + s3359+  s3361 :: SWord8 = if s3129 then s3360 else s3359+  s3362 :: SWord8 = s18 + s3361+  s3363 :: SWord8 = if s3086 then s3362 else s3361+  s3364 :: SWord8 = s18 + s3363+  s3365 :: SWord8 = if s3039 then s3364 else s3363+  s3366 :: SWord8 = s18 + s3365+  s3367 :: SWord8 = if s2988 then s3366 else s3365+  s3368 :: SWord8 = s18 + s3367+  s3369 :: SWord8 = if s2933 then s3368 else s3367+  s3370 :: SWord8 = s18 + s3369+  s3371 :: SWord8 = if s2874 then s3370 else s3369+  s3372 :: SWord8 = s18 + s3371+  s3373 :: SWord8 = if s253 then s3372 else s3371+  s3374 :: SWord8 = s18 + s3373+  s3375 :: SWord8 = if s248 then s3374 else s3373+  s3376 :: SWord8 = s18 + s3375+  s3377 :: SWord8 = if s243 then s3376 else s3375+  s3378 :: SWord8 = s18 + s3377+  s3379 :: SWord8 = if s238 then s3378 else s3377+  s3380 :: SWord8 = s18 + s3379+  s3381 :: SWord8 = if s233 then s3380 else s3379+  s3382 :: SWord8 = s18 + s3381+  s3383 :: SWord8 = if s228 then s3382 else s3381+  s3384 :: SWord8 = s18 + s3383+  s3385 :: SWord8 = if s223 then s3384 else s3383+  s3386 :: SWord8 = s18 + s3385+  s3387 :: SWord8 = if s218 then s3386 else s3385+  s3388 :: SWord8 = s18 + s3387+  s3389 :: SWord8 = if s213 then s3388 else s3387+  s3390 :: SWord8 = s18 + s3389+  s3391 :: SWord8 = if s208 then s3390 else s3389+  s3392 :: SWord8 = s18 + s3391+  s3393 :: SWord8 = if s203 then s3392 else s3391+  s3394 :: SWord8 = s18 + s3393+  s3395 :: SWord8 = if s198 then s3394 else s3393+  s3396 :: SWord8 = s18 + s3395+  s3397 :: SWord8 = if s193 then s3396 else s3395+  s3398 :: SWord8 = s18 + s3397+  s3399 :: SWord8 = if s188 then s3398 else s3397+  s3400 :: SWord8 = s18 + s3399+  s3401 :: SWord8 = if s183 then s3400 else s3399+  s3402 :: SWord8 = s18 + s3401+  s3403 :: SWord8 = if s178 then s3402 else s3401+  s3404 :: SWord8 = s18 + s3403+  s3405 :: SWord8 = if s173 then s3404 else s3403+  s3406 :: SWord8 = s18 + s3405+  s3407 :: SWord8 = if s168 then s3406 else s3405+  s3408 :: SWord8 = s18 + s3407+  s3409 :: SWord8 = if s163 then s3408 else s3407+  s3410 :: SWord8 = s18 + s3409+  s3411 :: SWord8 = if s158 then s3410 else s3409+  s3412 :: SWord8 = s18 + s3411+  s3413 :: SWord8 = if s153 then s3412 else s3411+  s3414 :: SWord8 = s18 + s3413+  s3415 :: SWord8 = if s148 then s3414 else s3413+  s3416 :: SWord8 = s18 + s3415+  s3417 :: SWord8 = if s143 then s3416 else s3415+  s3418 :: SWord8 = s18 + s3417+  s3419 :: SWord8 = if s138 then s3418 else s3417+  s3420 :: SWord8 = s18 + s3419+  s3421 :: SWord8 = if s133 then s3420 else s3419+  s3422 :: SWord8 = s18 + s3421+  s3423 :: SWord8 = if s128 then s3422 else s3421+  s3424 :: SWord8 = s18 + s3423+  s3425 :: SWord8 = if s123 then s3424 else s3423+  s3426 :: SWord8 = s18 + s3425+  s3427 :: SWord8 = if s118 then s3426 else s3425+  s3428 :: SWord8 = s18 + s3427+  s3429 :: SWord8 = if s113 then s3428 else s3427+  s3430 :: SWord8 = s18 + s3429+  s3431 :: SWord8 = if s108 then s3430 else s3429+  s3432 :: SWord8 = s18 + s3431+  s3433 :: SWord8 = if s103 then s3432 else s3431+  s3434 :: SWord8 = s18 + s3433+  s3435 :: SWord8 = if s98 then s3434 else s3433+  s3436 :: SWord8 = s18 + s3435+  s3437 :: SWord8 = if s93 then s3436 else s3435+  s3438 :: SWord8 = s18 + s3437+  s3439 :: SWord8 = if s88 then s3438 else s3437+  s3440 :: SWord8 = s18 + s3439+  s3441 :: SWord8 = if s83 then s3440 else s3439+  s3442 :: SWord8 = s18 + s3441+  s3443 :: SWord8 = if s78 then s3442 else s3441+  s3444 :: SWord8 = s18 + s3443+  s3445 :: SWord8 = if s73 then s3444 else s3443+  s3446 :: SWord8 = s18 + s3445+  s3447 :: SWord8 = if s68 then s3446 else s3445+  s3448 :: SWord8 = s18 + s3447+  s3449 :: SWord8 = if s63 then s3448 else s3447+  s3450 :: SWord8 = s18 + s3449+  s3451 :: SWord8 = if s58 then s3450 else s3449+  s3452 :: SWord8 = s18 + s3451+  s3453 :: SWord8 = if s53 then s3452 else s3451+  s3454 :: SWord8 = s18 + s3453+  s3455 :: SWord8 = if s48 then s3454 else s3453+  s3456 :: SWord8 = s18 + s3455+  s3457 :: SWord8 = if s43 then s3456 else s3455+  s3458 :: SWord8 = s18 + s3457+  s3459 :: SWord8 = if s38 then s3458 else s3457+  s3460 :: SWord8 = s18 + s3459+  s3461 :: SWord8 = if s33 then s3460 else s3459+  s3462 :: SWord8 = s18 + s3461+  s3463 :: SWord8 = if s28 then s3462 else s3461+  s3464 :: SWord8 = s18 + s3463+  s3465 :: SWord8 = if s23 then s3464 else s3463+  s3466 :: SWord8 = s18 + s3465+  s3467 :: SWord8 = if s17 then s3466 else s3465+  s3469 :: SBool = s3467 >= s3468+  s3470 :: SBool = s12 | s3469+  s3471 :: SBool = s7 & s3470+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s3471
+ SBVTestSuite/GoldFiles/crcUSB5_1.gold view
@@ -0,0 +1,181 @@+== BEGIN: "Makefile" ================+# Makefile for crcUSB5. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: crcUSB5_driver++crcUSB5.o: crcUSB5.c crcUSB5.h+	${CC} ${CCFLAGS} -c $< -o $@++crcUSB5_driver.o: crcUSB5_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++crcUSB5_driver: crcUSB5.o crcUSB5_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f crcUSB5_driver+== END: "Makefile" ==================+== BEGIN: "crcUSB5.h" ================+/* Header file for crcUSB5. Automatically generated by SBV. Do not edit! */++#ifndef __crcUSB5__HEADER_INCLUDED__+#define __crcUSB5__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+SWord16 crcUSB5(const SWord16 msg);++#endif /* __crcUSB5__HEADER_INCLUDED__ */+== END: "crcUSB5.h" ==================+== BEGIN: "crcUSB5_driver.c" ================+/* Example driver program for crcUSB5. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "crcUSB5.h"++int main(void)+{+  const SWord16 __result = crcUSB5(0xfedcU);++  printf("crcUSB5(0xfedcU) = 0x%04"PRIx16"U\n", __result);++  return 0;+}+== END: "crcUSB5_driver.c" ==================+== BEGIN: "crcUSB5.c" ================+/* File: "crcUSB5.c". Automatically generated by SBV. Do not edit! */++#include "crcUSB5.h"++SWord16 crcUSB5(const SWord16 msg)+{+  const SWord16 s0 = msg;+  const SBool   s1 = (SBool) ((s0 >> 10) & 1);+  const SBool   s3 = s1 != false;+  const SBool   s4 = (SBool) ((s0 >> 9) & 1);+  const SBool   s5 = false != s4;+  const SBool   s6 = (SBool) ((s0 >> 8) & 1);+  const SBool   s7 = false != s6;+  const SBool   s8 = (SBool) ((s0 >> 7) & 1);+  const SBool   s9 = false != s8;+  const SBool   s10 = (SBool) ((s0 >> 6) & 1);+  const SBool   s11 = false != s10;+  const SBool   s12 = (SBool) ((s0 >> 5) & 1);+  const SBool   s13 = false != s12;+  const SBool   s14 = (SBool) ((s0 >> 4) & 1);+  const SBool   s15 = false != s14;+  const SBool   s16 = (SBool) ((s0 >> 3) & 1);+  const SBool   s17 = false != s16;+  const SBool   s18 = (SBool) ((s0 >> 2) & 1);+  const SBool   s19 = false != s18;+  const SBool   s20 = (SBool) ((s0 >> 1) & 1);+  const SBool   s21 = false != s20;+  const SBool   s22 = (SBool) ((s0 >> 0) & 1);+  const SBool   s23 = false != s22;+  const SBool   s24 = !s9;+  const SBool   s25 = s3 ? s24 : s9;+  const SBool   s26 = !s11;+  const SBool   s27 = s5 ? s26 : s11;+  const SBool   s28 = !s13;+  const SBool   s29 = s3 ? s28 : s13;+  const SBool   s30 = !s29;+  const SBool   s31 = s7 ? s30 : s29;+  const SBool   s32 = !s15;+  const SBool   s33 = s5 ? s32 : s15;+  const SBool   s34 = !s33;+  const SBool   s35 = s25 ? s34 : s33;+  const SBool   s36 = !s17;+  const SBool   s37 = s7 ? s36 : s17;+  const SBool   s38 = !s37;+  const SBool   s39 = s27 ? s38 : s37;+  const SBool   s40 = !s19;+  const SBool   s41 = s25 ? s40 : s19;+  const SBool   s42 = !s41;+  const SBool   s43 = s31 ? s42 : s41;+  const SBool   s44 = !s21;+  const SBool   s45 = s27 ? s44 : s21;+  const SBool   s46 = !s45;+  const SBool   s47 = s35 ? s46 : s45;+  const SBool   s48 = !s23;+  const SBool   s49 = s31 ? s48 : s23;+  const SBool   s50 = !s49;+  const SBool   s51 = s39 ? s50 : s49;+  const SBool   s52 = !s35;+  const SBool   s53 = s43 ? s52 : s35;+  const SBool   s54 = !s39;+  const SBool   s55 = s47 ? s54 : s39;+  const SBool   s56 = !s43;+  const SBool   s57 = s51 ? s56 : s43;+  const SWord16 s60 = s51 ? 0x0001U : 0x0000U;+  const SWord16 s62 = s60 | 0x0002U;+  const SWord16 s63 = s47 ? s62 : s60;+  const SWord16 s65 = s63 | 0x0004U;+  const SWord16 s66 = s57 ? s65 : s63;+  const SWord16 s68 = s66 | 0x0008U;+  const SWord16 s69 = s55 ? s68 : s66;+  const SWord16 s71 = s69 | 0x0010U;+  const SWord16 s72 = s53 ? s71 : s69;+  const SWord16 s74 = s72 | 0x0020U;+  const SWord16 s75 = s23 ? s74 : s72;+  const SWord16 s77 = s75 | 0x0040U;+  const SWord16 s78 = s21 ? s77 : s75;+  const SWord16 s80 = s78 | 0x0080U;+  const SWord16 s81 = s19 ? s80 : s78;+  const SWord16 s83 = s81 | 0x0100U;+  const SWord16 s84 = s17 ? s83 : s81;+  const SWord16 s86 = s84 | 0x0200U;+  const SWord16 s87 = s15 ? s86 : s84;+  const SWord16 s89 = s87 | 0x0400U;+  const SWord16 s90 = s13 ? s89 : s87;+  const SWord16 s92 = s90 | 0x0800U;+  const SWord16 s93 = s11 ? s92 : s90;+  const SWord16 s95 = s93 | 0x1000U;+  const SWord16 s96 = s9 ? s95 : s93;+  const SWord16 s98 = s96 | 0x2000U;+  const SWord16 s99 = s7 ? s98 : s96;+  const SWord16 s101 = s99 | 0x4000U;+  const SWord16 s102 = s5 ? s101 : s99;+  const SWord16 s104 = s102 | 0x8000U;+  const SWord16 s105 = s3 ? s104 : s102;++  return s105;+}+== END: "crcUSB5.c" ==================
+ SBVTestSuite/GoldFiles/crcUSB5_2.gold view
@@ -0,0 +1,225 @@+== BEGIN: "Makefile" ================+# Makefile for crcUSB5. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: crcUSB5_driver++crcUSB5.o: crcUSB5.c crcUSB5.h+	${CC} ${CCFLAGS} -c $< -o $@++crcUSB5_driver.o: crcUSB5_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++crcUSB5_driver: crcUSB5.o crcUSB5_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f crcUSB5_driver+== END: "Makefile" ==================+== BEGIN: "crcUSB5.h" ================+/* Header file for crcUSB5. Automatically generated by SBV. Do not edit! */++#ifndef __crcUSB5__HEADER_INCLUDED__+#define __crcUSB5__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+SWord16 crcUSB5(const SWord16 msg);++#endif /* __crcUSB5__HEADER_INCLUDED__ */+== END: "crcUSB5.h" ==================+== BEGIN: "crcUSB5_driver.c" ================+/* Example driver program for crcUSB5. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "crcUSB5.h"++int main(void)+{+  const SWord16 __result = crcUSB5(0xfedcU);++  printf("crcUSB5(0xfedcU) = 0x%04"PRIx16"U\n", __result);++  return 0;+}+== END: "crcUSB5_driver.c" ==================+== BEGIN: "crcUSB5.c" ================+/* File: "crcUSB5.c". Automatically generated by SBV. Do not edit! */++#include "crcUSB5.h"++SWord16 crcUSB5(const SWord16 msg)+{+  const SWord16 s0 = msg;+  const SWord16 s1 = s0 << 5;+  const SBool   s2 = (SBool) ((s1 >> 15) & 1);+  const SBool   s4 = s2 != false;+  const SBool   s5 = (SBool) ((s1 >> 14) & 1);+  const SBool   s6 = false != s5;+  const SBool   s7 = (SBool) ((s1 >> 13) & 1);+  const SBool   s8 = false != s7;+  const SBool   s9 = (SBool) ((s1 >> 12) & 1);+  const SBool   s10 = false != s9;+  const SBool   s11 = !s10;+  const SBool   s12 = s4 ? s11 : s10;+  const SBool   s13 = (SBool) ((s1 >> 11) & 1);+  const SBool   s14 = false != s13;+  const SBool   s15 = !s14;+  const SBool   s16 = s6 ? s15 : s14;+  const SBool   s17 = (SBool) ((s1 >> 10) & 1);+  const SBool   s18 = false != s17;+  const SBool   s19 = !s18;+  const SBool   s20 = s4 ? s19 : s18;+  const SBool   s21 = !s20;+  const SBool   s22 = s8 ? s21 : s20;+  const SBool   s23 = (SBool) ((s1 >> 9) & 1);+  const SBool   s24 = false != s23;+  const SBool   s25 = !s24;+  const SBool   s26 = s6 ? s25 : s24;+  const SBool   s27 = !s26;+  const SBool   s28 = s12 ? s27 : s26;+  const SBool   s29 = (SBool) ((s1 >> 8) & 1);+  const SBool   s30 = false != s29;+  const SBool   s31 = !s30;+  const SBool   s32 = s8 ? s31 : s30;+  const SBool   s33 = !s32;+  const SBool   s34 = s16 ? s33 : s32;+  const SBool   s35 = (SBool) ((s1 >> 7) & 1);+  const SBool   s36 = false != s35;+  const SBool   s37 = !s36;+  const SBool   s38 = s12 ? s37 : s36;+  const SBool   s39 = !s38;+  const SBool   s40 = s22 ? s39 : s38;+  const SBool   s41 = (SBool) ((s1 >> 6) & 1);+  const SBool   s42 = false != s41;+  const SBool   s43 = !s42;+  const SBool   s44 = s16 ? s43 : s42;+  const SBool   s45 = !s44;+  const SBool   s46 = s28 ? s45 : s44;+  const SBool   s47 = (SBool) ((s1 >> 5) & 1);+  const SBool   s48 = false != s47;+  const SBool   s49 = !s48;+  const SBool   s50 = s22 ? s49 : s48;+  const SBool   s51 = !s50;+  const SBool   s52 = s34 ? s51 : s50;+  const SBool   s53 = !s4;+  const SBool   s54 = s4 ? s53 : s4;+  const SBool   s55 = !s6;+  const SBool   s56 = s6 ? s55 : s6;+  const SBool   s57 = !s8;+  const SBool   s58 = s8 ? s57 : s8;+  const SBool   s59 = !s12;+  const SBool   s60 = s12 ? s59 : s12;+  const SBool   s61 = !s16;+  const SBool   s62 = s16 ? s61 : s16;+  const SBool   s63 = !s22;+  const SBool   s64 = s22 ? s63 : s22;+  const SBool   s65 = !s28;+  const SBool   s66 = s28 ? s65 : s28;+  const SBool   s67 = !s34;+  const SBool   s68 = s34 ? s67 : s34;+  const SBool   s69 = !s40;+  const SBool   s70 = s40 ? s69 : s40;+  const SBool   s71 = !s46;+  const SBool   s72 = s46 ? s71 : s46;+  const SBool   s73 = !s52;+  const SBool   s74 = s52 ? s73 : s52;+  const SBool   s75 = (SBool) ((s1 >> 4) & 1);+  const SBool   s76 = false != s75;+  const SBool   s77 = !s76;+  const SBool   s78 = s28 ? s77 : s76;+  const SBool   s79 = !s78;+  const SBool   s80 = s40 ? s79 : s78;+  const SBool   s81 = (SBool) ((s1 >> 3) & 1);+  const SBool   s82 = false != s81;+  const SBool   s83 = !s82;+  const SBool   s84 = s34 ? s83 : s82;+  const SBool   s85 = !s84;+  const SBool   s86 = s46 ? s85 : s84;+  const SBool   s87 = (SBool) ((s1 >> 2) & 1);+  const SBool   s88 = false != s87;+  const SBool   s89 = !s88;+  const SBool   s90 = s40 ? s89 : s88;+  const SBool   s91 = !s90;+  const SBool   s92 = s52 ? s91 : s90;+  const SBool   s93 = (SBool) ((s1 >> 1) & 1);+  const SBool   s94 = false != s93;+  const SBool   s95 = !s94;+  const SBool   s96 = s46 ? s95 : s94;+  const SBool   s97 = (SBool) ((s1 >> 0) & 1);+  const SBool   s98 = false != s97;+  const SBool   s99 = !s98;+  const SBool   s100 = s52 ? s99 : s98;+  const SWord16 s103 = s100 ? 0x0001U : 0x0000U;+  const SWord16 s105 = s103 | 0x0002U;+  const SWord16 s106 = s96 ? s105 : s103;+  const SWord16 s108 = s106 | 0x0004U;+  const SWord16 s109 = s92 ? s108 : s106;+  const SWord16 s111 = s109 | 0x0008U;+  const SWord16 s112 = s86 ? s111 : s109;+  const SWord16 s114 = s112 | 0x0010U;+  const SWord16 s115 = s80 ? s114 : s112;+  const SWord16 s117 = s115 | 0x0020U;+  const SWord16 s118 = s74 ? s117 : s115;+  const SWord16 s120 = s118 | 0x0040U;+  const SWord16 s121 = s72 ? s120 : s118;+  const SWord16 s123 = s121 | 0x0080U;+  const SWord16 s124 = s70 ? s123 : s121;+  const SWord16 s126 = s124 | 0x0100U;+  const SWord16 s127 = s68 ? s126 : s124;+  const SWord16 s129 = s127 | 0x0200U;+  const SWord16 s130 = s66 ? s129 : s127;+  const SWord16 s132 = s130 | 0x0400U;+  const SWord16 s133 = s64 ? s132 : s130;+  const SWord16 s135 = s133 | 0x0800U;+  const SWord16 s136 = s62 ? s135 : s133;+  const SWord16 s138 = s136 | 0x1000U;+  const SWord16 s139 = s60 ? s138 : s136;+  const SWord16 s141 = s139 | 0x2000U;+  const SWord16 s142 = s58 ? s141 : s139;+  const SWord16 s144 = s142 | 0x4000U;+  const SWord16 s145 = s56 ? s144 : s142;+  const SWord16 s147 = s145 | 0x8000U;+  const SWord16 s148 = s54 ? s147 : s145;+  const SWord16 s149 = s1 | s148;++  return s149;+}+== END: "crcUSB5.c" ==================
+ SBVTestSuite/GoldFiles/dogCatMouse.gold view
@@ -0,0 +1,5 @@+Solution #1:+  dog   =  3 :: Integer+  cat   = 41 :: Integer+  mouse = 56 :: Integer+This is the only solution.
+ SBVTestSuite/GoldFiles/euler185.gold view
@@ -0,0 +1,18 @@+Solution #1:+  s0  = 4 :: Word8+  s1  = 6 :: Word8+  s2  = 4 :: Word8+  s3  = 0 :: Word8+  s4  = 2 :: Word8+  s5  = 6 :: Word8+  s6  = 1 :: Word8+  s7  = 5 :: Word8+  s8  = 7 :: Word8+  s9  = 1 :: Word8+  s10 = 8 :: Word8+  s11 = 4 :: Word8+  s12 = 9 :: Word8+  s13 = 5 :: Word8+  s14 = 3 :: Word8+  s15 = 3 :: Word8+This is the only solution.
+ SBVTestSuite/GoldFiles/fib1.gold view
@@ -0,0 +1,222 @@+== BEGIN: "Makefile" ================+# Makefile for fib1. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: fib1_driver++fib1.o: fib1.c fib1.h+	${CC} ${CCFLAGS} -c $< -o $@++fib1_driver.o: fib1_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++fib1_driver: fib1.o fib1_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f fib1_driver+== END: "Makefile" ==================+== BEGIN: "fib1.h" ================+/* Header file for fib1. Automatically generated by SBV. Do not edit! */++#ifndef __fib1__HEADER_INCLUDED__+#define __fib1__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+SWord64 fib1(const SWord64 n);++#endif /* __fib1__HEADER_INCLUDED__ */+== END: "fib1.h" ==================+== BEGIN: "fib1_driver.c" ================+/* Example driver program for fib1. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "fib1.h"++int main(void)+{+  const SWord64 __result = fib1(0x000000000000000cULL);++  printf("fib1(0x000000000000000cULL) = 0x%016"PRIx64"ULL\n", __result);++  return 0;+}+== END: "fib1_driver.c" ==================+== BEGIN: "fib1.c" ================+/* File: "fib1.c". Automatically generated by SBV. Do not edit! */++#include "fib1.h"++SWord64 fib1(const SWord64 n)+{+  const SWord64 s0 = n;+  const SBool   s2 = s0 == 0x0000000000000000ULL;+  const SBool   s4 = s0 == 0x0000000000000001ULL;+  const SBool   s6 = s0 == 0x0000000000000002ULL;+  const SBool   s8 = s0 == 0x0000000000000003ULL;+  const SBool   s10 = s0 == 0x0000000000000004ULL;+  const SBool   s12 = s0 == 0x0000000000000005ULL;+  const SBool   s14 = s0 == 0x0000000000000006ULL;+  const SBool   s17 = s0 == 0x0000000000000007ULL;+  const SBool   s19 = s0 == 0x0000000000000008ULL;+  const SBool   s22 = s0 == 0x0000000000000009ULL;+  const SBool   s25 = s0 == 0x000000000000000aULL;+  const SBool   s28 = s0 == 0x000000000000000bULL;+  const SBool   s31 = s0 == 0x000000000000000cULL;+  const SBool   s33 = s0 == 0x000000000000000dULL;+  const SBool   s36 = s0 == 0x000000000000000eULL;+  const SBool   s39 = s0 == 0x000000000000000fULL;+  const SBool   s42 = s0 == 0x0000000000000010ULL;+  const SBool   s45 = s0 == 0x0000000000000011ULL;+  const SBool   s48 = s0 == 0x0000000000000012ULL;+  const SBool   s51 = s0 == 0x0000000000000013ULL;+  const SBool   s54 = s0 == 0x0000000000000014ULL;+  const SBool   s56 = s0 == 0x0000000000000015ULL;+  const SBool   s59 = s0 == 0x0000000000000016ULL;+  const SBool   s62 = s0 == 0x0000000000000017ULL;+  const SBool   s65 = s0 == 0x0000000000000018ULL;+  const SBool   s68 = s0 == 0x0000000000000019ULL;+  const SBool   s71 = s0 == 0x000000000000001aULL;+  const SBool   s74 = s0 == 0x000000000000001bULL;+  const SBool   s77 = s0 == 0x000000000000001cULL;+  const SBool   s80 = s0 == 0x000000000000001dULL;+  const SBool   s83 = s0 == 0x000000000000001eULL;+  const SBool   s86 = s0 == 0x000000000000001fULL;+  const SBool   s89 = s0 == 0x0000000000000020ULL;+  const SBool   s92 = s0 == 0x0000000000000021ULL;+  const SBool   s94 = s0 == 0x0000000000000022ULL;+  const SBool   s97 = s0 == 0x0000000000000023ULL;+  const SBool   s100 = s0 == 0x0000000000000024ULL;+  const SBool   s103 = s0 == 0x0000000000000025ULL;+  const SBool   s106 = s0 == 0x0000000000000026ULL;+  const SBool   s109 = s0 == 0x0000000000000027ULL;+  const SBool   s112 = s0 == 0x0000000000000028ULL;+  const SBool   s115 = s0 == 0x0000000000000029ULL;+  const SBool   s118 = s0 == 0x000000000000002aULL;+  const SBool   s121 = s0 == 0x000000000000002bULL;+  const SBool   s124 = s0 == 0x000000000000002cULL;+  const SBool   s127 = s0 == 0x000000000000002dULL;+  const SBool   s130 = s0 == 0x000000000000002eULL;+  const SBool   s133 = s0 == 0x000000000000002fULL;+  const SBool   s136 = s0 == 0x0000000000000030ULL;+  const SBool   s139 = s0 == 0x0000000000000031ULL;+  const SBool   s142 = s0 == 0x0000000000000032ULL;+  const SBool   s145 = s0 == 0x0000000000000033ULL;+  const SBool   s148 = s0 == 0x0000000000000034ULL;+  const SBool   s151 = s0 == 0x0000000000000035ULL;+  const SBool   s154 = s0 == 0x0000000000000036ULL;+  const SBool   s156 = s0 == 0x0000000000000037ULL;+  const SBool   s159 = s0 == 0x0000000000000038ULL;+  const SBool   s162 = s0 == 0x0000000000000039ULL;+  const SBool   s165 = s0 == 0x000000000000003aULL;+  const SBool   s168 = s0 == 0x000000000000003bULL;+  const SBool   s171 = s0 == 0x000000000000003cULL;+  const SBool   s174 = s0 == 0x000000000000003dULL;+  const SBool   s177 = s0 == 0x000000000000003eULL;+  const SBool   s180 = s0 == 0x000000000000003fULL;+  const SWord64 s183 = s180 ? 0x000005f6c7b064e2ULL : 0x000009a661ca20bbULL;+  const SWord64 s184 = s177 ? 0x000003af9a19bbd9ULL : s183;+  const SWord64 s185 = s174 ? 0x000002472d96a909ULL : s184;+  const SWord64 s186 = s171 ? 0x000001686c8312d0ULL : s185;+  const SWord64 s187 = s168 ? 0x000000dec1139639ULL : s186;+  const SWord64 s188 = s165 ? 0x00000089ab6f7c97ULL : s187;+  const SWord64 s189 = s162 ? 0x0000005515a419a2ULL : s188;+  const SWord64 s190 = s159 ? 0x0000003495cb62f5ULL : s189;+  const SWord64 s191 = s156 ? 0x000000207fd8b6adULL : s190;+  const SWord64 s192 = s154 ? 0x0000001415f2ac48ULL : s191;+  const SWord64 s193 = s151 ? 0x0000000c69e60a65ULL : s192;+  const SWord64 s194 = s148 ? 0x00000007ac0ca1e3ULL : s193;+  const SWord64 s195 = s145 ? 0x00000004bdd96882ULL : s194;+  const SWord64 s196 = s142 ? 0x00000002ee333961ULL : s195;+  const SWord64 s197 = s139 ? 0x00000001cfa62f21ULL : s196;+  const SWord64 s198 = s136 ? 0x000000011e8d0a40ULL : s197;+  const SWord64 s199 = s133 ? 0x00000000b11924e1ULL : s198;+  const SWord64 s200 = s130 ? 0x000000006d73e55fULL : s199;+  const SWord64 s201 = s127 ? 0x0000000043a53f82ULL : s200;+  const SWord64 s202 = s124 ? 0x0000000029cea5ddULL : s201;+  const SWord64 s203 = s121 ? 0x0000000019d699a5ULL : s202;+  const SWord64 s204 = s118 ? 0x000000000ff80c38ULL : s203;+  const SWord64 s205 = s115 ? 0x0000000009de8d6dULL : s204;+  const SWord64 s206 = s112 ? 0x0000000006197ecbULL : s205;+  const SWord64 s207 = s109 ? 0x0000000003c50ea2ULL : s206;+  const SWord64 s208 = s106 ? 0x0000000002547029ULL : s207;+  const SWord64 s209 = s103 ? 0x0000000001709e79ULL : s208;+  const SWord64 s210 = s100 ? 0x0000000000e3d1b0ULL : s209;+  const SWord64 s211 = s97 ? 0x00000000008cccc9ULL : s210;+  const SWord64 s212 = s94 ? 0x00000000005704e7ULL : s211;+  const SWord64 s213 = s92 ? 0x000000000035c7e2ULL : s212;+  const SWord64 s214 = s89 ? 0x0000000000213d05ULL : s213;+  const SWord64 s215 = s86 ? 0x0000000000148addULL : s214;+  const SWord64 s216 = s83 ? 0x00000000000cb228ULL : s215;+  const SWord64 s217 = s80 ? 0x000000000007d8b5ULL : s216;+  const SWord64 s218 = s77 ? 0x000000000004d973ULL : s217;+  const SWord64 s219 = s74 ? 0x000000000002ff42ULL : s218;+  const SWord64 s220 = s71 ? 0x000000000001da31ULL : s219;+  const SWord64 s221 = s68 ? 0x0000000000012511ULL : s220;+  const SWord64 s222 = s65 ? 0x000000000000b520ULL : s221;+  const SWord64 s223 = s62 ? 0x0000000000006ff1ULL : s222;+  const SWord64 s224 = s59 ? 0x000000000000452fULL : s223;+  const SWord64 s225 = s56 ? 0x0000000000002ac2ULL : s224;+  const SWord64 s226 = s54 ? 0x0000000000001a6dULL : s225;+  const SWord64 s227 = s51 ? 0x0000000000001055ULL : s226;+  const SWord64 s228 = s48 ? 0x0000000000000a18ULL : s227;+  const SWord64 s229 = s45 ? 0x000000000000063dULL : s228;+  const SWord64 s230 = s42 ? 0x00000000000003dbULL : s229;+  const SWord64 s231 = s39 ? 0x0000000000000262ULL : s230;+  const SWord64 s232 = s36 ? 0x0000000000000179ULL : s231;+  const SWord64 s233 = s33 ? 0x00000000000000e9ULL : s232;+  const SWord64 s234 = s31 ? 0x0000000000000090ULL : s233;+  const SWord64 s235 = s28 ? 0x0000000000000059ULL : s234;+  const SWord64 s236 = s25 ? 0x0000000000000037ULL : s235;+  const SWord64 s237 = s22 ? 0x0000000000000022ULL : s236;+  const SWord64 s238 = s19 ? 0x0000000000000015ULL : s237;+  const SWord64 s239 = s17 ? 0x000000000000000dULL : s238;+  const SWord64 s240 = s14 ? 0x0000000000000008ULL : s239;+  const SWord64 s241 = s12 ? 0x0000000000000005ULL : s240;+  const SWord64 s242 = s10 ? 0x0000000000000003ULL : s241;+  const SWord64 s243 = s8 ? 0x0000000000000002ULL : s242;+  const SWord64 s244 = s6 ? 0x0000000000000001ULL : s243;+  const SWord64 s245 = s4 ? 0x0000000000000001ULL : s244;+  const SWord64 s246 = s2 ? 0x0000000000000000ULL : s245;++  return s246;+}+== END: "fib1.c" ==================
+ SBVTestSuite/GoldFiles/fib2.gold view
@@ -0,0 +1,129 @@+== BEGIN: "Makefile" ================+# Makefile for fib2. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: fib2_driver++fib2.o: fib2.c fib2.h+	${CC} ${CCFLAGS} -c $< -o $@++fib2_driver.o: fib2_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++fib2_driver: fib2.o fib2_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f fib2_driver+== END: "Makefile" ==================+== BEGIN: "fib2.h" ================+/* Header file for fib2. Automatically generated by SBV. Do not edit! */++#ifndef __fib2__HEADER_INCLUDED__+#define __fib2__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+SWord64 fib2(const SWord64 n);++#endif /* __fib2__HEADER_INCLUDED__ */+== END: "fib2.h" ==================+== BEGIN: "fib2_driver.c" ================+/* Example driver program for fib2. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "fib2.h"++int main(void)+{+  const SWord64 __result = fib2(0x0000000000000014ULL);++  printf("fib2(0x0000000000000014ULL) = 0x%016"PRIx64"ULL\n", __result);++  return 0;+}+== END: "fib2_driver.c" ==================+== BEGIN: "fib2.c" ================+/* File: "fib2.c". Automatically generated by SBV. Do not edit! */++#include "fib2.h"++SWord64 fib2(const SWord64 n)+{+  const SWord64 s0 = n;+  static const SWord64 table0[] = {+      0x0000000000000000ULL, 0x0000000000000001ULL,+      0x0000000000000001ULL, 0x0000000000000002ULL,+      0x0000000000000003ULL, 0x0000000000000005ULL,+      0x0000000000000008ULL, 0x000000000000000dULL,+      0x0000000000000015ULL, 0x0000000000000022ULL,+      0x0000000000000037ULL, 0x0000000000000059ULL,+      0x0000000000000090ULL, 0x00000000000000e9ULL,+      0x0000000000000179ULL, 0x0000000000000262ULL,+      0x00000000000003dbULL, 0x000000000000063dULL,+      0x0000000000000a18ULL, 0x0000000000001055ULL,+      0x0000000000001a6dULL, 0x0000000000002ac2ULL,+      0x000000000000452fULL, 0x0000000000006ff1ULL,+      0x000000000000b520ULL, 0x0000000000012511ULL,+      0x000000000001da31ULL, 0x000000000002ff42ULL,+      0x000000000004d973ULL, 0x000000000007d8b5ULL,+      0x00000000000cb228ULL, 0x0000000000148addULL,+      0x0000000000213d05ULL, 0x000000000035c7e2ULL,+      0x00000000005704e7ULL, 0x00000000008cccc9ULL,+      0x0000000000e3d1b0ULL, 0x0000000001709e79ULL,+      0x0000000002547029ULL, 0x0000000003c50ea2ULL,+      0x0000000006197ecbULL, 0x0000000009de8d6dULL,+      0x000000000ff80c38ULL, 0x0000000019d699a5ULL,+      0x0000000029cea5ddULL, 0x0000000043a53f82ULL,+      0x000000006d73e55fULL, 0x00000000b11924e1ULL,+      0x000000011e8d0a40ULL, 0x00000001cfa62f21ULL,+      0x00000002ee333961ULL, 0x00000004bdd96882ULL,+      0x00000007ac0ca1e3ULL, 0x0000000c69e60a65ULL,+      0x0000001415f2ac48ULL, 0x000000207fd8b6adULL,+      0x0000003495cb62f5ULL, 0x0000005515a419a2ULL,+      0x00000089ab6f7c97ULL, 0x000000dec1139639ULL,+      0x000001686c8312d0ULL, 0x000002472d96a909ULL,+      0x000003af9a19bbd9ULL, 0x000005f6c7b064e2ULL, 0x000009a661ca20bbULL+  };+  const SWord64 s65 = s0 >= 65 ? 0x0000000000000000ULL : table0[s0];++  return s65;+}+== END: "fib2.c" ==================
+ SBVTestSuite/GoldFiles/floats_cgen.gold view
@@ -0,0 +1,2869 @@+== BEGIN: "toFP_Int8_ToFloat.c" ================+/* File: "toFP_Int8_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Int8_ToFloat(const SInt8 a)+{+  const SInt8  s0 = a;+  const SFloat s2 = (SFloat) s0;++  return s2;+}+== END: "toFP_Int8_ToFloat.c" ==================+== BEGIN: "toFP_Int16_ToFloat.c" ================+/* File: "toFP_Int16_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Int16_ToFloat(const SInt16 a)+{+  const SInt16 s0 = a;+  const SFloat s2 = (SFloat) s0;++  return s2;+}+== END: "toFP_Int16_ToFloat.c" ==================+== BEGIN: "toFP_Int32_ToFloat.c" ================+/* File: "toFP_Int32_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Int32_ToFloat(const SInt32 a)+{+  const SInt32 s0 = a;+  const SFloat s2 = (SFloat) s0;++  return s2;+}+== END: "toFP_Int32_ToFloat.c" ==================+== BEGIN: "toFP_Int64_ToFloat.c" ================+/* File: "toFP_Int64_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Int64_ToFloat(const SInt64 a)+{+  const SInt64 s0 = a;+  const SFloat s2 = (SFloat) s0;++  return s2;+}+== END: "toFP_Int64_ToFloat.c" ==================+== BEGIN: "toFP_Word8_ToFloat.c" ================+/* File: "toFP_Word8_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Word8_ToFloat(const SWord8 a)+{+  const SWord8 s0 = a;+  const SFloat s2 = (SFloat) s0;++  return s2;+}+== END: "toFP_Word8_ToFloat.c" ==================+== BEGIN: "toFP_Word16_ToFloat.c" ================+/* File: "toFP_Word16_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Word16_ToFloat(const SWord16 a)+{+  const SWord16 s0 = a;+  const SFloat  s2 = (SFloat) s0;++  return s2;+}+== END: "toFP_Word16_ToFloat.c" ==================+== BEGIN: "toFP_Word32_ToFloat.c" ================+/* File: "toFP_Word32_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Word32_ToFloat(const SWord32 a)+{+  const SWord32 s0 = a;+  const SFloat  s2 = (SFloat) s0;++  return s2;+}+== END: "toFP_Word32_ToFloat.c" ==================+== BEGIN: "toFP_Word64_ToFloat.c" ================+/* File: "toFP_Word64_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Word64_ToFloat(const SWord64 a)+{+  const SWord64 s0 = a;+  const SFloat  s2 = (SFloat) s0;++  return s2;+}+== END: "toFP_Word64_ToFloat.c" ==================+== BEGIN: "toFP_Float_ToFloat.c" ================+/* File: "toFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Float_ToFloat(const SFloat a)+{+  const SFloat s0 = a;+  return s0;+}+== END: "toFP_Float_ToFloat.c" ==================+== BEGIN: "toFP_Double_ToFloat.c" ================+/* File: "toFP_Double_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Double_ToFloat(const SDouble a)+{+  const SDouble s0 = a;+  const SFloat  s2 = (SFloat) s0;++  return s2;+}+== END: "toFP_Double_ToFloat.c" ==================+== BEGIN: "toFP_Integer_ToFloat.c" ================+/* File: "toFP_Integer_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Integer_ToFloat(const SInteger a)+{+  const SInteger s0 = a;+  const SFloat   s2 = (SFloat) s0;++  return s2;+}+== END: "toFP_Integer_ToFloat.c" ==================+== BEGIN: "toFP_Real_ToFloat.c" ================+/* File: "toFP_Real_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat toFP_Real_ToFloat(const SReal a)+{+  const SReal  s0 = a;+  const SFloat s2 = (SFloat) s0;++  return s2;+}+== END: "toFP_Real_ToFloat.c" ==================+== BEGIN: "toFP_Int8_ToDouble.c" ================+/* File: "toFP_Int8_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Int8_ToDouble(const SInt8 a)+{+  const SInt8   s0 = a;+  const SDouble s2 = (SDouble) s0;++  return s2;+}+== END: "toFP_Int8_ToDouble.c" ==================+== BEGIN: "toFP_Int16_ToDouble.c" ================+/* File: "toFP_Int16_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Int16_ToDouble(const SInt16 a)+{+  const SInt16  s0 = a;+  const SDouble s2 = (SDouble) s0;++  return s2;+}+== END: "toFP_Int16_ToDouble.c" ==================+== BEGIN: "toFP_Int32_ToDouble.c" ================+/* File: "toFP_Int32_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Int32_ToDouble(const SInt32 a)+{+  const SInt32  s0 = a;+  const SDouble s2 = (SDouble) s0;++  return s2;+}+== END: "toFP_Int32_ToDouble.c" ==================+== BEGIN: "toFP_Int64_ToDouble.c" ================+/* File: "toFP_Int64_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Int64_ToDouble(const SInt64 a)+{+  const SInt64  s0 = a;+  const SDouble s2 = (SDouble) s0;++  return s2;+}+== END: "toFP_Int64_ToDouble.c" ==================+== BEGIN: "toFP_Word8_ToDouble.c" ================+/* File: "toFP_Word8_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Word8_ToDouble(const SWord8 a)+{+  const SWord8  s0 = a;+  const SDouble s2 = (SDouble) s0;++  return s2;+}+== END: "toFP_Word8_ToDouble.c" ==================+== BEGIN: "toFP_Word16_ToDouble.c" ================+/* File: "toFP_Word16_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Word16_ToDouble(const SWord16 a)+{+  const SWord16 s0 = a;+  const SDouble s2 = (SDouble) s0;++  return s2;+}+== END: "toFP_Word16_ToDouble.c" ==================+== BEGIN: "toFP_Word32_ToDouble.c" ================+/* File: "toFP_Word32_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Word32_ToDouble(const SWord32 a)+{+  const SWord32 s0 = a;+  const SDouble s2 = (SDouble) s0;++  return s2;+}+== END: "toFP_Word32_ToDouble.c" ==================+== BEGIN: "toFP_Word64_ToDouble.c" ================+/* File: "toFP_Word64_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Word64_ToDouble(const SWord64 a)+{+  const SWord64 s0 = a;+  const SDouble s2 = (SDouble) s0;++  return s2;+}+== END: "toFP_Word64_ToDouble.c" ==================+== BEGIN: "toFP_Float_ToDouble.c" ================+/* File: "toFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Float_ToDouble(const SFloat a)+{+  const SFloat  s0 = a;+  const SDouble s2 = (SDouble) s0;++  return s2;+}+== END: "toFP_Float_ToDouble.c" ==================+== BEGIN: "toFP_Double_ToDouble.c" ================+/* File: "toFP_Double_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Double_ToDouble(const SDouble a)+{+  const SDouble s0 = a;+  return s0;+}+== END: "toFP_Double_ToDouble.c" ==================+== BEGIN: "toFP_Integer_ToDouble.c" ================+/* File: "toFP_Integer_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Integer_ToDouble(const SInteger a)+{+  const SInteger s0 = a;+  const SDouble  s2 = (SDouble) s0;++  return s2;+}+== END: "toFP_Integer_ToDouble.c" ==================+== BEGIN: "toFP_Real_ToDouble.c" ================+/* File: "toFP_Real_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble toFP_Real_ToDouble(const SReal a)+{+  const SReal   s0 = a;+  const SDouble s2 = (SDouble) s0;++  return s2;+}+== END: "toFP_Real_ToDouble.c" ==================+== BEGIN: "fromFP_Float_ToInt8.c" ================+/* File: "fromFP_Float_ToInt8.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SInt8 fromFP_Float_ToInt8(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = isnan(s0);+  const SBool  s2 = isinf(s0);+  const SBool  s3 = s1 || s2;+  const SBool  s4 = !s3;+  const SInt8  s6 = (SInt8) s0;+  const SInt8  s8 = s4 ? s6 : 0;++  return s8;+}+== END: "fromFP_Float_ToInt8.c" ==================+== BEGIN: "fromFP_Float_ToInt16.c" ================+/* File: "fromFP_Float_ToInt16.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SInt16 fromFP_Float_ToInt16(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = isnan(s0);+  const SBool  s2 = isinf(s0);+  const SBool  s3 = s1 || s2;+  const SBool  s4 = !s3;+  const SInt16 s6 = (SInt16) s0;+  const SInt16 s8 = s4 ? s6 : 0x0000;++  return s8;+}+== END: "fromFP_Float_ToInt16.c" ==================+== BEGIN: "fromFP_Float_ToInt32.c" ================+/* File: "fromFP_Float_ToInt32.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SInt32 fromFP_Float_ToInt32(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = isnan(s0);+  const SBool  s2 = isinf(s0);+  const SBool  s3 = s1 || s2;+  const SBool  s4 = !s3;+  const SInt32 s6 = (SInt32) s0;+  const SInt32 s8 = s4 ? s6 : 0x00000000L;++  return s8;+}+== END: "fromFP_Float_ToInt32.c" ==================+== BEGIN: "fromFP_Float_ToInt64.c" ================+/* File: "fromFP_Float_ToInt64.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SInt64 fromFP_Float_ToInt64(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = isnan(s0);+  const SBool  s2 = isinf(s0);+  const SBool  s3 = s1 || s2;+  const SBool  s4 = !s3;+  const SInt64 s6 = (SInt64) s0;+  const SInt64 s8 = s4 ? s6 : 0x0000000000000000LL;++  return s8;+}+== END: "fromFP_Float_ToInt64.c" ==================+== BEGIN: "fromFP_Float_ToWord8.c" ================+/* File: "fromFP_Float_ToWord8.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SWord8 fromFP_Float_ToWord8(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = isnan(s0);+  const SBool  s2 = isinf(s0);+  const SBool  s3 = s1 || s2;+  const SBool  s4 = !s3;+  const SWord8 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord8) fabsf(s0))) : ((SWord8) s0);+  const SWord8 s8 = s4 ? s6 : 0;++  return s8;+}+== END: "fromFP_Float_ToWord8.c" ==================+== BEGIN: "fromFP_Float_ToWord16.c" ================+/* File: "fromFP_Float_ToWord16.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SWord16 fromFP_Float_ToWord16(const SFloat a)+{+  const SFloat  s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SWord16 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord16) fabsf(s0))) : ((SWord16) s0);+  const SWord16 s8 = s4 ? s6 : 0x0000U;++  return s8;+}+== END: "fromFP_Float_ToWord16.c" ==================+== BEGIN: "fromFP_Float_ToWord32.c" ================+/* File: "fromFP_Float_ToWord32.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SWord32 fromFP_Float_ToWord32(const SFloat a)+{+  const SFloat  s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SWord32 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord32) fabsf(s0))) : ((SWord32) s0);+  const SWord32 s8 = s4 ? s6 : 0x00000000UL;++  return s8;+}+== END: "fromFP_Float_ToWord32.c" ==================+== BEGIN: "fromFP_Float_ToWord64.c" ================+/* File: "fromFP_Float_ToWord64.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SWord64 fromFP_Float_ToWord64(const SFloat a)+{+  const SFloat  s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SWord64 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord64) fabsf(s0))) : ((SWord64) s0);+  const SWord64 s8 = s4 ? s6 : 0x0000000000000000ULL;++  return s8;+}+== END: "fromFP_Float_ToWord64.c" ==================+== BEGIN: "fromFP_Float_ToFloat.c" ================+/* File: "fromFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat fromFP_Float_ToFloat(const SFloat a)+{+  const SFloat s0 = a;+  return s0;+}+== END: "fromFP_Float_ToFloat.c" ==================+== BEGIN: "fromFP_Float_ToDouble.c" ================+/* File: "fromFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble fromFP_Float_ToDouble(const SFloat a)+{+  const SFloat  s0 = a;+  const SDouble s2 = (SDouble) s0;++  return s2;+}+== END: "fromFP_Float_ToDouble.c" ==================+== BEGIN: "fromFP_Float_ToInteger.c" ================+/* File: "fromFP_Float_ToInteger.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SInteger fromFP_Float_ToInteger(const SFloat a)+{+  const SFloat   s0 = a;+  const SBool    s1 = isnan(s0);+  const SBool    s2 = isinf(s0);+  const SBool    s3 = s1 || s2;+  const SBool    s4 = !s3;+  const SInteger s6 = (SInteger) s0;+  const SInteger s8 = s4 ? s6 : 0x0000000000000000LL;++  return s8;+}+== END: "fromFP_Float_ToInteger.c" ==================+== BEGIN: "fromFP_Float_ToReal.c" ================+/* File: "fromFP_Float_ToReal.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SReal fromFP_Float_ToReal(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = isnan(s0);+  const SBool  s2 = isinf(s0);+  const SBool  s3 = s1 || s2;+  const SBool  s4 = !s3;+  const SReal  s6 = (SReal) s0;+  const SReal  s8 = s4 ? s6 : 0.0L;++  return s8;+}+== END: "fromFP_Float_ToReal.c" ==================+== BEGIN: "fromFP_DoubleTo_Int8.c" ================+/* File: "fromFP_DoubleTo_Int8.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SInt8 fromFP_DoubleTo_Int8(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SInt8   s6 = (SInt8) s0;+  const SInt8   s8 = s4 ? s6 : 0;++  return s8;+}+== END: "fromFP_DoubleTo_Int8.c" ==================+== BEGIN: "fromFP_DoubleTo_Int16.c" ================+/* File: "fromFP_DoubleTo_Int16.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SInt16 fromFP_DoubleTo_Int16(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SInt16  s6 = (SInt16) s0;+  const SInt16  s8 = s4 ? s6 : 0x0000;++  return s8;+}+== END: "fromFP_DoubleTo_Int16.c" ==================+== BEGIN: "fromFP_DoubleTo_Int32.c" ================+/* File: "fromFP_DoubleTo_Int32.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SInt32 fromFP_DoubleTo_Int32(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SInt32  s6 = (SInt32) s0;+  const SInt32  s8 = s4 ? s6 : 0x00000000L;++  return s8;+}+== END: "fromFP_DoubleTo_Int32.c" ==================+== BEGIN: "fromFP_DoubleTo_Int64.c" ================+/* File: "fromFP_DoubleTo_Int64.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SInt64 fromFP_DoubleTo_Int64(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SInt64  s6 = (SInt64) s0;+  const SInt64  s8 = s4 ? s6 : 0x0000000000000000LL;++  return s8;+}+== END: "fromFP_DoubleTo_Int64.c" ==================+== BEGIN: "fromFP_DoubleTo_Word8.c" ================+/* File: "fromFP_DoubleTo_Word8.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SWord8 fromFP_DoubleTo_Word8(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SWord8  s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord8) fabs(s0))) : ((SWord8) s0);+  const SWord8  s8 = s4 ? s6 : 0;++  return s8;+}+== END: "fromFP_DoubleTo_Word8.c" ==================+== BEGIN: "fromFP_DoubleTo_Word16.c" ================+/* File: "fromFP_DoubleTo_Word16.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SWord16 fromFP_DoubleTo_Word16(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SWord16 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord16) fabs(s0))) : ((SWord16) s0);+  const SWord16 s8 = s4 ? s6 : 0x0000U;++  return s8;+}+== END: "fromFP_DoubleTo_Word16.c" ==================+== BEGIN: "fromFP_DoubleTo_Word32.c" ================+/* File: "fromFP_DoubleTo_Word32.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SWord32 fromFP_DoubleTo_Word32(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SWord32 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord32) fabs(s0))) : ((SWord32) s0);+  const SWord32 s8 = s4 ? s6 : 0x00000000UL;++  return s8;+}+== END: "fromFP_DoubleTo_Word32.c" ==================+== BEGIN: "fromFP_DoubleTo_Word64.c" ================+/* File: "fromFP_DoubleTo_Word64.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SWord64 fromFP_DoubleTo_Word64(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SWord64 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord64) fabs(s0))) : ((SWord64) s0);+  const SWord64 s8 = s4 ? s6 : 0x0000000000000000ULL;++  return s8;+}+== END: "fromFP_DoubleTo_Word64.c" ==================+== BEGIN: "fromFP_DoubleTo_Float.c" ================+/* File: "fromFP_DoubleTo_Float.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat fromFP_DoubleTo_Float(const SDouble a)+{+  const SDouble s0 = a;+  const SFloat  s2 = (SFloat) s0;++  return s2;+}+== END: "fromFP_DoubleTo_Float.c" ==================+== BEGIN: "fromFP_DoubleTo_Double.c" ================+/* File: "fromFP_DoubleTo_Double.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble fromFP_DoubleTo_Double(const SDouble a)+{+  const SDouble s0 = a;+  return s0;+}+== END: "fromFP_DoubleTo_Double.c" ==================+== BEGIN: "fromFP_DoubleTo_Integer.c" ================+/* File: "fromFP_DoubleTo_Integer.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SInteger fromFP_DoubleTo_Integer(const SDouble a)+{+  const SDouble  s0 = a;+  const SBool    s1 = isnan(s0);+  const SBool    s2 = isinf(s0);+  const SBool    s3 = s1 || s2;+  const SBool    s4 = !s3;+  const SInteger s6 = (SInteger) s0;+  const SInteger s8 = s4 ? s6 : 0x0000000000000000LL;++  return s8;+}+== END: "fromFP_DoubleTo_Integer.c" ==================+== BEGIN: "fromFP_DoubleTo_Real.c" ================+/* File: "fromFP_DoubleTo_Real.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SReal fromFP_DoubleTo_Real(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isnan(s0);+  const SBool   s2 = isinf(s0);+  const SBool   s3 = s1 || s2;+  const SBool   s4 = !s3;+  const SReal   s6 = (SReal) s0;+  const SReal   s8 = s4 ? s6 : 0.0L;++  return s8;+}+== END: "fromFP_DoubleTo_Real.c" ==================+== BEGIN: "fromFP_SWord32_SFloat.c" ================+/* File: "fromFP_SWord32_SFloat.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat fromFP_SWord32_SFloat(const SWord32 a)+{+  const SWord32 s0 = a;+        SFloat  s1; memcpy(&s1, &s0, sizeof(SFloat));++  return s1;+}+== END: "fromFP_SWord32_SFloat.c" ==================+== BEGIN: "fromFP_SWord64_SDouble.c" ================+/* File: "fromFP_SWord64_SDouble.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble fromFP_SWord64_SDouble(const SWord64 a)+{+  const SWord64 s0 = a;+        SDouble s1; memcpy(&s1, &s0, sizeof(SDouble));++  return s1;+}+== END: "fromFP_SWord64_SDouble.c" ==================+== BEGIN: "fromFP_SFloat_SWord32.c" ================+/* File: "fromFP_SFloat_SWord32.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SWord32 fromFP_SFloat_SWord32(const SFloat a)+{+  const SFloat  s0 = a;+        SWord32 s1; memcpy(&s1, &s0, sizeof(SWord32));++  return s1;+}+== END: "fromFP_SFloat_SWord32.c" ==================+== BEGIN: "fromFP_SDouble_SWord64.c" ================+/* File: "fromFP_SDouble_SWord64.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SWord64 fromFP_SDouble_SWord64(const SDouble a)+{+  const SDouble s0 = a;+        SWord64 s1; memcpy(&s1, &s0, sizeof(SWord64));++  return s1;+}+== END: "fromFP_SDouble_SWord64.c" ==================+== BEGIN: "f_FP_Abs.c" ================+/* File: "f_FP_Abs.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_Abs(const SFloat a)+{+  const SFloat s0 = a;+  const SFloat s1 = fabsf(s0);++  return s1;+}+== END: "f_FP_Abs.c" ==================+== BEGIN: "d_FP_Abs.c" ================+/* File: "d_FP_Abs.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_Abs(const SDouble a)+{+  const SDouble s0 = a;+  const SDouble s1 = fabs(s0);++  return s1;+}+== END: "d_FP_Abs.c" ==================+== BEGIN: "f_FP_Neg.c" ================+/* File: "f_FP_Neg.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_Neg(const SFloat a)+{+  const SFloat s0 = a;+  const SFloat s1 = (- s0);++  return s1;+}+== END: "f_FP_Neg.c" ==================+== BEGIN: "d_FP_Neg.c" ================+/* File: "d_FP_Neg.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_Neg(const SDouble a)+{+  const SDouble s0 = a;+  const SDouble s1 = (- s0);++  return s1;+}+== END: "d_FP_Neg.c" ==================+== BEGIN: "f_FP_Add.c" ================+/* File: "f_FP_Add.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_Add(const SFloat a, const SFloat b)+{+  const SFloat s0 = a;+  const SFloat s1 = b;+  const SFloat s3 = s0 + s1;++  return s3;+}+== END: "f_FP_Add.c" ==================+== BEGIN: "d_FP_Add.c" ================+/* File: "d_FP_Add.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_Add(const SDouble a, const SDouble b)+{+  const SDouble s0 = a;+  const SDouble s1 = b;+  const SDouble s3 = s0 + s1;++  return s3;+}+== END: "d_FP_Add.c" ==================+== BEGIN: "f_FP_Sub.c" ================+/* File: "f_FP_Sub.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_Sub(const SFloat a, const SFloat b)+{+  const SFloat s0 = a;+  const SFloat s1 = b;+  const SFloat s3 = s0 - s1;++  return s3;+}+== END: "f_FP_Sub.c" ==================+== BEGIN: "d_FP_Sub.c" ================+/* File: "d_FP_Sub.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_Sub(const SDouble a, const SDouble b)+{+  const SDouble s0 = a;+  const SDouble s1 = b;+  const SDouble s3 = s0 - s1;++  return s3;+}+== END: "d_FP_Sub.c" ==================+== BEGIN: "f_FP_Mul.c" ================+/* File: "f_FP_Mul.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_Mul(const SFloat a, const SFloat b)+{+  const SFloat s0 = a;+  const SFloat s1 = b;+  const SFloat s3 = s0 * s1;++  return s3;+}+== END: "f_FP_Mul.c" ==================+== BEGIN: "d_FP_Mul.c" ================+/* File: "d_FP_Mul.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_Mul(const SDouble a, const SDouble b)+{+  const SDouble s0 = a;+  const SDouble s1 = b;+  const SDouble s3 = s0 * s1;++  return s3;+}+== END: "d_FP_Mul.c" ==================+== BEGIN: "f_FP_Div.c" ================+/* File: "f_FP_Div.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_Div(const SFloat a, const SFloat b)+{+  const SFloat s0 = a;+  const SFloat s1 = b;+  const SFloat s3 = s0 / s1;++  return s3;+}+== END: "f_FP_Div.c" ==================+== BEGIN: "d_FP_Div.c" ================+/* File: "d_FP_Div.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_Div(const SDouble a, const SDouble b)+{+  const SDouble s0 = a;+  const SDouble s1 = b;+  const SDouble s3 = s0 / s1;++  return s3;+}+== END: "d_FP_Div.c" ==================+== BEGIN: "f_FP_FMA.c" ================+/* File: "f_FP_FMA.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_FMA(const SFloat a, const SFloat b, const SFloat c)+{+  const SFloat s0 = a;+  const SFloat s1 = b;+  const SFloat s2 = c;+  const SFloat s4 = fmaf(s0, s1, s2);++  return s4;+}+== END: "f_FP_FMA.c" ==================+== BEGIN: "d_FP_FMA.c" ================+/* File: "d_FP_FMA.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_FMA(const SDouble a, const SDouble b, const SDouble c)+{+  const SDouble s0 = a;+  const SDouble s1 = b;+  const SDouble s2 = c;+  const SDouble s4 = fma(s0, s1, s2);++  return s4;+}+== END: "d_FP_FMA.c" ==================+== BEGIN: "f_FP_Sqrt.c" ================+/* File: "f_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_Sqrt(const SFloat a)+{+  const SFloat s0 = a;+  const SFloat s2 = sqrtf(s0);++  return s2;+}+== END: "f_FP_Sqrt.c" ==================+== BEGIN: "d_FP_Sqrt.c" ================+/* File: "d_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_Sqrt(const SDouble a)+{+  const SDouble s0 = a;+  const SDouble s2 = sqrt(s0);++  return s2;+}+== END: "d_FP_Sqrt.c" ==================+== BEGIN: "f_FP_Rem.c" ================+/* File: "f_FP_Rem.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_Rem(const SFloat a, const SFloat b)+{+  const SFloat s0 = a;+  const SFloat s1 = b;+  const SFloat s2 = fmodf(s0, s1);++  return s2;+}+== END: "f_FP_Rem.c" ==================+== BEGIN: "d_FP_Rem.c" ================+/* File: "d_FP_Rem.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_Rem(const SDouble a, const SDouble b)+{+  const SDouble s0 = a;+  const SDouble s1 = b;+  const SDouble s2 = fmod(s0, s1);++  return s2;+}+== END: "d_FP_Rem.c" ==================+== BEGIN: "f_FP_RoundToIntegral.c" ================+/* File: "f_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_RoundToIntegral(const SFloat a)+{+  const SFloat s0 = a;+  const SFloat s2 = rintf(s0);++  return s2;+}+== END: "f_FP_RoundToIntegral.c" ==================+== BEGIN: "d_FP_RoundToIntegral.c" ================+/* File: "d_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_RoundToIntegral(const SDouble a)+{+  const SDouble s0 = a;+  const SDouble s2 = rint(s0);++  return s2;+}+== END: "d_FP_RoundToIntegral.c" ==================+== BEGIN: "f_FP_Min.c" ================+/* File: "f_FP_Min.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_Min(const SFloat a, const SFloat b)+{+  const SFloat s0 = a;+  const SFloat s1 = b;+  const SFloat s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0F : fminf(s0,+                                                                                                                                s1);++  return s2;+}+== END: "f_FP_Min.c" ==================+== BEGIN: "d_FP_Min.c" ================+/* File: "d_FP_Min.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_Min(const SDouble a, const SDouble b)+{+  const SDouble s0 = a;+  const SDouble s1 = b;+  const SDouble s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0 : fmin(s0,+                                                                                                                               s1);++  return s2;+}+== END: "d_FP_Min.c" ==================+== BEGIN: "f_FP_Max.c" ================+/* File: "f_FP_Max.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SFloat f_FP_Max(const SFloat a, const SFloat b)+{+  const SFloat s0 = a;+  const SFloat s1 = b;+  const SFloat s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0F : fmaxf(s0,+                                                                                                                                s1);++  return s2;+}+== END: "f_FP_Max.c" ==================+== BEGIN: "d_FP_Max.c" ================+/* File: "d_FP_Max.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SDouble d_FP_Max(const SDouble a, const SDouble b)+{+  const SDouble s0 = a;+  const SDouble s1 = b;+  const SDouble s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0 : fmax(s0,+                                                                                                                               s1);++  return s2;+}+== END: "d_FP_Max.c" ==================+== BEGIN: "f_FP_IsEqualObject.c" ================+/* File: "f_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool f_FP_IsEqualObject(const SFloat a, const SFloat b)+{+  const SFloat s0 = a;+  const SFloat s1 = b;+  const SBool  s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1);++  return s2;+}+== END: "f_FP_IsEqualObject.c" ==================+== BEGIN: "d_FP_IsEqualObject.c" ================+/* File: "d_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool d_FP_IsEqualObject(const SDouble a, const SDouble b)+{+  const SDouble s0 = a;+  const SDouble s1 = b;+  const SBool   s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1);++  return s2;+}+== END: "d_FP_IsEqualObject.c" ==================+== BEGIN: "f_FP_IsNormal.c" ================+/* File: "f_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool f_FP_IsNormal(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = isnormal(s0);++  return s1;+}+== END: "f_FP_IsNormal.c" ==================+== BEGIN: "d_FP_IsNormal.c" ================+/* File: "d_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool d_FP_IsNormal(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isnormal(s0);++  return s1;+}+== END: "d_FP_IsNormal.c" ==================+== BEGIN: "f_FP_IsZero.c" ================+/* File: "f_FP_IsZero.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool f_FP_IsZero(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = FP_ZERO == fpclassify(s0);++  return s1;+}+== END: "f_FP_IsZero.c" ==================+== BEGIN: "d_FP_IsZero.c" ================+/* File: "d_FP_IsZero.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool d_FP_IsZero(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = FP_ZERO == fpclassify(s0);++  return s1;+}+== END: "d_FP_IsZero.c" ==================+== BEGIN: "f_FP_IsSubnormal.c" ================+/* File: "f_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool f_FP_IsSubnormal(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = FP_SUBNORMAL == fpclassify(s0);++  return s1;+}+== END: "f_FP_IsSubnormal.c" ==================+== BEGIN: "d_FP_IsSubnormal.c" ================+/* File: "d_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool d_FP_IsSubnormal(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = FP_SUBNORMAL == fpclassify(s0);++  return s1;+}+== END: "d_FP_IsSubnormal.c" ==================+== BEGIN: "f_FP_IsInfinite.c" ================+/* File: "f_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool f_FP_IsInfinite(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = isinf(s0);++  return s1;+}+== END: "f_FP_IsInfinite.c" ==================+== BEGIN: "d_FP_IsInfinite.c" ================+/* File: "d_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool d_FP_IsInfinite(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isinf(s0);++  return s1;+}+== END: "d_FP_IsInfinite.c" ==================+== BEGIN: "f_FP_IsNaN.c" ================+/* File: "f_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool f_FP_IsNaN(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = isnan(s0);++  return s1;+}+== END: "f_FP_IsNaN.c" ==================+== BEGIN: "d_FP_IsNaN.c" ================+/* File: "d_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool d_FP_IsNaN(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = isnan(s0);++  return s1;+}+== END: "d_FP_IsNaN.c" ==================+== BEGIN: "f_FP_IsNegative.c" ================+/* File: "f_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool f_FP_IsNegative(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = !isnan(s0) && signbit(s0);++  return s1;+}+== END: "f_FP_IsNegative.c" ==================+== BEGIN: "d_FP_IsNegative.c" ================+/* File: "d_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool d_FP_IsNegative(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = !isnan(s0) && signbit(s0);++  return s1;+}+== END: "d_FP_IsNegative.c" ==================+== BEGIN: "f_FP_IsPositive.c" ================+/* File: "f_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool f_FP_IsPositive(const SFloat a)+{+  const SFloat s0 = a;+  const SBool  s1 = !isnan(s0) && !signbit(s0);++  return s1;+}+== END: "f_FP_IsPositive.c" ==================+== BEGIN: "d_FP_IsPositive.c" ================+/* File: "d_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */++#include "floatCodeGen.h"++SBool d_FP_IsPositive(const SDouble a)+{+  const SDouble s0 = a;+  const SBool   s1 = !isnan(s0) && !signbit(s0);++  return s1;+}+== END: "d_FP_IsPositive.c" ==================+== BEGIN: "floatCodeGen.h" ================+/* Header file for floatCodeGen. Automatically generated by SBV. Do not edit! */++#ifndef __floatCodeGen__HEADER_INCLUDED__+#define __floatCodeGen__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* User requested mapping for SInteger.                                 */+/* NB. Loss of precision: Target type is subject to modular arithmetic. */+typedef SInt64 SInteger;++/* User requested mapping for SReal.                          */+/* NB. Loss of precision: Target type is subject to rounding. */+typedef long double SReal;++/* Entry point prototypes: */+SFloat toFP_Int8_ToFloat(const SInt8 a);+SFloat toFP_Int16_ToFloat(const SInt16 a);+SFloat toFP_Int32_ToFloat(const SInt32 a);+SFloat toFP_Int64_ToFloat(const SInt64 a);+SFloat toFP_Word8_ToFloat(const SWord8 a);+SFloat toFP_Word16_ToFloat(const SWord16 a);+SFloat toFP_Word32_ToFloat(const SWord32 a);+SFloat toFP_Word64_ToFloat(const SWord64 a);+SFloat toFP_Float_ToFloat(const SFloat a);+SFloat toFP_Double_ToFloat(const SDouble a);+SFloat toFP_Integer_ToFloat(const SInteger a);+SFloat toFP_Real_ToFloat(const SReal a);+SDouble toFP_Int8_ToDouble(const SInt8 a);+SDouble toFP_Int16_ToDouble(const SInt16 a);+SDouble toFP_Int32_ToDouble(const SInt32 a);+SDouble toFP_Int64_ToDouble(const SInt64 a);+SDouble toFP_Word8_ToDouble(const SWord8 a);+SDouble toFP_Word16_ToDouble(const SWord16 a);+SDouble toFP_Word32_ToDouble(const SWord32 a);+SDouble toFP_Word64_ToDouble(const SWord64 a);+SDouble toFP_Float_ToDouble(const SFloat a);+SDouble toFP_Double_ToDouble(const SDouble a);+SDouble toFP_Integer_ToDouble(const SInteger a);+SDouble toFP_Real_ToDouble(const SReal a);+SInt8 fromFP_Float_ToInt8(const SFloat a);+SInt16 fromFP_Float_ToInt16(const SFloat a);+SInt32 fromFP_Float_ToInt32(const SFloat a);+SInt64 fromFP_Float_ToInt64(const SFloat a);+SWord8 fromFP_Float_ToWord8(const SFloat a);+SWord16 fromFP_Float_ToWord16(const SFloat a);+SWord32 fromFP_Float_ToWord32(const SFloat a);+SWord64 fromFP_Float_ToWord64(const SFloat a);+SFloat fromFP_Float_ToFloat(const SFloat a);+SDouble fromFP_Float_ToDouble(const SFloat a);+SInteger fromFP_Float_ToInteger(const SFloat a);+SReal fromFP_Float_ToReal(const SFloat a);+SInt8 fromFP_DoubleTo_Int8(const SDouble a);+SInt16 fromFP_DoubleTo_Int16(const SDouble a);+SInt32 fromFP_DoubleTo_Int32(const SDouble a);+SInt64 fromFP_DoubleTo_Int64(const SDouble a);+SWord8 fromFP_DoubleTo_Word8(const SDouble a);+SWord16 fromFP_DoubleTo_Word16(const SDouble a);+SWord32 fromFP_DoubleTo_Word32(const SDouble a);+SWord64 fromFP_DoubleTo_Word64(const SDouble a);+SFloat fromFP_DoubleTo_Float(const SDouble a);+SDouble fromFP_DoubleTo_Double(const SDouble a);+SInteger fromFP_DoubleTo_Integer(const SDouble a);+SReal fromFP_DoubleTo_Real(const SDouble a);+SFloat fromFP_SWord32_SFloat(const SWord32 a);+SDouble fromFP_SWord64_SDouble(const SWord64 a);+SWord32 fromFP_SFloat_SWord32(const SFloat a);+SWord64 fromFP_SDouble_SWord64(const SDouble a);+SFloat f_FP_Abs(const SFloat a);+SDouble d_FP_Abs(const SDouble a);+SFloat f_FP_Neg(const SFloat a);+SDouble d_FP_Neg(const SDouble a);+SFloat f_FP_Add(const SFloat a, const SFloat b);+SDouble d_FP_Add(const SDouble a, const SDouble b);+SFloat f_FP_Sub(const SFloat a, const SFloat b);+SDouble d_FP_Sub(const SDouble a, const SDouble b);+SFloat f_FP_Mul(const SFloat a, const SFloat b);+SDouble d_FP_Mul(const SDouble a, const SDouble b);+SFloat f_FP_Div(const SFloat a, const SFloat b);+SDouble d_FP_Div(const SDouble a, const SDouble b);+SFloat f_FP_FMA(const SFloat a, const SFloat b, const SFloat c);+SDouble d_FP_FMA(const SDouble a, const SDouble b,+                 const SDouble c);+SFloat f_FP_Sqrt(const SFloat a);+SDouble d_FP_Sqrt(const SDouble a);+SFloat f_FP_Rem(const SFloat a, const SFloat b);+SDouble d_FP_Rem(const SDouble a, const SDouble b);+SFloat f_FP_RoundToIntegral(const SFloat a);+SDouble d_FP_RoundToIntegral(const SDouble a);+SFloat f_FP_Min(const SFloat a, const SFloat b);+SDouble d_FP_Min(const SDouble a, const SDouble b);+SFloat f_FP_Max(const SFloat a, const SFloat b);+SDouble d_FP_Max(const SDouble a, const SDouble b);+SBool f_FP_IsEqualObject(const SFloat a, const SFloat b);+SBool d_FP_IsEqualObject(const SDouble a, const SDouble b);+SBool f_FP_IsNormal(const SFloat a);+SBool d_FP_IsNormal(const SDouble a);+SBool f_FP_IsZero(const SFloat a);+SBool d_FP_IsZero(const SDouble a);+SBool f_FP_IsSubnormal(const SFloat a);+SBool d_FP_IsSubnormal(const SDouble a);+SBool f_FP_IsInfinite(const SFloat a);+SBool d_FP_IsInfinite(const SDouble a);+SBool f_FP_IsNaN(const SFloat a);+SBool d_FP_IsNaN(const SDouble a);+SBool f_FP_IsNegative(const SFloat a);+SBool d_FP_IsNegative(const SDouble a);+SBool f_FP_IsPositive(const SFloat a);+SBool d_FP_IsPositive(const SDouble a);++#endif /* __floatCodeGen__HEADER_INCLUDED__ */+== END: "floatCodeGen.h" ==================+== BEGIN: "floatCodeGen_driver.c" ================+/* Example driver program for floatCodeGen. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "floatCodeGen.h"++void toFP_Int8_ToFloat_driver(void)+{+  const SFloat __result = toFP_Int8_ToFloat(42);++  printf("toFP_Int8_ToFloat(42) = %.6g\n", __result);+}++void toFP_Int16_ToFloat_driver(void)+{+  const SFloat __result = toFP_Int16_ToFloat(0x002a);++  printf("toFP_Int16_ToFloat(0x002a) = %.6g\n", __result);+}++void toFP_Int32_ToFloat_driver(void)+{+  const SFloat __result = toFP_Int32_ToFloat(0x0000002aL);++  printf("toFP_Int32_ToFloat(0x0000002aL) = %.6g\n", __result);+}++void toFP_Int64_ToFloat_driver(void)+{+  const SFloat __result = toFP_Int64_ToFloat(0x000000000000002aLL);++  printf("toFP_Int64_ToFloat(0x000000000000002aLL) = %.6g\n", __result);+}++void toFP_Word8_ToFloat_driver(void)+{+  const SFloat __result = toFP_Word8_ToFloat(42);++  printf("toFP_Word8_ToFloat(42) = %.6g\n", __result);+}++void toFP_Word16_ToFloat_driver(void)+{+  const SFloat __result = toFP_Word16_ToFloat(0x002aU);++  printf("toFP_Word16_ToFloat(0x002aU) = %.6g\n", __result);+}++void toFP_Word32_ToFloat_driver(void)+{+  const SFloat __result = toFP_Word32_ToFloat(0x0000002aUL);++  printf("toFP_Word32_ToFloat(0x0000002aUL) = %.6g\n", __result);+}++void toFP_Word64_ToFloat_driver(void)+{+  const SFloat __result = toFP_Word64_ToFloat(0x000000000000002aULL);++  printf("toFP_Word64_ToFloat(0x000000000000002aULL) = %.6g\n", __result);+}++void toFP_Float_ToFloat_driver(void)+{+  const SFloat __result = toFP_Float_ToFloat(42.0F);++  printf("toFP_Float_ToFloat(42.0F) = %.6g\n", __result);+}++void toFP_Double_ToFloat_driver(void)+{+  const SFloat __result = toFP_Double_ToFloat(42.0);++  printf("toFP_Double_ToFloat(42.0) = %.6g\n", __result);+}++void toFP_Integer_ToFloat_driver(void)+{+  const SFloat __result = toFP_Integer_ToFloat(0x000000000000002aLL);++  printf("toFP_Integer_ToFloat(0x000000000000002aLL) = %.6g\n", __result);+}++void toFP_Real_ToFloat_driver(void)+{+  const SFloat __result = toFP_Real_ToFloat(42.0L);++  printf("toFP_Real_ToFloat(42.0L) = %.6g\n", __result);+}++void toFP_Int8_ToDouble_driver(void)+{+  const SDouble __result = toFP_Int8_ToDouble(42);++  printf("toFP_Int8_ToDouble(42) = %.15g\n", __result);+}++void toFP_Int16_ToDouble_driver(void)+{+  const SDouble __result = toFP_Int16_ToDouble(0x002a);++  printf("toFP_Int16_ToDouble(0x002a) = %.15g\n", __result);+}++void toFP_Int32_ToDouble_driver(void)+{+  const SDouble __result = toFP_Int32_ToDouble(0x0000002aL);++  printf("toFP_Int32_ToDouble(0x0000002aL) = %.15g\n", __result);+}++void toFP_Int64_ToDouble_driver(void)+{+  const SDouble __result = toFP_Int64_ToDouble(0x000000000000002aLL);++  printf("toFP_Int64_ToDouble(0x000000000000002aLL) = %.15g\n", __result);+}++void toFP_Word8_ToDouble_driver(void)+{+  const SDouble __result = toFP_Word8_ToDouble(42);++  printf("toFP_Word8_ToDouble(42) = %.15g\n", __result);+}++void toFP_Word16_ToDouble_driver(void)+{+  const SDouble __result = toFP_Word16_ToDouble(0x002aU);++  printf("toFP_Word16_ToDouble(0x002aU) = %.15g\n", __result);+}++void toFP_Word32_ToDouble_driver(void)+{+  const SDouble __result = toFP_Word32_ToDouble(0x0000002aUL);++  printf("toFP_Word32_ToDouble(0x0000002aUL) = %.15g\n", __result);+}++void toFP_Word64_ToDouble_driver(void)+{+  const SDouble __result = toFP_Word64_ToDouble(0x000000000000002aULL);++  printf("toFP_Word64_ToDouble(0x000000000000002aULL) = %.15g\n", __result);+}++void toFP_Float_ToDouble_driver(void)+{+  const SDouble __result = toFP_Float_ToDouble(42.0F);++  printf("toFP_Float_ToDouble(42.0F) = %.15g\n", __result);+}++void toFP_Double_ToDouble_driver(void)+{+  const SDouble __result = toFP_Double_ToDouble(42.0);++  printf("toFP_Double_ToDouble(42.0) = %.15g\n", __result);+}++void toFP_Integer_ToDouble_driver(void)+{+  const SDouble __result = toFP_Integer_ToDouble(0x000000000000002aLL);++  printf("toFP_Integer_ToDouble(0x000000000000002aLL) = %.15g\n", __result);+}++void toFP_Real_ToDouble_driver(void)+{+  const SDouble __result = toFP_Real_ToDouble(42.0L);++  printf("toFP_Real_ToDouble(42.0L) = %.15g\n", __result);+}++void fromFP_Float_ToInt8_driver(void)+{+  const SInt8 __result = fromFP_Float_ToInt8(42.0F);++  printf("fromFP_Float_ToInt8(42.0F) = %"PRId8"\n", __result);+}++void fromFP_Float_ToInt16_driver(void)+{+  const SInt16 __result = fromFP_Float_ToInt16(42.0F);++  printf("fromFP_Float_ToInt16(42.0F) = %"PRId16"\n", __result);+}++void fromFP_Float_ToInt32_driver(void)+{+  const SInt32 __result = fromFP_Float_ToInt32(42.0F);++  printf("fromFP_Float_ToInt32(42.0F) = %"PRId32"L\n", __result);+}++void fromFP_Float_ToInt64_driver(void)+{+  const SInt64 __result = fromFP_Float_ToInt64(42.0F);++  printf("fromFP_Float_ToInt64(42.0F) = %"PRId64"LL\n", __result);+}++void fromFP_Float_ToWord8_driver(void)+{+  const SWord8 __result = fromFP_Float_ToWord8(42.0F);++  printf("fromFP_Float_ToWord8(42.0F) = %"PRIu8"\n", __result);+}++void fromFP_Float_ToWord16_driver(void)+{+  const SWord16 __result = fromFP_Float_ToWord16(42.0F);++  printf("fromFP_Float_ToWord16(42.0F) = 0x%04"PRIx16"U\n", __result);+}++void fromFP_Float_ToWord32_driver(void)+{+  const SWord32 __result = fromFP_Float_ToWord32(42.0F);++  printf("fromFP_Float_ToWord32(42.0F) = 0x%08"PRIx32"UL\n", __result);+}++void fromFP_Float_ToWord64_driver(void)+{+  const SWord64 __result = fromFP_Float_ToWord64(42.0F);++  printf("fromFP_Float_ToWord64(42.0F) = 0x%016"PRIx64"ULL\n", __result);+}++void fromFP_Float_ToFloat_driver(void)+{+  const SFloat __result = fromFP_Float_ToFloat(42.0F);++  printf("fromFP_Float_ToFloat(42.0F) = %.6g\n", __result);+}++void fromFP_Float_ToDouble_driver(void)+{+  const SDouble __result = fromFP_Float_ToDouble(42.0F);++  printf("fromFP_Float_ToDouble(42.0F) = %.15g\n", __result);+}++void fromFP_Float_ToInteger_driver(void)+{+  const SInteger __result = fromFP_Float_ToInteger(42.0F);++  printf("fromFP_Float_ToInteger(42.0F) = %"PRId64"LL\n", __result);+}++void fromFP_Float_ToReal_driver(void)+{+  const SReal __result = fromFP_Float_ToReal(42.0F);++  printf("fromFP_Float_ToReal(42.0F) = %Lf\n", __result);+}++void fromFP_DoubleTo_Int8_driver(void)+{+  const SInt8 __result = fromFP_DoubleTo_Int8(42.0);++  printf("fromFP_DoubleTo_Int8(42.0) = %"PRId8"\n", __result);+}++void fromFP_DoubleTo_Int16_driver(void)+{+  const SInt16 __result = fromFP_DoubleTo_Int16(42.0);++  printf("fromFP_DoubleTo_Int16(42.0) = %"PRId16"\n", __result);+}++void fromFP_DoubleTo_Int32_driver(void)+{+  const SInt32 __result = fromFP_DoubleTo_Int32(42.0);++  printf("fromFP_DoubleTo_Int32(42.0) = %"PRId32"L\n", __result);+}++void fromFP_DoubleTo_Int64_driver(void)+{+  const SInt64 __result = fromFP_DoubleTo_Int64(42.0);++  printf("fromFP_DoubleTo_Int64(42.0) = %"PRId64"LL\n", __result);+}++void fromFP_DoubleTo_Word8_driver(void)+{+  const SWord8 __result = fromFP_DoubleTo_Word8(42.0);++  printf("fromFP_DoubleTo_Word8(42.0) = %"PRIu8"\n", __result);+}++void fromFP_DoubleTo_Word16_driver(void)+{+  const SWord16 __result = fromFP_DoubleTo_Word16(42.0);++  printf("fromFP_DoubleTo_Word16(42.0) = 0x%04"PRIx16"U\n", __result);+}++void fromFP_DoubleTo_Word32_driver(void)+{+  const SWord32 __result = fromFP_DoubleTo_Word32(42.0);++  printf("fromFP_DoubleTo_Word32(42.0) = 0x%08"PRIx32"UL\n", __result);+}++void fromFP_DoubleTo_Word64_driver(void)+{+  const SWord64 __result = fromFP_DoubleTo_Word64(42.0);++  printf("fromFP_DoubleTo_Word64(42.0) = 0x%016"PRIx64"ULL\n", __result);+}++void fromFP_DoubleTo_Float_driver(void)+{+  const SFloat __result = fromFP_DoubleTo_Float(42.0);++  printf("fromFP_DoubleTo_Float(42.0) = %.6g\n", __result);+}++void fromFP_DoubleTo_Double_driver(void)+{+  const SDouble __result = fromFP_DoubleTo_Double(42.0);++  printf("fromFP_DoubleTo_Double(42.0) = %.15g\n", __result);+}++void fromFP_DoubleTo_Integer_driver(void)+{+  const SInteger __result = fromFP_DoubleTo_Integer(42.0);++  printf("fromFP_DoubleTo_Integer(42.0) = %"PRId64"LL\n", __result);+}++void fromFP_DoubleTo_Real_driver(void)+{+  const SReal __result = fromFP_DoubleTo_Real(42.0);++  printf("fromFP_DoubleTo_Real(42.0) = %Lf\n", __result);+}++void fromFP_SWord32_SFloat_driver(void)+{+  const SFloat __result = fromFP_SWord32_SFloat(0x0000002aUL);++  printf("fromFP_SWord32_SFloat(0x0000002aUL) = %.6g\n", __result);+}++void fromFP_SWord64_SDouble_driver(void)+{+  const SDouble __result = fromFP_SWord64_SDouble(0x000000000000002aULL);++  printf("fromFP_SWord64_SDouble(0x000000000000002aULL) = %.15g\n", __result);+}++void fromFP_SFloat_SWord32_driver(void)+{+  const SWord32 __result = fromFP_SFloat_SWord32(42.0F);++  printf("fromFP_SFloat_SWord32(42.0F) = 0x%08"PRIx32"UL\n", __result);+}++void fromFP_SDouble_SWord64_driver(void)+{+  const SWord64 __result = fromFP_SDouble_SWord64(42.0);++  printf("fromFP_SDouble_SWord64(42.0) = 0x%016"PRIx64"ULL\n", __result);+}++void f_FP_Abs_driver(void)+{+  const SFloat __result = f_FP_Abs(42.0F);++  printf("f_FP_Abs(42.0F) = %.6g\n", __result);+}++void d_FP_Abs_driver(void)+{+  const SDouble __result = d_FP_Abs(42.0);++  printf("d_FP_Abs(42.0) = %.15g\n", __result);+}++void f_FP_Neg_driver(void)+{+  const SFloat __result = f_FP_Neg(42.0F);++  printf("f_FP_Neg(42.0F) = %.6g\n", __result);+}++void d_FP_Neg_driver(void)+{+  const SDouble __result = d_FP_Neg(42.0);++  printf("d_FP_Neg(42.0) = %.15g\n", __result);+}++void f_FP_Add_driver(void)+{+  const SFloat __result = f_FP_Add(42.0F, 43.0F);++  printf("f_FP_Add(42.0F, 43.0F) = %.6g\n", __result);+}++void d_FP_Add_driver(void)+{+  const SDouble __result = d_FP_Add(42.0, 43.0);++  printf("d_FP_Add(42.0, 43.0) = %.15g\n", __result);+}++void f_FP_Sub_driver(void)+{+  const SFloat __result = f_FP_Sub(42.0F, 43.0F);++  printf("f_FP_Sub(42.0F, 43.0F) = %.6g\n", __result);+}++void d_FP_Sub_driver(void)+{+  const SDouble __result = d_FP_Sub(42.0, 43.0);++  printf("d_FP_Sub(42.0, 43.0) = %.15g\n", __result);+}++void f_FP_Mul_driver(void)+{+  const SFloat __result = f_FP_Mul(42.0F, 43.0F);++  printf("f_FP_Mul(42.0F, 43.0F) = %.6g\n", __result);+}++void d_FP_Mul_driver(void)+{+  const SDouble __result = d_FP_Mul(42.0, 43.0);++  printf("d_FP_Mul(42.0, 43.0) = %.15g\n", __result);+}++void f_FP_Div_driver(void)+{+  const SFloat __result = f_FP_Div(42.0F, 43.0F);++  printf("f_FP_Div(42.0F, 43.0F) = %.6g\n", __result);+}++void d_FP_Div_driver(void)+{+  const SDouble __result = d_FP_Div(42.0, 43.0);++  printf("d_FP_Div(42.0, 43.0) = %.15g\n", __result);+}++void f_FP_FMA_driver(void)+{+  const SFloat __result = f_FP_FMA(42.0F, 43.0F, 44.0F);++  printf("f_FP_FMA(42.0F, 43.0F, 44.0F) = %.6g\n", __result);+}++void d_FP_FMA_driver(void)+{+  const SDouble __result = d_FP_FMA(42.0, 43.0, 44.0);++  printf("d_FP_FMA(42.0, 43.0, 44.0) = %.15g\n", __result);+}++void f_FP_Sqrt_driver(void)+{+  const SFloat __result = f_FP_Sqrt(42.0F);++  printf("f_FP_Sqrt(42.0F) = %.6g\n", __result);+}++void d_FP_Sqrt_driver(void)+{+  const SDouble __result = d_FP_Sqrt(42.0);++  printf("d_FP_Sqrt(42.0) = %.15g\n", __result);+}++void f_FP_Rem_driver(void)+{+  const SFloat __result = f_FP_Rem(42.0F, 43.0F);++  printf("f_FP_Rem(42.0F, 43.0F) = %.6g\n", __result);+}++void d_FP_Rem_driver(void)+{+  const SDouble __result = d_FP_Rem(42.0, 43.0);++  printf("d_FP_Rem(42.0, 43.0) = %.15g\n", __result);+}++void f_FP_RoundToIntegral_driver(void)+{+  const SFloat __result = f_FP_RoundToIntegral(42.0F);++  printf("f_FP_RoundToIntegral(42.0F) = %.6g\n", __result);+}++void d_FP_RoundToIntegral_driver(void)+{+  const SDouble __result = d_FP_RoundToIntegral(42.0);++  printf("d_FP_RoundToIntegral(42.0) = %.15g\n", __result);+}++void f_FP_Min_driver(void)+{+  const SFloat __result = f_FP_Min(42.0F, 43.0F);++  printf("f_FP_Min(42.0F, 43.0F) = %.6g\n", __result);+}++void d_FP_Min_driver(void)+{+  const SDouble __result = d_FP_Min(42.0, 43.0);++  printf("d_FP_Min(42.0, 43.0) = %.15g\n", __result);+}++void f_FP_Max_driver(void)+{+  const SFloat __result = f_FP_Max(42.0F, 43.0F);++  printf("f_FP_Max(42.0F, 43.0F) = %.6g\n", __result);+}++void d_FP_Max_driver(void)+{+  const SDouble __result = d_FP_Max(42.0, 43.0);++  printf("d_FP_Max(42.0, 43.0) = %.15g\n", __result);+}++void f_FP_IsEqualObject_driver(void)+{+  const SBool __result = f_FP_IsEqualObject(42.0F, 43.0F);++  printf("f_FP_IsEqualObject(42.0F, 43.0F) = %d\n", __result);+}++void d_FP_IsEqualObject_driver(void)+{+  const SBool __result = d_FP_IsEqualObject(42.0, 43.0);++  printf("d_FP_IsEqualObject(42.0, 43.0) = %d\n", __result);+}++void f_FP_IsNormal_driver(void)+{+  const SBool __result = f_FP_IsNormal(42.0F);++  printf("f_FP_IsNormal(42.0F) = %d\n", __result);+}++void d_FP_IsNormal_driver(void)+{+  const SBool __result = d_FP_IsNormal(42.0);++  printf("d_FP_IsNormal(42.0) = %d\n", __result);+}++void f_FP_IsZero_driver(void)+{+  const SBool __result = f_FP_IsZero(42.0F);++  printf("f_FP_IsZero(42.0F) = %d\n", __result);+}++void d_FP_IsZero_driver(void)+{+  const SBool __result = d_FP_IsZero(42.0);++  printf("d_FP_IsZero(42.0) = %d\n", __result);+}++void f_FP_IsSubnormal_driver(void)+{+  const SBool __result = f_FP_IsSubnormal(42.0F);++  printf("f_FP_IsSubnormal(42.0F) = %d\n", __result);+}++void d_FP_IsSubnormal_driver(void)+{+  const SBool __result = d_FP_IsSubnormal(42.0);++  printf("d_FP_IsSubnormal(42.0) = %d\n", __result);+}++void f_FP_IsInfinite_driver(void)+{+  const SBool __result = f_FP_IsInfinite(42.0F);++  printf("f_FP_IsInfinite(42.0F) = %d\n", __result);+}++void d_FP_IsInfinite_driver(void)+{+  const SBool __result = d_FP_IsInfinite(42.0);++  printf("d_FP_IsInfinite(42.0) = %d\n", __result);+}++void f_FP_IsNaN_driver(void)+{+  const SBool __result = f_FP_IsNaN(42.0F);++  printf("f_FP_IsNaN(42.0F) = %d\n", __result);+}++void d_FP_IsNaN_driver(void)+{+  const SBool __result = d_FP_IsNaN(42.0);++  printf("d_FP_IsNaN(42.0) = %d\n", __result);+}++void f_FP_IsNegative_driver(void)+{+  const SBool __result = f_FP_IsNegative(42.0F);++  printf("f_FP_IsNegative(42.0F) = %d\n", __result);+}++void d_FP_IsNegative_driver(void)+{+  const SBool __result = d_FP_IsNegative(42.0);++  printf("d_FP_IsNegative(42.0) = %d\n", __result);+}++void f_FP_IsPositive_driver(void)+{+  const SBool __result = f_FP_IsPositive(42.0F);++  printf("f_FP_IsPositive(42.0F) = %d\n", __result);+}++void d_FP_IsPositive_driver(void)+{+  const SBool __result = d_FP_IsPositive(42.0);++  printf("d_FP_IsPositive(42.0) = %d\n", __result);+}++int main(void)+{+  printf("====================================\n");+  printf("** Driver run for toFP_Int8_ToFloat:\n");+  printf("====================================\n");+  toFP_Int8_ToFloat_driver();++  printf("=====================================\n");+  printf("** Driver run for toFP_Int16_ToFloat:\n");+  printf("=====================================\n");+  toFP_Int16_ToFloat_driver();++  printf("=====================================\n");+  printf("** Driver run for toFP_Int32_ToFloat:\n");+  printf("=====================================\n");+  toFP_Int32_ToFloat_driver();++  printf("=====================================\n");+  printf("** Driver run for toFP_Int64_ToFloat:\n");+  printf("=====================================\n");+  toFP_Int64_ToFloat_driver();++  printf("=====================================\n");+  printf("** Driver run for toFP_Word8_ToFloat:\n");+  printf("=====================================\n");+  toFP_Word8_ToFloat_driver();++  printf("======================================\n");+  printf("** Driver run for toFP_Word16_ToFloat:\n");+  printf("======================================\n");+  toFP_Word16_ToFloat_driver();++  printf("======================================\n");+  printf("** Driver run for toFP_Word32_ToFloat:\n");+  printf("======================================\n");+  toFP_Word32_ToFloat_driver();++  printf("======================================\n");+  printf("** Driver run for toFP_Word64_ToFloat:\n");+  printf("======================================\n");+  toFP_Word64_ToFloat_driver();++  printf("=====================================\n");+  printf("** Driver run for toFP_Float_ToFloat:\n");+  printf("=====================================\n");+  toFP_Float_ToFloat_driver();++  printf("======================================\n");+  printf("** Driver run for toFP_Double_ToFloat:\n");+  printf("======================================\n");+  toFP_Double_ToFloat_driver();++  printf("=======================================\n");+  printf("** Driver run for toFP_Integer_ToFloat:\n");+  printf("=======================================\n");+  toFP_Integer_ToFloat_driver();++  printf("====================================\n");+  printf("** Driver run for toFP_Real_ToFloat:\n");+  printf("====================================\n");+  toFP_Real_ToFloat_driver();++  printf("=====================================\n");+  printf("** Driver run for toFP_Int8_ToDouble:\n");+  printf("=====================================\n");+  toFP_Int8_ToDouble_driver();++  printf("======================================\n");+  printf("** Driver run for toFP_Int16_ToDouble:\n");+  printf("======================================\n");+  toFP_Int16_ToDouble_driver();++  printf("======================================\n");+  printf("** Driver run for toFP_Int32_ToDouble:\n");+  printf("======================================\n");+  toFP_Int32_ToDouble_driver();++  printf("======================================\n");+  printf("** Driver run for toFP_Int64_ToDouble:\n");+  printf("======================================\n");+  toFP_Int64_ToDouble_driver();++  printf("======================================\n");+  printf("** Driver run for toFP_Word8_ToDouble:\n");+  printf("======================================\n");+  toFP_Word8_ToDouble_driver();++  printf("=======================================\n");+  printf("** Driver run for toFP_Word16_ToDouble:\n");+  printf("=======================================\n");+  toFP_Word16_ToDouble_driver();++  printf("=======================================\n");+  printf("** Driver run for toFP_Word32_ToDouble:\n");+  printf("=======================================\n");+  toFP_Word32_ToDouble_driver();++  printf("=======================================\n");+  printf("** Driver run for toFP_Word64_ToDouble:\n");+  printf("=======================================\n");+  toFP_Word64_ToDouble_driver();++  printf("======================================\n");+  printf("** Driver run for toFP_Float_ToDouble:\n");+  printf("======================================\n");+  toFP_Float_ToDouble_driver();++  printf("=======================================\n");+  printf("** Driver run for toFP_Double_ToDouble:\n");+  printf("=======================================\n");+  toFP_Double_ToDouble_driver();++  printf("========================================\n");+  printf("** Driver run for toFP_Integer_ToDouble:\n");+  printf("========================================\n");+  toFP_Integer_ToDouble_driver();++  printf("=====================================\n");+  printf("** Driver run for toFP_Real_ToDouble:\n");+  printf("=====================================\n");+  toFP_Real_ToDouble_driver();++  printf("======================================\n");+  printf("** Driver run for fromFP_Float_ToInt8:\n");+  printf("======================================\n");+  fromFP_Float_ToInt8_driver();++  printf("=======================================\n");+  printf("** Driver run for fromFP_Float_ToInt16:\n");+  printf("=======================================\n");+  fromFP_Float_ToInt16_driver();++  printf("=======================================\n");+  printf("** Driver run for fromFP_Float_ToInt32:\n");+  printf("=======================================\n");+  fromFP_Float_ToInt32_driver();++  printf("=======================================\n");+  printf("** Driver run for fromFP_Float_ToInt64:\n");+  printf("=======================================\n");+  fromFP_Float_ToInt64_driver();++  printf("=======================================\n");+  printf("** Driver run for fromFP_Float_ToWord8:\n");+  printf("=======================================\n");+  fromFP_Float_ToWord8_driver();++  printf("========================================\n");+  printf("** Driver run for fromFP_Float_ToWord16:\n");+  printf("========================================\n");+  fromFP_Float_ToWord16_driver();++  printf("========================================\n");+  printf("** Driver run for fromFP_Float_ToWord32:\n");+  printf("========================================\n");+  fromFP_Float_ToWord32_driver();++  printf("========================================\n");+  printf("** Driver run for fromFP_Float_ToWord64:\n");+  printf("========================================\n");+  fromFP_Float_ToWord64_driver();++  printf("=======================================\n");+  printf("** Driver run for fromFP_Float_ToFloat:\n");+  printf("=======================================\n");+  fromFP_Float_ToFloat_driver();++  printf("========================================\n");+  printf("** Driver run for fromFP_Float_ToDouble:\n");+  printf("========================================\n");+  fromFP_Float_ToDouble_driver();++  printf("=========================================\n");+  printf("** Driver run for fromFP_Float_ToInteger:\n");+  printf("=========================================\n");+  fromFP_Float_ToInteger_driver();++  printf("======================================\n");+  printf("** Driver run for fromFP_Float_ToReal:\n");+  printf("======================================\n");+  fromFP_Float_ToReal_driver();++  printf("=======================================\n");+  printf("** Driver run for fromFP_DoubleTo_Int8:\n");+  printf("=======================================\n");+  fromFP_DoubleTo_Int8_driver();++  printf("========================================\n");+  printf("** Driver run for fromFP_DoubleTo_Int16:\n");+  printf("========================================\n");+  fromFP_DoubleTo_Int16_driver();++  printf("========================================\n");+  printf("** Driver run for fromFP_DoubleTo_Int32:\n");+  printf("========================================\n");+  fromFP_DoubleTo_Int32_driver();++  printf("========================================\n");+  printf("** Driver run for fromFP_DoubleTo_Int64:\n");+  printf("========================================\n");+  fromFP_DoubleTo_Int64_driver();++  printf("========================================\n");+  printf("** Driver run for fromFP_DoubleTo_Word8:\n");+  printf("========================================\n");+  fromFP_DoubleTo_Word8_driver();++  printf("=========================================\n");+  printf("** Driver run for fromFP_DoubleTo_Word16:\n");+  printf("=========================================\n");+  fromFP_DoubleTo_Word16_driver();++  printf("=========================================\n");+  printf("** Driver run for fromFP_DoubleTo_Word32:\n");+  printf("=========================================\n");+  fromFP_DoubleTo_Word32_driver();++  printf("=========================================\n");+  printf("** Driver run for fromFP_DoubleTo_Word64:\n");+  printf("=========================================\n");+  fromFP_DoubleTo_Word64_driver();++  printf("========================================\n");+  printf("** Driver run for fromFP_DoubleTo_Float:\n");+  printf("========================================\n");+  fromFP_DoubleTo_Float_driver();++  printf("=========================================\n");+  printf("** Driver run for fromFP_DoubleTo_Double:\n");+  printf("=========================================\n");+  fromFP_DoubleTo_Double_driver();++  printf("==========================================\n");+  printf("** Driver run for fromFP_DoubleTo_Integer:\n");+  printf("==========================================\n");+  fromFP_DoubleTo_Integer_driver();++  printf("=======================================\n");+  printf("** Driver run for fromFP_DoubleTo_Real:\n");+  printf("=======================================\n");+  fromFP_DoubleTo_Real_driver();++  printf("========================================\n");+  printf("** Driver run for fromFP_SWord32_SFloat:\n");+  printf("========================================\n");+  fromFP_SWord32_SFloat_driver();++  printf("=========================================\n");+  printf("** Driver run for fromFP_SWord64_SDouble:\n");+  printf("=========================================\n");+  fromFP_SWord64_SDouble_driver();++  printf("========================================\n");+  printf("** Driver run for fromFP_SFloat_SWord32:\n");+  printf("========================================\n");+  fromFP_SFloat_SWord32_driver();++  printf("=========================================\n");+  printf("** Driver run for fromFP_SDouble_SWord64:\n");+  printf("=========================================\n");+  fromFP_SDouble_SWord64_driver();++  printf("===========================\n");+  printf("** Driver run for f_FP_Abs:\n");+  printf("===========================\n");+  f_FP_Abs_driver();++  printf("===========================\n");+  printf("** Driver run for d_FP_Abs:\n");+  printf("===========================\n");+  d_FP_Abs_driver();++  printf("===========================\n");+  printf("** Driver run for f_FP_Neg:\n");+  printf("===========================\n");+  f_FP_Neg_driver();++  printf("===========================\n");+  printf("** Driver run for d_FP_Neg:\n");+  printf("===========================\n");+  d_FP_Neg_driver();++  printf("===========================\n");+  printf("** Driver run for f_FP_Add:\n");+  printf("===========================\n");+  f_FP_Add_driver();++  printf("===========================\n");+  printf("** Driver run for d_FP_Add:\n");+  printf("===========================\n");+  d_FP_Add_driver();++  printf("===========================\n");+  printf("** Driver run for f_FP_Sub:\n");+  printf("===========================\n");+  f_FP_Sub_driver();++  printf("===========================\n");+  printf("** Driver run for d_FP_Sub:\n");+  printf("===========================\n");+  d_FP_Sub_driver();++  printf("===========================\n");+  printf("** Driver run for f_FP_Mul:\n");+  printf("===========================\n");+  f_FP_Mul_driver();++  printf("===========================\n");+  printf("** Driver run for d_FP_Mul:\n");+  printf("===========================\n");+  d_FP_Mul_driver();++  printf("===========================\n");+  printf("** Driver run for f_FP_Div:\n");+  printf("===========================\n");+  f_FP_Div_driver();++  printf("===========================\n");+  printf("** Driver run for d_FP_Div:\n");+  printf("===========================\n");+  d_FP_Div_driver();++  printf("===========================\n");+  printf("** Driver run for f_FP_FMA:\n");+  printf("===========================\n");+  f_FP_FMA_driver();++  printf("===========================\n");+  printf("** Driver run for d_FP_FMA:\n");+  printf("===========================\n");+  d_FP_FMA_driver();++  printf("============================\n");+  printf("** Driver run for f_FP_Sqrt:\n");+  printf("============================\n");+  f_FP_Sqrt_driver();++  printf("============================\n");+  printf("** Driver run for d_FP_Sqrt:\n");+  printf("============================\n");+  d_FP_Sqrt_driver();++  printf("===========================\n");+  printf("** Driver run for f_FP_Rem:\n");+  printf("===========================\n");+  f_FP_Rem_driver();++  printf("===========================\n");+  printf("** Driver run for d_FP_Rem:\n");+  printf("===========================\n");+  d_FP_Rem_driver();++  printf("=======================================\n");+  printf("** Driver run for f_FP_RoundToIntegral:\n");+  printf("=======================================\n");+  f_FP_RoundToIntegral_driver();++  printf("=======================================\n");+  printf("** Driver run for d_FP_RoundToIntegral:\n");+  printf("=======================================\n");+  d_FP_RoundToIntegral_driver();++  printf("===========================\n");+  printf("** Driver run for f_FP_Min:\n");+  printf("===========================\n");+  f_FP_Min_driver();++  printf("===========================\n");+  printf("** Driver run for d_FP_Min:\n");+  printf("===========================\n");+  d_FP_Min_driver();++  printf("===========================\n");+  printf("** Driver run for f_FP_Max:\n");+  printf("===========================\n");+  f_FP_Max_driver();++  printf("===========================\n");+  printf("** Driver run for d_FP_Max:\n");+  printf("===========================\n");+  d_FP_Max_driver();++  printf("=====================================\n");+  printf("** Driver run for f_FP_IsEqualObject:\n");+  printf("=====================================\n");+  f_FP_IsEqualObject_driver();++  printf("=====================================\n");+  printf("** Driver run for d_FP_IsEqualObject:\n");+  printf("=====================================\n");+  d_FP_IsEqualObject_driver();++  printf("================================\n");+  printf("** Driver run for f_FP_IsNormal:\n");+  printf("================================\n");+  f_FP_IsNormal_driver();++  printf("================================\n");+  printf("** Driver run for d_FP_IsNormal:\n");+  printf("================================\n");+  d_FP_IsNormal_driver();++  printf("==============================\n");+  printf("** Driver run for f_FP_IsZero:\n");+  printf("==============================\n");+  f_FP_IsZero_driver();++  printf("==============================\n");+  printf("** Driver run for d_FP_IsZero:\n");+  printf("==============================\n");+  d_FP_IsZero_driver();++  printf("===================================\n");+  printf("** Driver run for f_FP_IsSubnormal:\n");+  printf("===================================\n");+  f_FP_IsSubnormal_driver();++  printf("===================================\n");+  printf("** Driver run for d_FP_IsSubnormal:\n");+  printf("===================================\n");+  d_FP_IsSubnormal_driver();++  printf("==================================\n");+  printf("** Driver run for f_FP_IsInfinite:\n");+  printf("==================================\n");+  f_FP_IsInfinite_driver();++  printf("==================================\n");+  printf("** Driver run for d_FP_IsInfinite:\n");+  printf("==================================\n");+  d_FP_IsInfinite_driver();++  printf("=============================\n");+  printf("** Driver run for f_FP_IsNaN:\n");+  printf("=============================\n");+  f_FP_IsNaN_driver();++  printf("=============================\n");+  printf("** Driver run for d_FP_IsNaN:\n");+  printf("=============================\n");+  d_FP_IsNaN_driver();++  printf("==================================\n");+  printf("** Driver run for f_FP_IsNegative:\n");+  printf("==================================\n");+  f_FP_IsNegative_driver();++  printf("==================================\n");+  printf("** Driver run for d_FP_IsNegative:\n");+  printf("==================================\n");+  d_FP_IsNegative_driver();++  printf("==================================\n");+  printf("** Driver run for f_FP_IsPositive:\n");+  printf("==================================\n");+  f_FP_IsPositive_driver();++  printf("==================================\n");+  printf("** Driver run for d_FP_IsPositive:\n");+  printf("==================================\n");+  d_FP_IsPositive_driver();++  return 0;+}+== END: "floatCodeGen_driver.c" ==================+== BEGIN: "Makefile" ================+# Makefile for floatCodeGen. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer+AR?=ar+ARFLAGS?=cr++all: floatCodeGen.a floatCodeGen_driver++floatCodeGen.a: toFP_Int8_ToFloat.o toFP_Int16_ToFloat.o toFP_Int32_ToFloat.o toFP_Int64_ToFloat.o toFP_Word8_ToFloat.o toFP_Word16_ToFloat.o toFP_Word32_ToFloat.o toFP_Word64_ToFloat.o toFP_Float_ToFloat.o toFP_Double_ToFloat.o toFP_Integer_ToFloat.o toFP_Real_ToFloat.o toFP_Int8_ToDouble.o toFP_Int16_ToDouble.o toFP_Int32_ToDouble.o toFP_Int64_ToDouble.o toFP_Word8_ToDouble.o toFP_Word16_ToDouble.o toFP_Word32_ToDouble.o toFP_Word64_ToDouble.o toFP_Float_ToDouble.o toFP_Double_ToDouble.o toFP_Integer_ToDouble.o toFP_Real_ToDouble.o fromFP_Float_ToInt8.o fromFP_Float_ToInt16.o fromFP_Float_ToInt32.o fromFP_Float_ToInt64.o fromFP_Float_ToWord8.o fromFP_Float_ToWord16.o fromFP_Float_ToWord32.o fromFP_Float_ToWord64.o fromFP_Float_ToFloat.o fromFP_Float_ToDouble.o fromFP_Float_ToInteger.o fromFP_Float_ToReal.o fromFP_DoubleTo_Int8.o fromFP_DoubleTo_Int16.o fromFP_DoubleTo_Int32.o fromFP_DoubleTo_Int64.o fromFP_DoubleTo_Word8.o fromFP_DoubleTo_Word16.o fromFP_DoubleTo_Word32.o fromFP_DoubleTo_Word64.o fromFP_DoubleTo_Float.o fromFP_DoubleTo_Double.o fromFP_DoubleTo_Integer.o fromFP_DoubleTo_Real.o fromFP_SWord32_SFloat.o fromFP_SWord64_SDouble.o fromFP_SFloat_SWord32.o fromFP_SDouble_SWord64.o f_FP_Abs.o d_FP_Abs.o f_FP_Neg.o d_FP_Neg.o f_FP_Add.o d_FP_Add.o f_FP_Sub.o d_FP_Sub.o f_FP_Mul.o d_FP_Mul.o f_FP_Div.o d_FP_Div.o f_FP_FMA.o d_FP_FMA.o f_FP_Sqrt.o d_FP_Sqrt.o f_FP_Rem.o d_FP_Rem.o f_FP_RoundToIntegral.o d_FP_RoundToIntegral.o f_FP_Min.o d_FP_Min.o f_FP_Max.o d_FP_Max.o f_FP_IsEqualObject.o d_FP_IsEqualObject.o f_FP_IsNormal.o d_FP_IsNormal.o f_FP_IsZero.o d_FP_IsZero.o f_FP_IsSubnormal.o d_FP_IsSubnormal.o f_FP_IsInfinite.o d_FP_IsInfinite.o f_FP_IsNaN.o d_FP_IsNaN.o f_FP_IsNegative.o d_FP_IsNegative.o f_FP_IsPositive.o d_FP_IsPositive.o+	${AR} ${ARFLAGS} $@ $^++floatCodeGen_driver: floatCodeGen_driver.c floatCodeGen.h+	${CC} ${CCFLAGS} $< -o $@ floatCodeGen.a++toFP_Int8_ToFloat.o: toFP_Int8_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Int16_ToFloat.o: toFP_Int16_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Int32_ToFloat.o: toFP_Int32_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Int64_ToFloat.o: toFP_Int64_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Word8_ToFloat.o: toFP_Word8_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Word16_ToFloat.o: toFP_Word16_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Word32_ToFloat.o: toFP_Word32_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Word64_ToFloat.o: toFP_Word64_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Float_ToFloat.o: toFP_Float_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Double_ToFloat.o: toFP_Double_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Integer_ToFloat.o: toFP_Integer_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Real_ToFloat.o: toFP_Real_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Int8_ToDouble.o: toFP_Int8_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Int16_ToDouble.o: toFP_Int16_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Int32_ToDouble.o: toFP_Int32_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Int64_ToDouble.o: toFP_Int64_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Word8_ToDouble.o: toFP_Word8_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Word16_ToDouble.o: toFP_Word16_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Word32_ToDouble.o: toFP_Word32_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Word64_ToDouble.o: toFP_Word64_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Float_ToDouble.o: toFP_Float_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Double_ToDouble.o: toFP_Double_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Integer_ToDouble.o: toFP_Integer_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++toFP_Real_ToDouble.o: toFP_Real_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToInt8.o: fromFP_Float_ToInt8.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToInt16.o: fromFP_Float_ToInt16.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToInt32.o: fromFP_Float_ToInt32.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToInt64.o: fromFP_Float_ToInt64.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToWord8.o: fromFP_Float_ToWord8.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToWord16.o: fromFP_Float_ToWord16.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToWord32.o: fromFP_Float_ToWord32.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToWord64.o: fromFP_Float_ToWord64.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToFloat.o: fromFP_Float_ToFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToDouble.o: fromFP_Float_ToDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToInteger.o: fromFP_Float_ToInteger.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_Float_ToReal.o: fromFP_Float_ToReal.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Int8.o: fromFP_DoubleTo_Int8.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Int16.o: fromFP_DoubleTo_Int16.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Int32.o: fromFP_DoubleTo_Int32.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Int64.o: fromFP_DoubleTo_Int64.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Word8.o: fromFP_DoubleTo_Word8.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Word16.o: fromFP_DoubleTo_Word16.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Word32.o: fromFP_DoubleTo_Word32.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Word64.o: fromFP_DoubleTo_Word64.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Float.o: fromFP_DoubleTo_Float.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Double.o: fromFP_DoubleTo_Double.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Integer.o: fromFP_DoubleTo_Integer.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_DoubleTo_Real.o: fromFP_DoubleTo_Real.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_SWord32_SFloat.o: fromFP_SWord32_SFloat.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_SWord64_SDouble.o: fromFP_SWord64_SDouble.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_SFloat_SWord32.o: fromFP_SFloat_SWord32.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++fromFP_SDouble_SWord64.o: fromFP_SDouble_SWord64.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_Abs.o: f_FP_Abs.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_Abs.o: d_FP_Abs.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_Neg.o: f_FP_Neg.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_Neg.o: d_FP_Neg.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_Add.o: f_FP_Add.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_Add.o: d_FP_Add.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_Sub.o: f_FP_Sub.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_Sub.o: d_FP_Sub.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_Mul.o: f_FP_Mul.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_Mul.o: d_FP_Mul.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_Div.o: f_FP_Div.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_Div.o: d_FP_Div.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_FMA.o: f_FP_FMA.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_FMA.o: d_FP_FMA.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_Sqrt.o: f_FP_Sqrt.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_Sqrt.o: d_FP_Sqrt.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_Rem.o: f_FP_Rem.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_Rem.o: d_FP_Rem.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_RoundToIntegral.o: f_FP_RoundToIntegral.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_RoundToIntegral.o: d_FP_RoundToIntegral.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_Min.o: f_FP_Min.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_Min.o: d_FP_Min.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_Max.o: f_FP_Max.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_Max.o: d_FP_Max.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_IsEqualObject.o: f_FP_IsEqualObject.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_IsEqualObject.o: d_FP_IsEqualObject.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_IsNormal.o: f_FP_IsNormal.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_IsNormal.o: d_FP_IsNormal.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_IsZero.o: f_FP_IsZero.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_IsZero.o: d_FP_IsZero.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_IsSubnormal.o: f_FP_IsSubnormal.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_IsSubnormal.o: d_FP_IsSubnormal.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_IsInfinite.o: f_FP_IsInfinite.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_IsInfinite.o: d_FP_IsInfinite.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_IsNaN.o: f_FP_IsNaN.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_IsNaN.o: d_FP_IsNaN.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_IsNegative.o: f_FP_IsNegative.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_IsNegative.o: d_FP_IsNegative.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++f_FP_IsPositive.o: f_FP_IsPositive.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++d_FP_IsPositive.o: d_FP_IsPositive.c floatCodeGen.h+	${CC} ${CCFLAGS} -c $< -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f floatCodeGen.a floatCodeGen_driver+== END: "Makefile" ==================
+ SBVTestSuite/GoldFiles/freshVars.gold view
@@ -0,0 +1,133 @@+** 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] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s1 () Int 0)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () Int) ; tracks user variable "a"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s2 () Bool (= s0 s1))+[GOOD] (assert s2)+[GOOD] (declare-fun s3 () Bool)+[GOOD] (declare-fun s4 () (_ BitVec 8))+[GOOD] (declare-fun s5 () (_ BitVec 16))+[GOOD] (declare-fun s6 () (_ BitVec 32))+[GOOD] (declare-fun s7 () (_ BitVec 64))+[GOOD] (declare-fun s8 () (_ BitVec 8))+[GOOD] (declare-fun s9 () (_ BitVec 16))+[GOOD] (declare-fun s10 () (_ BitVec 32))+[GOOD] (declare-fun s11 () (_ BitVec 64))+[GOOD] (declare-fun s12 () (_ FloatingPoint  8 24))+[GOOD] (declare-fun s13 () (_ FloatingPoint 11 53))+[GOOD] (declare-fun s14 () Real)+[GOOD] (declare-fun s15 () Int)+[GOOD] (declare-datatypes () ((BinOp (Plus) (Minus) (Times))))+[GOOD] (define-fun BinOp_constrIndex ((x BinOp)) Int+          (ite (= x Plus) 0 (ite (= x Minus) 1 2))+       )+[GOOD] (declare-fun s16 () BinOp)+[GOOD] (assert s3)+[GOOD] (define-fun s17 () (_ BitVec 8) #x01)+[GOOD] (define-fun s18 () Bool (= s4 s17))+[GOOD] (assert s18)+[GOOD] (define-fun s19 () (_ BitVec 16) #x0002)+[GOOD] (define-fun s20 () Bool (= s5 s19))+[GOOD] (assert s20)+[GOOD] (define-fun s21 () (_ BitVec 32) #x00000003)+[GOOD] (define-fun s22 () Bool (= s6 s21))+[GOOD] (assert s22)+[GOOD] (define-fun s23 () (_ BitVec 64) #x0000000000000004)+[GOOD] (define-fun s24 () Bool (= s7 s23))+[GOOD] (assert s24)+[GOOD] (define-fun s25 () (_ BitVec 8) #x05)+[GOOD] (define-fun s26 () Bool (= s8 s25))+[GOOD] (assert s26)+[GOOD] (define-fun s27 () (_ BitVec 16) #x0006)+[GOOD] (define-fun s28 () Bool (= s9 s27))+[GOOD] (assert s28)+[GOOD] (define-fun s29 () (_ BitVec 32) #x00000007)+[GOOD] (define-fun s30 () Bool (= s10 s29))+[GOOD] (assert s30)+[GOOD] (define-fun s31 () (_ BitVec 64) #x0000000000000008)+[GOOD] (define-fun s32 () Bool (= s11 s31))+[GOOD] (assert s32)+[GOOD] (define-fun s33 () (_ FloatingPoint  8 24) ((_ to_fp 8 24) roundNearestTiesToEven (/ 9.0 1.0)))+[GOOD] (define-fun s34 () Bool (fp.eq s12 s33))+[GOOD] (assert s34)+[GOOD] (define-fun s35 () (_ FloatingPoint 11 53) ((_ to_fp 11 53) roundNearestTiesToEven (/ 10.0 1.0)))+[GOOD] (define-fun s36 () Bool (fp.eq s13 s35))+[GOOD] (assert s36)+[GOOD] (define-fun s37 () Real (/ 11.0 1.0))+[GOOD] (define-fun s38 () Bool (= s14 s37))+[GOOD] (assert s38)+[GOOD] (define-fun s39 () Int 12)+[GOOD] (define-fun s40 () Bool (= s15 s39))+[GOOD] (assert s40)+[GOOD] (define-fun s41 () BinOp Plus)+[GOOD] (define-fun s42 () Bool (= s16 s41))+[GOOD] (assert s42)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 0))+[SEND] (get-value (s3))+[RECV] ((s3 true))+[SEND] (get-value (s4))+[RECV] ((s4 #x01))+[SEND] (get-value (s5))+[RECV] ((s5 #x0002))+[SEND] (get-value (s6))+[RECV] ((s6 #x00000003))+[SEND] (get-value (s7))+[RECV] ((s7 #x0000000000000004))+[SEND] (get-value (s8))+[RECV] ((s8 #x05))+[SEND] (get-value (s9))+[RECV] ((s9 #x0006))+[SEND] (get-value (s10))+[RECV] ((s10 #x00000007))+[SEND] (get-value (s11))+[RECV] ((s11 #x0000000000000008))+[SEND] (get-value (s12))+[RECV] ((s12 (fp #b0 #x82 #b00100000000000000000000)))+[SEND] (get-value (s13))+[RECV] ((s13 (fp #b0 #b10000000010 #x4000000000000)))+[SEND] (get-value (s14))+[RECV] ((s14 11.0))+[SEND] (get-value (s15))+[RECV] ((s15 12))+[SEND] (get-value (s16))+[RECV] ((s16 Plus))+*** Solver   : Z3+*** Exit code: ExitSuccess++ FINAL:Satisfiable. Model:+  a        =    0 :: Integer+  vBool    = True :: Bool+  vWord8   =    1 :: Word8+  s5       =    2 :: Word16+  s6       =    3 :: Word32+  vWord64  =    4 :: Word64+  vInt8    =    5 :: Int8+  s9       =    6 :: Int16+  s10      =    7 :: Int32+  vInt64   =    8 :: Int64+  vFloat   =  9.0 :: Float+  s13      = 10.0 :: Double+  s14      = 11.0 :: Real+  vInteger =   12 :: Integer+  vBinOp   = Plus :: BinOp+DONE!
+ SBVTestSuite/GoldFiles/gcd.gold view
@@ -0,0 +1,141 @@+== BEGIN: "Makefile" ================+# Makefile for sgcd. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: sgcd_driver++sgcd.o: sgcd.c sgcd.h+	${CC} ${CCFLAGS} -c $< -o $@++sgcd_driver.o: sgcd_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++sgcd_driver: sgcd.o sgcd_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f sgcd_driver+== END: "Makefile" ==================+== BEGIN: "sgcd.h" ================+/* Header file for sgcd. Automatically generated by SBV. Do not edit! */++#ifndef __sgcd__HEADER_INCLUDED__+#define __sgcd__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+SWord8 sgcd(const SWord8 x, const SWord8 y);++#endif /* __sgcd__HEADER_INCLUDED__ */+== END: "sgcd.h" ==================+== BEGIN: "sgcd_driver.c" ================+/* Example driver program for sgcd. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "sgcd.h"++int main(void)+{+  const SWord8 __result = sgcd(55, 154);++  printf("sgcd(55, 154) = %"PRIu8"\n", __result);++  return 0;+}+== END: "sgcd_driver.c" ==================+== BEGIN: "sgcd.c" ================+/* File: "sgcd.c". Automatically generated by SBV. Do not edit! */++#include "sgcd.h"++SWord8 sgcd(const SWord8 x, const SWord8 y)+{+  const SWord8 s0 = x;+  const SWord8 s1 = y;+  const SBool  s3 = s1 == 0;+  const SWord8 s4 = (s1 == 0) ? s0 : (s0 % s1);+  const SWord8 s5 = s3 ? s0 : s4;+  const SBool  s6 = 0 == s5;+  const SWord8 s7 = (s5 == 0) ? s1 : (s1 % s5);+  const SWord8 s8 = s6 ? s1 : s7;+  const SBool  s9 = 0 == s8;+  const SWord8 s10 = (s8 == 0) ? s5 : (s5 % s8);+  const SWord8 s11 = s9 ? s5 : s10;+  const SBool  s12 = 0 == s11;+  const SWord8 s13 = (s11 == 0) ? s8 : (s8 % s11);+  const SWord8 s14 = s12 ? s8 : s13;+  const SBool  s15 = 0 == s14;+  const SWord8 s16 = (s14 == 0) ? s11 : (s11 % s14);+  const SWord8 s17 = s15 ? s11 : s16;+  const SBool  s18 = 0 == s17;+  const SWord8 s19 = (s17 == 0) ? s14 : (s14 % s17);+  const SWord8 s20 = s18 ? s14 : s19;+  const SBool  s21 = 0 == s20;+  const SWord8 s22 = (s20 == 0) ? s17 : (s17 % s20);+  const SWord8 s23 = s21 ? s17 : s22;+  const SBool  s24 = 0 == s23;+  const SWord8 s25 = (s23 == 0) ? s20 : (s20 % s23);+  const SWord8 s26 = s24 ? s20 : s25;+  const SBool  s27 = 0 == s26;+  const SWord8 s28 = (s26 == 0) ? s23 : (s23 % s26);+  const SWord8 s29 = s27 ? s23 : s28;+  const SBool  s30 = 0 == s29;+  const SWord8 s31 = (s29 == 0) ? s26 : (s26 % s29);+  const SWord8 s32 = s30 ? s26 : s31;+  const SBool  s33 = 0 == s32;+  const SWord8 s34 = (s32 == 0) ? s29 : (s29 % s32);+  const SWord8 s35 = s33 ? s29 : s34;+  const SBool  s36 = 0 == s35;+  const SWord8 s37 = s36 ? s32 : s35;+  const SWord8 s38 = s33 ? s29 : s37;+  const SWord8 s39 = s30 ? s26 : s38;+  const SWord8 s40 = s27 ? s23 : s39;+  const SWord8 s41 = s24 ? s20 : s40;+  const SWord8 s42 = s21 ? s17 : s41;+  const SWord8 s43 = s18 ? s14 : s42;+  const SWord8 s44 = s15 ? s11 : s43;+  const SWord8 s45 = s12 ? s8 : s44;+  const SWord8 s46 = s9 ? s5 : s45;+  const SWord8 s47 = s6 ? s1 : s46;+  const SWord8 s48 = s3 ? s0 : s47;++  return s48;+}+== END: "sgcd.c" ==================
+ SBVTestSuite/GoldFiles/genBenchMark1.gold view
@@ -0,0 +1,21 @@+(set-option :smtlib2_compliant true)+(set-option :diagnostic-output-channel "stdout")+(set-option :produce-models true)+(set-logic QF_BV)+; --- uninterpreted sorts ---+; --- literal constants ---+(define-fun s_2 () Bool false)+(define-fun s_1 () Bool true)+(define-fun s1 () (_ BitVec 8) #x01)+; --- skolem constants ---+(declare-fun s0 () (_ BitVec 8))+; --- constant tables ---+; --- skolemized tables ---+; --- arrays ---+; --- uninterpreted constants ---+; --- user given axioms ---+; --- formula ---+(define-fun s2 () (_ BitVec 8) (bvadd s0 s1))+(define-fun s3 () Bool (= s0 s2))+(assert (not s3))+(check-sat)
+ SBVTestSuite/GoldFiles/genBenchMark2.gold view
@@ -0,0 +1,21 @@+(set-option :smtlib2_compliant true)+(set-option :diagnostic-output-channel "stdout")+(set-option :produce-models true)+(set-logic QF_BV)+; --- uninterpreted sorts ---+; --- literal constants ---+(define-fun s_2 () Bool false)+(define-fun s_1 () Bool true)+(define-fun s1 () (_ BitVec 8) #x01)+; --- skolem constants ---+(declare-fun s0 () (_ BitVec 8))+; --- constant tables ---+; --- skolemized tables ---+; --- arrays ---+; --- uninterpreted constants ---+; --- user given axioms ---+; --- formula ---+(define-fun s2 () (_ BitVec 8) (bvadd s0 s1))+(define-fun s3 () Bool (= s0 s2))+(assert s3)+(check-sat)
+ SBVTestSuite/GoldFiles/higher-1.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ SBVTestSuite/GoldFiles/higher-2.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ SBVTestSuite/GoldFiles/higher-3.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ SBVTestSuite/GoldFiles/higher-4.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ SBVTestSuite/GoldFiles/higher-5.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ SBVTestSuite/GoldFiles/higher-6.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ SBVTestSuite/GoldFiles/higher-7.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ SBVTestSuite/GoldFiles/higher-8.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ SBVTestSuite/GoldFiles/higher-9.gold view
@@ -0,0 +1,2 @@+Falsifiable. Counter-example:+  s0 = 128 :: Word8
+ SBVTestSuite/GoldFiles/iteTest1.gold view
@@ -0,0 +1,14 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+CONSTRAINTS+ASSERTIONS+OUTPUTS
+ SBVTestSuite/GoldFiles/iteTest2.gold view
@@ -0,0 +1,14 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+CONSTRAINTS+ASSERTIONS+OUTPUTS
+ SBVTestSuite/GoldFiles/iteTest3.gold view
@@ -0,0 +1,14 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+CONSTRAINTS+ASSERTIONS+OUTPUTS
+ SBVTestSuite/GoldFiles/legato.gold view
@@ -0,0 +1,8955 @@+INPUTS+  s0 :: SWord32, existential, aliasing "addrX"+  s1 :: SWord8, existential, aliasing "x"+  s2 :: SWord32, existential, aliasing "addrY"+  s3 :: SWord8, existential, aliasing "y"+  s4 :: SWord32, existential, aliasing "addrLow"+  s5 :: SWord8, existential, aliasing "regX"+  s6 :: SWord8, existential, aliasing "regA"+  s7 :: SBool, existential, aliasing "flagC"+  s8 :: SBool, existential, aliasing "flagZ"+CONSTANTS+  s_2 = False :: Bool+  s_1 = True :: Bool+  s14 = 0 :: Word1+  s12 = 0 :: Word8+  s19 = 128 :: Word8+  s21 = 127 :: Word8+  s11 = 256 :: Word16+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+USER GIVEN CODE SEGMENTS+AXIOMS+DEFINE+  s9 :: SBool = /= s0 s2 s4+  s10 :: SBool = ~ s9+  s13 :: SWord1 = choose [0:0] s1+  s15 :: SBool = s13 /= s14+  s16 :: SBool = s_2 == s15+  s17 :: SBool = s0 == s4+  s18 :: SWord8 = s1 >>> 1+  s20 :: SWord8 = s18 | s19+  s22 :: SWord8 = s18 & s21+  s23 :: SWord8 = if s7 then s20 else s22+  s24 :: SBool = s2 == s4+  s25 :: SWord8 = if s24 then s3 else s12+  s26 :: SWord8 = if s17 then s1 else s25+  s27 :: SWord8 = if s17 then s23 else s26+  s28 :: SWord8 = s27 >>> 1+  s29 :: SWord8 = s21 & s28+  s30 :: SWord8 = if s17 then s29 else s23+  s31 :: SWord1 = choose [0:0] s30+  s32 :: SBool = s14 /= s31+  s33 :: SBool = s_2 == s32+  s34 :: SWord8 = if s15 then s19 else s12+  s35 :: SWord1 = choose [0:0] s34+  s36 :: SBool = s14 /= s35+  s37 :: SWord1 = choose [0:0] s27+  s38 :: SBool = s14 /= s37+  s39 :: SWord8 = s30 >>> 1+  s40 :: SWord8 = s19 | s39+  s41 :: SWord8 = s21 & s39+  s42 :: SWord8 = if s38 then s40 else s41+  s43 :: SWord8 = if s17 then s42 else s29+  s44 :: SWord8 = s43 >>> 1+  s45 :: SWord8 = s19 | s44+  s46 :: SWord8 = s21 & s44+  s47 :: SWord8 = if s36 then s45 else s46+  s48 :: SWord8 = if s17 then s47 else s42+  s49 :: SWord1 = choose [0:0] s48+  s50 :: SBool = s14 /= s49+  s51 :: SBool = s_2 == s50+  s52 :: SWord8 = s34 >>> 1+  s53 :: SWord8 = s19 | s52+  s54 :: SWord8 = s21 & s52+  s55 :: SWord8 = if s32 then s53 else s54+  s56 :: SWord1 = choose [0:0] s55+  s57 :: SBool = s14 /= s56+  s58 :: SWord1 = choose [0:0] s43+  s59 :: SBool = s14 /= s58+  s60 :: SWord8 = s48 >>> 1+  s61 :: SWord8 = s19 | s60+  s62 :: SWord8 = s21 & s60+  s63 :: SWord8 = if s59 then s61 else s62+  s64 :: SWord8 = if s17 then s63 else s47+  s65 :: SWord8 = s64 >>> 1+  s66 :: SWord8 = s19 | s65+  s67 :: SWord8 = s21 & s65+  s68 :: SWord8 = if s57 then s66 else s67+  s69 :: SWord8 = if s17 then s68 else s63+  s70 :: SWord1 = choose [0:0] s69+  s71 :: SBool = s14 /= s70+  s72 :: SBool = s_2 == s71+  s73 :: SWord8 = s55 >>> 1+  s74 :: SWord8 = s19 | s73+  s75 :: SWord8 = s21 & s73+  s76 :: SWord8 = if s50 then s74 else s75+  s77 :: SWord1 = choose [0:0] s76+  s78 :: SBool = s14 /= s77+  s79 :: SWord1 = choose [0:0] s64+  s80 :: SBool = s14 /= s79+  s81 :: SWord8 = s69 >>> 1+  s82 :: SWord8 = s19 | s81+  s83 :: SWord8 = s21 & s81+  s84 :: SWord8 = if s80 then s82 else s83+  s85 :: SWord8 = if s17 then s84 else s68+  s86 :: SWord8 = s85 >>> 1+  s87 :: SWord8 = s19 | s86+  s88 :: SWord8 = s21 & s86+  s89 :: SWord8 = if s78 then s87 else s88+  s90 :: SWord8 = if s17 then s89 else s84+  s91 :: SWord1 = choose [0:0] s90+  s92 :: SBool = s14 /= s91+  s93 :: SBool = s_2 == s92+  s94 :: SWord8 = s76 >>> 1+  s95 :: SWord8 = s19 | s94+  s96 :: SWord8 = s21 & s94+  s97 :: SWord8 = if s71 then s95 else s96+  s98 :: SWord1 = choose [0:0] s97+  s99 :: SBool = s14 /= s98+  s100 :: SWord1 = choose [0:0] s85+  s101 :: SBool = s14 /= s100+  s102 :: SWord8 = s90 >>> 1+  s103 :: SWord8 = s19 | s102+  s104 :: SWord8 = s21 & s102+  s105 :: SWord8 = if s101 then s103 else s104+  s106 :: SWord8 = if s17 then s105 else s89+  s107 :: SWord8 = s106 >>> 1+  s108 :: SWord8 = s19 | s107+  s109 :: SWord8 = s21 & s107+  s110 :: SWord8 = if s99 then s108 else s109+  s111 :: SWord8 = if s17 then s110 else s105+  s112 :: SWord1 = choose [0:0] s111+  s113 :: SBool = s14 /= s112+  s114 :: SBool = s_2 == s113+  s115 :: SWord8 = s97 >>> 1+  s116 :: SWord8 = s19 | s115+  s117 :: SWord8 = s21 & s115+  s118 :: SWord8 = if s92 then s116 else s117+  s119 :: SWord1 = choose [0:0] s118+  s120 :: SBool = s14 /= s119+  s121 :: SWord1 = choose [0:0] s106+  s122 :: SBool = s14 /= s121+  s123 :: SWord8 = s111 >>> 1+  s124 :: SWord8 = s19 | s123+  s125 :: SWord8 = s21 & s123+  s126 :: SWord8 = if s122 then s124 else s125+  s127 :: SWord8 = if s17 then s126 else s110+  s128 :: SWord8 = s127 >>> 1+  s129 :: SWord8 = s19 | s128+  s130 :: SWord8 = s21 & s128+  s131 :: SWord8 = if s120 then s129 else s130+  s132 :: SWord8 = if s17 then s131 else s126+  s133 :: SWord1 = choose [0:0] s132+  s134 :: SBool = s14 /= s133+  s135 :: SBool = s_2 == s134+  s136 :: SWord8 = s118 >>> 1+  s137 :: SWord8 = s19 | s136+  s138 :: SWord8 = s21 & s136+  s139 :: SWord8 = if s113 then s137 else s138+  s140 :: SWord1 = choose [0:0] s139+  s141 :: SBool = s14 /= s140+  s142 :: SWord1 = choose [0:0] s127+  s143 :: SBool = s14 /= s142+  s144 :: SWord8 = s132 >>> 1+  s145 :: SWord8 = s19 | s144+  s146 :: SWord8 = s21 & s144+  s147 :: SWord8 = if s143 then s145 else s146+  s148 :: SWord8 = if s17 then s147 else s131+  s149 :: SWord8 = s148 >>> 1+  s150 :: SWord8 = s19 | s149+  s151 :: SWord8 = s21 & s149+  s152 :: SWord8 = if s141 then s150 else s151+  s153 :: SWord8 = if s17 then s152 else s147+  s154 :: SWord1 = choose [0:0] s153+  s155 :: SBool = s14 /= s154+  s156 :: SBool = s_2 == s155+  s157 :: SWord8 = s139 >>> 1+  s158 :: SWord8 = s19 | s157+  s159 :: SWord8 = s21 & s157+  s160 :: SWord8 = if s134 then s158 else s159+  s161 :: SWord8 = s160 >>> 1+  s162 :: SWord8 = s19 | s161+  s163 :: SWord8 = s21 & s161+  s164 :: SWord8 = if s155 then s162 else s163+  s165 :: SBool = s0 == s2+  s166 :: SWord1 = choose [0:0] s148+  s167 :: SBool = s14 /= s166+  s168 :: SWord8 = s153 >>> 1+  s169 :: SWord8 = s19 | s168+  s170 :: SWord8 = s21 & s168+  s171 :: SWord8 = if s167 then s169 else s170+  s172 :: SWord8 = if s165 then s1 else s3+  s173 :: SWord8 = if s165 then s23 else s172+  s174 :: SWord8 = if s24 then s29 else s173+  s175 :: SWord8 = if s165 then s42 else s174+  s176 :: SWord8 = if s24 then s47 else s175+  s177 :: SWord8 = if s165 then s63 else s176+  s178 :: SWord8 = if s24 then s68 else s177+  s179 :: SWord8 = if s165 then s84 else s178+  s180 :: SWord8 = if s24 then s89 else s179+  s181 :: SWord8 = if s165 then s105 else s180+  s182 :: SWord8 = if s24 then s110 else s181+  s183 :: SWord8 = if s165 then s126 else s182+  s184 :: SWord8 = if s24 then s131 else s183+  s185 :: SWord8 = if s165 then s147 else s184+  s186 :: SWord8 = if s24 then s152 else s185+  s187 :: SWord8 = if s165 then s171 else s186+  s188 :: SWord8 = s160 + s187+  s189 :: SBool = s188 < s187+  s190 :: SBool = s188 < s160+  s191 :: SBool = s189 | s190+  s192 :: SWord8 = s188 >>> 1+  s193 :: SWord8 = s19 | s192+  s194 :: SWord8 = s21 & s192+  s195 :: SWord8 = if s191 then s193 else s194+  s196 :: SWord8 = if s156 then s164 else s195+  s197 :: SWord8 = s139 + s185+  s198 :: SWord1 = choose [0:0] s197+  s199 :: SBool = s14 /= s198+  s200 :: SWord8 = if s199 then s150 else s151+  s201 :: SWord8 = if s17 then s200 else s147+  s202 :: SWord1 = choose [0:0] s201+  s203 :: SBool = s14 /= s202+  s204 :: SBool = s_2 == s203+  s205 :: SBool = s197 < s185+  s206 :: SBool = s197 < s139+  s207 :: SBool = s205 | s206+  s208 :: SWord8 = s197 >>> 1+  s209 :: SWord8 = s19 | s208+  s210 :: SWord8 = s21 & s208+  s211 :: SWord8 = if s207 then s209 else s210+  s212 :: SWord8 = s211 >>> 1+  s213 :: SWord8 = s19 | s212+  s214 :: SWord8 = s21 & s212+  s215 :: SWord8 = if s203 then s213 else s214+  s216 :: SWord8 = s201 >>> 1+  s217 :: SWord8 = s19 | s216+  s218 :: SWord8 = s21 & s216+  s219 :: SWord8 = if s167 then s217 else s218+  s220 :: SWord8 = if s24 then s200 else s185+  s221 :: SWord8 = if s165 then s219 else s220+  s222 :: SWord8 = s211 + s221+  s223 :: SBool = s222 < s221+  s224 :: SBool = s222 < s211+  s225 :: SBool = s223 | s224+  s226 :: SWord8 = s222 >>> 1+  s227 :: SWord8 = s19 | s226+  s228 :: SWord8 = s21 & s226+  s229 :: SWord8 = if s225 then s227 else s228+  s230 :: SWord8 = if s204 then s215 else s229+  s231 :: SWord8 = if s135 then s196 else s230+  s232 :: SWord8 = s118 + s183+  s233 :: SWord1 = choose [0:0] s232+  s234 :: SBool = s14 /= s233+  s235 :: SWord8 = if s234 then s129 else s130+  s236 :: SWord8 = if s17 then s235 else s126+  s237 :: SWord1 = choose [0:0] s236+  s238 :: SBool = s14 /= s237+  s239 :: SBool = s_2 == s238+  s240 :: SBool = s232 < s183+  s241 :: SBool = s232 < s118+  s242 :: SBool = s240 | s241+  s243 :: SWord8 = s232 >>> 1+  s244 :: SWord8 = s19 | s243+  s245 :: SWord8 = s21 & s243+  s246 :: SWord8 = if s242 then s244 else s245+  s247 :: SWord1 = choose [0:0] s246+  s248 :: SBool = s14 /= s247+  s249 :: SWord8 = s236 >>> 1+  s250 :: SWord8 = s19 | s249+  s251 :: SWord8 = s21 & s249+  s252 :: SWord8 = if s143 then s250 else s251+  s253 :: SWord8 = if s17 then s252 else s235+  s254 :: SWord8 = s253 >>> 1+  s255 :: SWord8 = s19 | s254+  s256 :: SWord8 = s21 & s254+  s257 :: SWord8 = if s248 then s255 else s256+  s258 :: SWord8 = if s17 then s257 else s252+  s259 :: SWord1 = choose [0:0] s258+  s260 :: SBool = s14 /= s259+  s261 :: SBool = s_2 == s260+  s262 :: SWord8 = s246 >>> 1+  s263 :: SWord8 = s19 | s262+  s264 :: SWord8 = s21 & s262+  s265 :: SWord8 = if s238 then s263 else s264+  s266 :: SWord8 = s265 >>> 1+  s267 :: SWord8 = s19 | s266+  s268 :: SWord8 = s21 & s266+  s269 :: SWord8 = if s260 then s267 else s268+  s270 :: SWord1 = choose [0:0] s253+  s271 :: SBool = s14 /= s270+  s272 :: SWord8 = s258 >>> 1+  s273 :: SWord8 = s19 | s272+  s274 :: SWord8 = s21 & s272+  s275 :: SWord8 = if s271 then s273 else s274+  s276 :: SWord8 = if s24 then s235 else s183+  s277 :: SWord8 = if s165 then s252 else s276+  s278 :: SWord8 = if s24 then s257 else s277+  s279 :: SWord8 = if s165 then s275 else s278+  s280 :: SWord8 = s265 + s279+  s281 :: SBool = s280 < s279+  s282 :: SBool = s280 < s265+  s283 :: SBool = s281 | s282+  s284 :: SWord8 = s280 >>> 1+  s285 :: SWord8 = s19 | s284+  s286 :: SWord8 = s21 & s284+  s287 :: SWord8 = if s283 then s285 else s286+  s288 :: SWord8 = if s261 then s269 else s287+  s289 :: SWord8 = s246 + s277+  s290 :: SWord1 = choose [0:0] s289+  s291 :: SBool = s14 /= s290+  s292 :: SWord8 = if s291 then s255 else s256+  s293 :: SWord8 = if s17 then s292 else s252+  s294 :: SWord1 = choose [0:0] s293+  s295 :: SBool = s14 /= s294+  s296 :: SBool = s_2 == s295+  s297 :: SBool = s289 < s277+  s298 :: SBool = s289 < s246+  s299 :: SBool = s297 | s298+  s300 :: SWord8 = s289 >>> 1+  s301 :: SWord8 = s19 | s300+  s302 :: SWord8 = s21 & s300+  s303 :: SWord8 = if s299 then s301 else s302+  s304 :: SWord8 = s303 >>> 1+  s305 :: SWord8 = s19 | s304+  s306 :: SWord8 = s21 & s304+  s307 :: SWord8 = if s295 then s305 else s306+  s308 :: SWord8 = s293 >>> 1+  s309 :: SWord8 = s19 | s308+  s310 :: SWord8 = s21 & s308+  s311 :: SWord8 = if s271 then s309 else s310+  s312 :: SWord8 = if s24 then s292 else s277+  s313 :: SWord8 = if s165 then s311 else s312+  s314 :: SWord8 = s303 + s313+  s315 :: SBool = s314 < s313+  s316 :: SBool = s314 < s303+  s317 :: SBool = s315 | s316+  s318 :: SWord8 = s314 >>> 1+  s319 :: SWord8 = s19 | s318+  s320 :: SWord8 = s21 & s318+  s321 :: SWord8 = if s317 then s319 else s320+  s322 :: SWord8 = if s296 then s307 else s321+  s323 :: SWord8 = if s239 then s288 else s322+  s324 :: SWord8 = if s114 then s231 else s323+  s325 :: SWord8 = s97 + s181+  s326 :: SWord1 = choose [0:0] s325+  s327 :: SBool = s14 /= s326+  s328 :: SWord8 = if s327 then s108 else s109+  s329 :: SWord8 = if s17 then s328 else s105+  s330 :: SWord1 = choose [0:0] s329+  s331 :: SBool = s14 /= s330+  s332 :: SBool = s_2 == s331+  s333 :: SBool = s325 < s181+  s334 :: SBool = s325 < s97+  s335 :: SBool = s333 | s334+  s336 :: SWord8 = s325 >>> 1+  s337 :: SWord8 = s19 | s336+  s338 :: SWord8 = s21 & s336+  s339 :: SWord8 = if s335 then s337 else s338+  s340 :: SWord1 = choose [0:0] s339+  s341 :: SBool = s14 /= s340+  s342 :: SWord8 = s329 >>> 1+  s343 :: SWord8 = s19 | s342+  s344 :: SWord8 = s21 & s342+  s345 :: SWord8 = if s122 then s343 else s344+  s346 :: SWord8 = if s17 then s345 else s328+  s347 :: SWord8 = s346 >>> 1+  s348 :: SWord8 = s19 | s347+  s349 :: SWord8 = s21 & s347+  s350 :: SWord8 = if s341 then s348 else s349+  s351 :: SWord8 = if s17 then s350 else s345+  s352 :: SWord1 = choose [0:0] s351+  s353 :: SBool = s14 /= s352+  s354 :: SBool = s_2 == s353+  s355 :: SWord8 = s339 >>> 1+  s356 :: SWord8 = s19 | s355+  s357 :: SWord8 = s21 & s355+  s358 :: SWord8 = if s331 then s356 else s357+  s359 :: SWord1 = choose [0:0] s358+  s360 :: SBool = s14 /= s359+  s361 :: SWord1 = choose [0:0] s346+  s362 :: SBool = s14 /= s361+  s363 :: SWord8 = s351 >>> 1+  s364 :: SWord8 = s19 | s363+  s365 :: SWord8 = s21 & s363+  s366 :: SWord8 = if s362 then s364 else s365+  s367 :: SWord8 = if s17 then s366 else s350+  s368 :: SWord8 = s367 >>> 1+  s369 :: SWord8 = s19 | s368+  s370 :: SWord8 = s21 & s368+  s371 :: SWord8 = if s360 then s369 else s370+  s372 :: SWord8 = if s17 then s371 else s366+  s373 :: SWord1 = choose [0:0] s372+  s374 :: SBool = s14 /= s373+  s375 :: SBool = s_2 == s374+  s376 :: SWord8 = s358 >>> 1+  s377 :: SWord8 = s19 | s376+  s378 :: SWord8 = s21 & s376+  s379 :: SWord8 = if s353 then s377 else s378+  s380 :: SWord8 = s379 >>> 1+  s381 :: SWord8 = s19 | s380+  s382 :: SWord8 = s21 & s380+  s383 :: SWord8 = if s374 then s381 else s382+  s384 :: SWord1 = choose [0:0] s367+  s385 :: SBool = s14 /= s384+  s386 :: SWord8 = s372 >>> 1+  s387 :: SWord8 = s19 | s386+  s388 :: SWord8 = s21 & s386+  s389 :: SWord8 = if s385 then s387 else s388+  s390 :: SWord8 = if s24 then s328 else s181+  s391 :: SWord8 = if s165 then s345 else s390+  s392 :: SWord8 = if s24 then s350 else s391+  s393 :: SWord8 = if s165 then s366 else s392+  s394 :: SWord8 = if s24 then s371 else s393+  s395 :: SWord8 = if s165 then s389 else s394+  s396 :: SWord8 = s379 + s395+  s397 :: SBool = s396 < s395+  s398 :: SBool = s396 < s379+  s399 :: SBool = s397 | s398+  s400 :: SWord8 = s396 >>> 1+  s401 :: SWord8 = s19 | s400+  s402 :: SWord8 = s21 & s400+  s403 :: SWord8 = if s399 then s401 else s402+  s404 :: SWord8 = if s375 then s383 else s403+  s405 :: SWord8 = s358 + s393+  s406 :: SWord1 = choose [0:0] s405+  s407 :: SBool = s14 /= s406+  s408 :: SWord8 = if s407 then s369 else s370+  s409 :: SWord8 = if s17 then s408 else s366+  s410 :: SWord1 = choose [0:0] s409+  s411 :: SBool = s14 /= s410+  s412 :: SBool = s_2 == s411+  s413 :: SBool = s405 < s393+  s414 :: SBool = s405 < s358+  s415 :: SBool = s413 | s414+  s416 :: SWord8 = s405 >>> 1+  s417 :: SWord8 = s19 | s416+  s418 :: SWord8 = s21 & s416+  s419 :: SWord8 = if s415 then s417 else s418+  s420 :: SWord8 = s419 >>> 1+  s421 :: SWord8 = s19 | s420+  s422 :: SWord8 = s21 & s420+  s423 :: SWord8 = if s411 then s421 else s422+  s424 :: SWord8 = s409 >>> 1+  s425 :: SWord8 = s19 | s424+  s426 :: SWord8 = s21 & s424+  s427 :: SWord8 = if s385 then s425 else s426+  s428 :: SWord8 = if s24 then s408 else s393+  s429 :: SWord8 = if s165 then s427 else s428+  s430 :: SWord8 = s419 + s429+  s431 :: SBool = s430 < s429+  s432 :: SBool = s430 < s419+  s433 :: SBool = s431 | s432+  s434 :: SWord8 = s430 >>> 1+  s435 :: SWord8 = s19 | s434+  s436 :: SWord8 = s21 & s434+  s437 :: SWord8 = if s433 then s435 else s436+  s438 :: SWord8 = if s412 then s423 else s437+  s439 :: SWord8 = if s354 then s404 else s438+  s440 :: SWord8 = s339 + s391+  s441 :: SWord1 = choose [0:0] s440+  s442 :: SBool = s14 /= s441+  s443 :: SWord8 = if s442 then s348 else s349+  s444 :: SWord8 = if s17 then s443 else s345+  s445 :: SWord1 = choose [0:0] s444+  s446 :: SBool = s14 /= s445+  s447 :: SBool = s_2 == s446+  s448 :: SBool = s440 < s391+  s449 :: SBool = s440 < s339+  s450 :: SBool = s448 | s449+  s451 :: SWord8 = s440 >>> 1+  s452 :: SWord8 = s19 | s451+  s453 :: SWord8 = s21 & s451+  s454 :: SWord8 = if s450 then s452 else s453+  s455 :: SWord1 = choose [0:0] s454+  s456 :: SBool = s14 /= s455+  s457 :: SWord8 = s444 >>> 1+  s458 :: SWord8 = s19 | s457+  s459 :: SWord8 = s21 & s457+  s460 :: SWord8 = if s362 then s458 else s459+  s461 :: SWord8 = if s17 then s460 else s443+  s462 :: SWord8 = s461 >>> 1+  s463 :: SWord8 = s19 | s462+  s464 :: SWord8 = s21 & s462+  s465 :: SWord8 = if s456 then s463 else s464+  s466 :: SWord8 = if s17 then s465 else s460+  s467 :: SWord1 = choose [0:0] s466+  s468 :: SBool = s14 /= s467+  s469 :: SBool = s_2 == s468+  s470 :: SWord8 = s454 >>> 1+  s471 :: SWord8 = s19 | s470+  s472 :: SWord8 = s21 & s470+  s473 :: SWord8 = if s446 then s471 else s472+  s474 :: SWord8 = s473 >>> 1+  s475 :: SWord8 = s19 | s474+  s476 :: SWord8 = s21 & s474+  s477 :: SWord8 = if s468 then s475 else s476+  s478 :: SWord1 = choose [0:0] s461+  s479 :: SBool = s14 /= s478+  s480 :: SWord8 = s466 >>> 1+  s481 :: SWord8 = s19 | s480+  s482 :: SWord8 = s21 & s480+  s483 :: SWord8 = if s479 then s481 else s482+  s484 :: SWord8 = if s24 then s443 else s391+  s485 :: SWord8 = if s165 then s460 else s484+  s486 :: SWord8 = if s24 then s465 else s485+  s487 :: SWord8 = if s165 then s483 else s486+  s488 :: SWord8 = s473 + s487+  s489 :: SBool = s488 < s487+  s490 :: SBool = s488 < s473+  s491 :: SBool = s489 | s490+  s492 :: SWord8 = s488 >>> 1+  s493 :: SWord8 = s19 | s492+  s494 :: SWord8 = s21 & s492+  s495 :: SWord8 = if s491 then s493 else s494+  s496 :: SWord8 = if s469 then s477 else s495+  s497 :: SWord8 = s454 + s485+  s498 :: SWord1 = choose [0:0] s497+  s499 :: SBool = s14 /= s498+  s500 :: SWord8 = if s499 then s463 else s464+  s501 :: SWord8 = if s17 then s500 else s460+  s502 :: SWord1 = choose [0:0] s501+  s503 :: SBool = s14 /= s502+  s504 :: SBool = s_2 == s503+  s505 :: SBool = s497 < s485+  s506 :: SBool = s497 < s454+  s507 :: SBool = s505 | s506+  s508 :: SWord8 = s497 >>> 1+  s509 :: SWord8 = s19 | s508+  s510 :: SWord8 = s21 & s508+  s511 :: SWord8 = if s507 then s509 else s510+  s512 :: SWord8 = s511 >>> 1+  s513 :: SWord8 = s19 | s512+  s514 :: SWord8 = s21 & s512+  s515 :: SWord8 = if s503 then s513 else s514+  s516 :: SWord8 = s501 >>> 1+  s517 :: SWord8 = s19 | s516+  s518 :: SWord8 = s21 & s516+  s519 :: SWord8 = if s479 then s517 else s518+  s520 :: SWord8 = if s24 then s500 else s485+  s521 :: SWord8 = if s165 then s519 else s520+  s522 :: SWord8 = s511 + s521+  s523 :: SBool = s522 < s521+  s524 :: SBool = s522 < s511+  s525 :: SBool = s523 | s524+  s526 :: SWord8 = s522 >>> 1+  s527 :: SWord8 = s19 | s526+  s528 :: SWord8 = s21 & s526+  s529 :: SWord8 = if s525 then s527 else s528+  s530 :: SWord8 = if s504 then s515 else s529+  s531 :: SWord8 = if s447 then s496 else s530+  s532 :: SWord8 = if s332 then s439 else s531+  s533 :: SWord8 = if s93 then s324 else s532+  s534 :: SWord8 = s76 + s179+  s535 :: SWord1 = choose [0:0] s534+  s536 :: SBool = s14 /= s535+  s537 :: SWord8 = if s536 then s87 else s88+  s538 :: SWord8 = if s17 then s537 else s84+  s539 :: SWord1 = choose [0:0] s538+  s540 :: SBool = s14 /= s539+  s541 :: SBool = s_2 == s540+  s542 :: SBool = s534 < s179+  s543 :: SBool = s534 < s76+  s544 :: SBool = s542 | s543+  s545 :: SWord8 = s534 >>> 1+  s546 :: SWord8 = s19 | s545+  s547 :: SWord8 = s21 & s545+  s548 :: SWord8 = if s544 then s546 else s547+  s549 :: SWord1 = choose [0:0] s548+  s550 :: SBool = s14 /= s549+  s551 :: SWord8 = s538 >>> 1+  s552 :: SWord8 = s19 | s551+  s553 :: SWord8 = s21 & s551+  s554 :: SWord8 = if s101 then s552 else s553+  s555 :: SWord8 = if s17 then s554 else s537+  s556 :: SWord8 = s555 >>> 1+  s557 :: SWord8 = s19 | s556+  s558 :: SWord8 = s21 & s556+  s559 :: SWord8 = if s550 then s557 else s558+  s560 :: SWord8 = if s17 then s559 else s554+  s561 :: SWord1 = choose [0:0] s560+  s562 :: SBool = s14 /= s561+  s563 :: SBool = s_2 == s562+  s564 :: SWord8 = s548 >>> 1+  s565 :: SWord8 = s19 | s564+  s566 :: SWord8 = s21 & s564+  s567 :: SWord8 = if s540 then s565 else s566+  s568 :: SWord1 = choose [0:0] s567+  s569 :: SBool = s14 /= s568+  s570 :: SWord1 = choose [0:0] s555+  s571 :: SBool = s14 /= s570+  s572 :: SWord8 = s560 >>> 1+  s573 :: SWord8 = s19 | s572+  s574 :: SWord8 = s21 & s572+  s575 :: SWord8 = if s571 then s573 else s574+  s576 :: SWord8 = if s17 then s575 else s559+  s577 :: SWord8 = s576 >>> 1+  s578 :: SWord8 = s19 | s577+  s579 :: SWord8 = s21 & s577+  s580 :: SWord8 = if s569 then s578 else s579+  s581 :: SWord8 = if s17 then s580 else s575+  s582 :: SWord1 = choose [0:0] s581+  s583 :: SBool = s14 /= s582+  s584 :: SBool = s_2 == s583+  s585 :: SWord8 = s567 >>> 1+  s586 :: SWord8 = s19 | s585+  s587 :: SWord8 = s21 & s585+  s588 :: SWord8 = if s562 then s586 else s587+  s589 :: SWord1 = choose [0:0] s588+  s590 :: SBool = s14 /= s589+  s591 :: SWord1 = choose [0:0] s576+  s592 :: SBool = s14 /= s591+  s593 :: SWord8 = s581 >>> 1+  s594 :: SWord8 = s19 | s593+  s595 :: SWord8 = s21 & s593+  s596 :: SWord8 = if s592 then s594 else s595+  s597 :: SWord8 = if s17 then s596 else s580+  s598 :: SWord8 = s597 >>> 1+  s599 :: SWord8 = s19 | s598+  s600 :: SWord8 = s21 & s598+  s601 :: SWord8 = if s590 then s599 else s600+  s602 :: SWord8 = if s17 then s601 else s596+  s603 :: SWord1 = choose [0:0] s602+  s604 :: SBool = s14 /= s603+  s605 :: SBool = s_2 == s604+  s606 :: SWord8 = s588 >>> 1+  s607 :: SWord8 = s19 | s606+  s608 :: SWord8 = s21 & s606+  s609 :: SWord8 = if s583 then s607 else s608+  s610 :: SWord8 = s609 >>> 1+  s611 :: SWord8 = s19 | s610+  s612 :: SWord8 = s21 & s610+  s613 :: SWord8 = if s604 then s611 else s612+  s614 :: SWord1 = choose [0:0] s597+  s615 :: SBool = s14 /= s614+  s616 :: SWord8 = s602 >>> 1+  s617 :: SWord8 = s19 | s616+  s618 :: SWord8 = s21 & s616+  s619 :: SWord8 = if s615 then s617 else s618+  s620 :: SWord8 = if s24 then s537 else s179+  s621 :: SWord8 = if s165 then s554 else s620+  s622 :: SWord8 = if s24 then s559 else s621+  s623 :: SWord8 = if s165 then s575 else s622+  s624 :: SWord8 = if s24 then s580 else s623+  s625 :: SWord8 = if s165 then s596 else s624+  s626 :: SWord8 = if s24 then s601 else s625+  s627 :: SWord8 = if s165 then s619 else s626+  s628 :: SWord8 = s609 + s627+  s629 :: SBool = s628 < s627+  s630 :: SBool = s628 < s609+  s631 :: SBool = s629 | s630+  s632 :: SWord8 = s628 >>> 1+  s633 :: SWord8 = s19 | s632+  s634 :: SWord8 = s21 & s632+  s635 :: SWord8 = if s631 then s633 else s634+  s636 :: SWord8 = if s605 then s613 else s635+  s637 :: SWord8 = s588 + s625+  s638 :: SWord1 = choose [0:0] s637+  s639 :: SBool = s14 /= s638+  s640 :: SWord8 = if s639 then s599 else s600+  s641 :: SWord8 = if s17 then s640 else s596+  s642 :: SWord1 = choose [0:0] s641+  s643 :: SBool = s14 /= s642+  s644 :: SBool = s_2 == s643+  s645 :: SBool = s637 < s625+  s646 :: SBool = s637 < s588+  s647 :: SBool = s645 | s646+  s648 :: SWord8 = s637 >>> 1+  s649 :: SWord8 = s19 | s648+  s650 :: SWord8 = s21 & s648+  s651 :: SWord8 = if s647 then s649 else s650+  s652 :: SWord8 = s651 >>> 1+  s653 :: SWord8 = s19 | s652+  s654 :: SWord8 = s21 & s652+  s655 :: SWord8 = if s643 then s653 else s654+  s656 :: SWord8 = s641 >>> 1+  s657 :: SWord8 = s19 | s656+  s658 :: SWord8 = s21 & s656+  s659 :: SWord8 = if s615 then s657 else s658+  s660 :: SWord8 = if s24 then s640 else s625+  s661 :: SWord8 = if s165 then s659 else s660+  s662 :: SWord8 = s651 + s661+  s663 :: SBool = s662 < s661+  s664 :: SBool = s662 < s651+  s665 :: SBool = s663 | s664+  s666 :: SWord8 = s662 >>> 1+  s667 :: SWord8 = s19 | s666+  s668 :: SWord8 = s21 & s666+  s669 :: SWord8 = if s665 then s667 else s668+  s670 :: SWord8 = if s644 then s655 else s669+  s671 :: SWord8 = if s584 then s636 else s670+  s672 :: SWord8 = s567 + s623+  s673 :: SWord1 = choose [0:0] s672+  s674 :: SBool = s14 /= s673+  s675 :: SWord8 = if s674 then s578 else s579+  s676 :: SWord8 = if s17 then s675 else s575+  s677 :: SWord1 = choose [0:0] s676+  s678 :: SBool = s14 /= s677+  s679 :: SBool = s_2 == s678+  s680 :: SBool = s672 < s623+  s681 :: SBool = s672 < s567+  s682 :: SBool = s680 | s681+  s683 :: SWord8 = s672 >>> 1+  s684 :: SWord8 = s19 | s683+  s685 :: SWord8 = s21 & s683+  s686 :: SWord8 = if s682 then s684 else s685+  s687 :: SWord1 = choose [0:0] s686+  s688 :: SBool = s14 /= s687+  s689 :: SWord8 = s676 >>> 1+  s690 :: SWord8 = s19 | s689+  s691 :: SWord8 = s21 & s689+  s692 :: SWord8 = if s592 then s690 else s691+  s693 :: SWord8 = if s17 then s692 else s675+  s694 :: SWord8 = s693 >>> 1+  s695 :: SWord8 = s19 | s694+  s696 :: SWord8 = s21 & s694+  s697 :: SWord8 = if s688 then s695 else s696+  s698 :: SWord8 = if s17 then s697 else s692+  s699 :: SWord1 = choose [0:0] s698+  s700 :: SBool = s14 /= s699+  s701 :: SBool = s_2 == s700+  s702 :: SWord8 = s686 >>> 1+  s703 :: SWord8 = s19 | s702+  s704 :: SWord8 = s21 & s702+  s705 :: SWord8 = if s678 then s703 else s704+  s706 :: SWord8 = s705 >>> 1+  s707 :: SWord8 = s19 | s706+  s708 :: SWord8 = s21 & s706+  s709 :: SWord8 = if s700 then s707 else s708+  s710 :: SWord1 = choose [0:0] s693+  s711 :: SBool = s14 /= s710+  s712 :: SWord8 = s698 >>> 1+  s713 :: SWord8 = s19 | s712+  s714 :: SWord8 = s21 & s712+  s715 :: SWord8 = if s711 then s713 else s714+  s716 :: SWord8 = if s24 then s675 else s623+  s717 :: SWord8 = if s165 then s692 else s716+  s718 :: SWord8 = if s24 then s697 else s717+  s719 :: SWord8 = if s165 then s715 else s718+  s720 :: SWord8 = s705 + s719+  s721 :: SBool = s720 < s719+  s722 :: SBool = s720 < s705+  s723 :: SBool = s721 | s722+  s724 :: SWord8 = s720 >>> 1+  s725 :: SWord8 = s19 | s724+  s726 :: SWord8 = s21 & s724+  s727 :: SWord8 = if s723 then s725 else s726+  s728 :: SWord8 = if s701 then s709 else s727+  s729 :: SWord8 = s686 + s717+  s730 :: SWord1 = choose [0:0] s729+  s731 :: SBool = s14 /= s730+  s732 :: SWord8 = if s731 then s695 else s696+  s733 :: SWord8 = if s17 then s732 else s692+  s734 :: SWord1 = choose [0:0] s733+  s735 :: SBool = s14 /= s734+  s736 :: SBool = s_2 == s735+  s737 :: SBool = s729 < s717+  s738 :: SBool = s729 < s686+  s739 :: SBool = s737 | s738+  s740 :: SWord8 = s729 >>> 1+  s741 :: SWord8 = s19 | s740+  s742 :: SWord8 = s21 & s740+  s743 :: SWord8 = if s739 then s741 else s742+  s744 :: SWord8 = s743 >>> 1+  s745 :: SWord8 = s19 | s744+  s746 :: SWord8 = s21 & s744+  s747 :: SWord8 = if s735 then s745 else s746+  s748 :: SWord8 = s733 >>> 1+  s749 :: SWord8 = s19 | s748+  s750 :: SWord8 = s21 & s748+  s751 :: SWord8 = if s711 then s749 else s750+  s752 :: SWord8 = if s24 then s732 else s717+  s753 :: SWord8 = if s165 then s751 else s752+  s754 :: SWord8 = s743 + s753+  s755 :: SBool = s754 < s753+  s756 :: SBool = s754 < s743+  s757 :: SBool = s755 | s756+  s758 :: SWord8 = s754 >>> 1+  s759 :: SWord8 = s19 | s758+  s760 :: SWord8 = s21 & s758+  s761 :: SWord8 = if s757 then s759 else s760+  s762 :: SWord8 = if s736 then s747 else s761+  s763 :: SWord8 = if s679 then s728 else s762+  s764 :: SWord8 = if s563 then s671 else s763+  s765 :: SWord8 = s548 + s621+  s766 :: SWord1 = choose [0:0] s765+  s767 :: SBool = s14 /= s766+  s768 :: SWord8 = if s767 then s557 else s558+  s769 :: SWord8 = if s17 then s768 else s554+  s770 :: SWord1 = choose [0:0] s769+  s771 :: SBool = s14 /= s770+  s772 :: SBool = s_2 == s771+  s773 :: SBool = s765 < s621+  s774 :: SBool = s765 < s548+  s775 :: SBool = s773 | s774+  s776 :: SWord8 = s765 >>> 1+  s777 :: SWord8 = s19 | s776+  s778 :: SWord8 = s21 & s776+  s779 :: SWord8 = if s775 then s777 else s778+  s780 :: SWord1 = choose [0:0] s779+  s781 :: SBool = s14 /= s780+  s782 :: SWord8 = s769 >>> 1+  s783 :: SWord8 = s19 | s782+  s784 :: SWord8 = s21 & s782+  s785 :: SWord8 = if s571 then s783 else s784+  s786 :: SWord8 = if s17 then s785 else s768+  s787 :: SWord8 = s786 >>> 1+  s788 :: SWord8 = s19 | s787+  s789 :: SWord8 = s21 & s787+  s790 :: SWord8 = if s781 then s788 else s789+  s791 :: SWord8 = if s17 then s790 else s785+  s792 :: SWord1 = choose [0:0] s791+  s793 :: SBool = s14 /= s792+  s794 :: SBool = s_2 == s793+  s795 :: SWord8 = s779 >>> 1+  s796 :: SWord8 = s19 | s795+  s797 :: SWord8 = s21 & s795+  s798 :: SWord8 = if s771 then s796 else s797+  s799 :: SWord1 = choose [0:0] s798+  s800 :: SBool = s14 /= s799+  s801 :: SWord1 = choose [0:0] s786+  s802 :: SBool = s14 /= s801+  s803 :: SWord8 = s791 >>> 1+  s804 :: SWord8 = s19 | s803+  s805 :: SWord8 = s21 & s803+  s806 :: SWord8 = if s802 then s804 else s805+  s807 :: SWord8 = if s17 then s806 else s790+  s808 :: SWord8 = s807 >>> 1+  s809 :: SWord8 = s19 | s808+  s810 :: SWord8 = s21 & s808+  s811 :: SWord8 = if s800 then s809 else s810+  s812 :: SWord8 = if s17 then s811 else s806+  s813 :: SWord1 = choose [0:0] s812+  s814 :: SBool = s14 /= s813+  s815 :: SBool = s_2 == s814+  s816 :: SWord8 = s798 >>> 1+  s817 :: SWord8 = s19 | s816+  s818 :: SWord8 = s21 & s816+  s819 :: SWord8 = if s793 then s817 else s818+  s820 :: SWord8 = s819 >>> 1+  s821 :: SWord8 = s19 | s820+  s822 :: SWord8 = s21 & s820+  s823 :: SWord8 = if s814 then s821 else s822+  s824 :: SWord1 = choose [0:0] s807+  s825 :: SBool = s14 /= s824+  s826 :: SWord8 = s812 >>> 1+  s827 :: SWord8 = s19 | s826+  s828 :: SWord8 = s21 & s826+  s829 :: SWord8 = if s825 then s827 else s828+  s830 :: SWord8 = if s24 then s768 else s621+  s831 :: SWord8 = if s165 then s785 else s830+  s832 :: SWord8 = if s24 then s790 else s831+  s833 :: SWord8 = if s165 then s806 else s832+  s834 :: SWord8 = if s24 then s811 else s833+  s835 :: SWord8 = if s165 then s829 else s834+  s836 :: SWord8 = s819 + s835+  s837 :: SBool = s836 < s835+  s838 :: SBool = s836 < s819+  s839 :: SBool = s837 | s838+  s840 :: SWord8 = s836 >>> 1+  s841 :: SWord8 = s19 | s840+  s842 :: SWord8 = s21 & s840+  s843 :: SWord8 = if s839 then s841 else s842+  s844 :: SWord8 = if s815 then s823 else s843+  s845 :: SWord8 = s798 + s833+  s846 :: SWord1 = choose [0:0] s845+  s847 :: SBool = s14 /= s846+  s848 :: SWord8 = if s847 then s809 else s810+  s849 :: SWord8 = if s17 then s848 else s806+  s850 :: SWord1 = choose [0:0] s849+  s851 :: SBool = s14 /= s850+  s852 :: SBool = s_2 == s851+  s853 :: SBool = s845 < s833+  s854 :: SBool = s845 < s798+  s855 :: SBool = s853 | s854+  s856 :: SWord8 = s845 >>> 1+  s857 :: SWord8 = s19 | s856+  s858 :: SWord8 = s21 & s856+  s859 :: SWord8 = if s855 then s857 else s858+  s860 :: SWord8 = s859 >>> 1+  s861 :: SWord8 = s19 | s860+  s862 :: SWord8 = s21 & s860+  s863 :: SWord8 = if s851 then s861 else s862+  s864 :: SWord8 = s849 >>> 1+  s865 :: SWord8 = s19 | s864+  s866 :: SWord8 = s21 & s864+  s867 :: SWord8 = if s825 then s865 else s866+  s868 :: SWord8 = if s24 then s848 else s833+  s869 :: SWord8 = if s165 then s867 else s868+  s870 :: SWord8 = s859 + s869+  s871 :: SBool = s870 < s869+  s872 :: SBool = s870 < s859+  s873 :: SBool = s871 | s872+  s874 :: SWord8 = s870 >>> 1+  s875 :: SWord8 = s19 | s874+  s876 :: SWord8 = s21 & s874+  s877 :: SWord8 = if s873 then s875 else s876+  s878 :: SWord8 = if s852 then s863 else s877+  s879 :: SWord8 = if s794 then s844 else s878+  s880 :: SWord8 = s779 + s831+  s881 :: SWord1 = choose [0:0] s880+  s882 :: SBool = s14 /= s881+  s883 :: SWord8 = if s882 then s788 else s789+  s884 :: SWord8 = if s17 then s883 else s785+  s885 :: SWord1 = choose [0:0] s884+  s886 :: SBool = s14 /= s885+  s887 :: SBool = s_2 == s886+  s888 :: SBool = s880 < s831+  s889 :: SBool = s880 < s779+  s890 :: SBool = s888 | s889+  s891 :: SWord8 = s880 >>> 1+  s892 :: SWord8 = s19 | s891+  s893 :: SWord8 = s21 & s891+  s894 :: SWord8 = if s890 then s892 else s893+  s895 :: SWord1 = choose [0:0] s894+  s896 :: SBool = s14 /= s895+  s897 :: SWord8 = s884 >>> 1+  s898 :: SWord8 = s19 | s897+  s899 :: SWord8 = s21 & s897+  s900 :: SWord8 = if s802 then s898 else s899+  s901 :: SWord8 = if s17 then s900 else s883+  s902 :: SWord8 = s901 >>> 1+  s903 :: SWord8 = s19 | s902+  s904 :: SWord8 = s21 & s902+  s905 :: SWord8 = if s896 then s903 else s904+  s906 :: SWord8 = if s17 then s905 else s900+  s907 :: SWord1 = choose [0:0] s906+  s908 :: SBool = s14 /= s907+  s909 :: SBool = s_2 == s908+  s910 :: SWord8 = s894 >>> 1+  s911 :: SWord8 = s19 | s910+  s912 :: SWord8 = s21 & s910+  s913 :: SWord8 = if s886 then s911 else s912+  s914 :: SWord8 = s913 >>> 1+  s915 :: SWord8 = s19 | s914+  s916 :: SWord8 = s21 & s914+  s917 :: SWord8 = if s908 then s915 else s916+  s918 :: SWord1 = choose [0:0] s901+  s919 :: SBool = s14 /= s918+  s920 :: SWord8 = s906 >>> 1+  s921 :: SWord8 = s19 | s920+  s922 :: SWord8 = s21 & s920+  s923 :: SWord8 = if s919 then s921 else s922+  s924 :: SWord8 = if s24 then s883 else s831+  s925 :: SWord8 = if s165 then s900 else s924+  s926 :: SWord8 = if s24 then s905 else s925+  s927 :: SWord8 = if s165 then s923 else s926+  s928 :: SWord8 = s913 + s927+  s929 :: SBool = s928 < s927+  s930 :: SBool = s928 < s913+  s931 :: SBool = s929 | s930+  s932 :: SWord8 = s928 >>> 1+  s933 :: SWord8 = s19 | s932+  s934 :: SWord8 = s21 & s932+  s935 :: SWord8 = if s931 then s933 else s934+  s936 :: SWord8 = if s909 then s917 else s935+  s937 :: SWord8 = s894 + s925+  s938 :: SWord1 = choose [0:0] s937+  s939 :: SBool = s14 /= s938+  s940 :: SWord8 = if s939 then s903 else s904+  s941 :: SWord8 = if s17 then s940 else s900+  s942 :: SWord1 = choose [0:0] s941+  s943 :: SBool = s14 /= s942+  s944 :: SBool = s_2 == s943+  s945 :: SBool = s937 < s925+  s946 :: SBool = s937 < s894+  s947 :: SBool = s945 | s946+  s948 :: SWord8 = s937 >>> 1+  s949 :: SWord8 = s19 | s948+  s950 :: SWord8 = s21 & s948+  s951 :: SWord8 = if s947 then s949 else s950+  s952 :: SWord8 = s951 >>> 1+  s953 :: SWord8 = s19 | s952+  s954 :: SWord8 = s21 & s952+  s955 :: SWord8 = if s943 then s953 else s954+  s956 :: SWord8 = s941 >>> 1+  s957 :: SWord8 = s19 | s956+  s958 :: SWord8 = s21 & s956+  s959 :: SWord8 = if s919 then s957 else s958+  s960 :: SWord8 = if s24 then s940 else s925+  s961 :: SWord8 = if s165 then s959 else s960+  s962 :: SWord8 = s951 + s961+  s963 :: SBool = s962 < s961+  s964 :: SBool = s962 < s951+  s965 :: SBool = s963 | s964+  s966 :: SWord8 = s962 >>> 1+  s967 :: SWord8 = s19 | s966+  s968 :: SWord8 = s21 & s966+  s969 :: SWord8 = if s965 then s967 else s968+  s970 :: SWord8 = if s944 then s955 else s969+  s971 :: SWord8 = if s887 then s936 else s970+  s972 :: SWord8 = if s772 then s879 else s971+  s973 :: SWord8 = if s541 then s764 else s972+  s974 :: SWord8 = if s72 then s533 else s973+  s975 :: SWord8 = s55 + s177+  s976 :: SWord1 = choose [0:0] s975+  s977 :: SBool = s14 /= s976+  s978 :: SWord8 = if s977 then s66 else s67+  s979 :: SWord8 = if s17 then s978 else s63+  s980 :: SWord1 = choose [0:0] s979+  s981 :: SBool = s14 /= s980+  s982 :: SBool = s_2 == s981+  s983 :: SBool = s975 < s177+  s984 :: SBool = s975 < s55+  s985 :: SBool = s983 | s984+  s986 :: SWord8 = s975 >>> 1+  s987 :: SWord8 = s19 | s986+  s988 :: SWord8 = s21 & s986+  s989 :: SWord8 = if s985 then s987 else s988+  s990 :: SWord1 = choose [0:0] s989+  s991 :: SBool = s14 /= s990+  s992 :: SWord8 = s979 >>> 1+  s993 :: SWord8 = s19 | s992+  s994 :: SWord8 = s21 & s992+  s995 :: SWord8 = if s80 then s993 else s994+  s996 :: SWord8 = if s17 then s995 else s978+  s997 :: SWord8 = s996 >>> 1+  s998 :: SWord8 = s19 | s997+  s999 :: SWord8 = s21 & s997+  s1000 :: SWord8 = if s991 then s998 else s999+  s1001 :: SWord8 = if s17 then s1000 else s995+  s1002 :: SWord1 = choose [0:0] s1001+  s1003 :: SBool = s14 /= s1002+  s1004 :: SBool = s_2 == s1003+  s1005 :: SWord8 = s989 >>> 1+  s1006 :: SWord8 = s19 | s1005+  s1007 :: SWord8 = s21 & s1005+  s1008 :: SWord8 = if s981 then s1006 else s1007+  s1009 :: SWord1 = choose [0:0] s1008+  s1010 :: SBool = s14 /= s1009+  s1011 :: SWord1 = choose [0:0] s996+  s1012 :: SBool = s14 /= s1011+  s1013 :: SWord8 = s1001 >>> 1+  s1014 :: SWord8 = s19 | s1013+  s1015 :: SWord8 = s21 & s1013+  s1016 :: SWord8 = if s1012 then s1014 else s1015+  s1017 :: SWord8 = if s17 then s1016 else s1000+  s1018 :: SWord8 = s1017 >>> 1+  s1019 :: SWord8 = s19 | s1018+  s1020 :: SWord8 = s21 & s1018+  s1021 :: SWord8 = if s1010 then s1019 else s1020+  s1022 :: SWord8 = if s17 then s1021 else s1016+  s1023 :: SWord1 = choose [0:0] s1022+  s1024 :: SBool = s14 /= s1023+  s1025 :: SBool = s_2 == s1024+  s1026 :: SWord8 = s1008 >>> 1+  s1027 :: SWord8 = s19 | s1026+  s1028 :: SWord8 = s21 & s1026+  s1029 :: SWord8 = if s1003 then s1027 else s1028+  s1030 :: SWord1 = choose [0:0] s1029+  s1031 :: SBool = s14 /= s1030+  s1032 :: SWord1 = choose [0:0] s1017+  s1033 :: SBool = s14 /= s1032+  s1034 :: SWord8 = s1022 >>> 1+  s1035 :: SWord8 = s19 | s1034+  s1036 :: SWord8 = s21 & s1034+  s1037 :: SWord8 = if s1033 then s1035 else s1036+  s1038 :: SWord8 = if s17 then s1037 else s1021+  s1039 :: SWord8 = s1038 >>> 1+  s1040 :: SWord8 = s19 | s1039+  s1041 :: SWord8 = s21 & s1039+  s1042 :: SWord8 = if s1031 then s1040 else s1041+  s1043 :: SWord8 = if s17 then s1042 else s1037+  s1044 :: SWord1 = choose [0:0] s1043+  s1045 :: SBool = s14 /= s1044+  s1046 :: SBool = s_2 == s1045+  s1047 :: SWord8 = s1029 >>> 1+  s1048 :: SWord8 = s19 | s1047+  s1049 :: SWord8 = s21 & s1047+  s1050 :: SWord8 = if s1024 then s1048 else s1049+  s1051 :: SWord1 = choose [0:0] s1050+  s1052 :: SBool = s14 /= s1051+  s1053 :: SWord1 = choose [0:0] s1038+  s1054 :: SBool = s14 /= s1053+  s1055 :: SWord8 = s1043 >>> 1+  s1056 :: SWord8 = s19 | s1055+  s1057 :: SWord8 = s21 & s1055+  s1058 :: SWord8 = if s1054 then s1056 else s1057+  s1059 :: SWord8 = if s17 then s1058 else s1042+  s1060 :: SWord8 = s1059 >>> 1+  s1061 :: SWord8 = s19 | s1060+  s1062 :: SWord8 = s21 & s1060+  s1063 :: SWord8 = if s1052 then s1061 else s1062+  s1064 :: SWord8 = if s17 then s1063 else s1058+  s1065 :: SWord1 = choose [0:0] s1064+  s1066 :: SBool = s14 /= s1065+  s1067 :: SBool = s_2 == s1066+  s1068 :: SWord8 = s1050 >>> 1+  s1069 :: SWord8 = s19 | s1068+  s1070 :: SWord8 = s21 & s1068+  s1071 :: SWord8 = if s1045 then s1069 else s1070+  s1072 :: SWord8 = s1071 >>> 1+  s1073 :: SWord8 = s19 | s1072+  s1074 :: SWord8 = s21 & s1072+  s1075 :: SWord8 = if s1066 then s1073 else s1074+  s1076 :: SWord1 = choose [0:0] s1059+  s1077 :: SBool = s14 /= s1076+  s1078 :: SWord8 = s1064 >>> 1+  s1079 :: SWord8 = s19 | s1078+  s1080 :: SWord8 = s21 & s1078+  s1081 :: SWord8 = if s1077 then s1079 else s1080+  s1082 :: SWord8 = if s24 then s978 else s177+  s1083 :: SWord8 = if s165 then s995 else s1082+  s1084 :: SWord8 = if s24 then s1000 else s1083+  s1085 :: SWord8 = if s165 then s1016 else s1084+  s1086 :: SWord8 = if s24 then s1021 else s1085+  s1087 :: SWord8 = if s165 then s1037 else s1086+  s1088 :: SWord8 = if s24 then s1042 else s1087+  s1089 :: SWord8 = if s165 then s1058 else s1088+  s1090 :: SWord8 = if s24 then s1063 else s1089+  s1091 :: SWord8 = if s165 then s1081 else s1090+  s1092 :: SWord8 = s1071 + s1091+  s1093 :: SBool = s1092 < s1091+  s1094 :: SBool = s1092 < s1071+  s1095 :: SBool = s1093 | s1094+  s1096 :: SWord8 = s1092 >>> 1+  s1097 :: SWord8 = s19 | s1096+  s1098 :: SWord8 = s21 & s1096+  s1099 :: SWord8 = if s1095 then s1097 else s1098+  s1100 :: SWord8 = if s1067 then s1075 else s1099+  s1101 :: SWord8 = s1050 + s1089+  s1102 :: SWord1 = choose [0:0] s1101+  s1103 :: SBool = s14 /= s1102+  s1104 :: SWord8 = if s1103 then s1061 else s1062+  s1105 :: SWord8 = if s17 then s1104 else s1058+  s1106 :: SWord1 = choose [0:0] s1105+  s1107 :: SBool = s14 /= s1106+  s1108 :: SBool = s_2 == s1107+  s1109 :: SBool = s1101 < s1089+  s1110 :: SBool = s1101 < s1050+  s1111 :: SBool = s1109 | s1110+  s1112 :: SWord8 = s1101 >>> 1+  s1113 :: SWord8 = s19 | s1112+  s1114 :: SWord8 = s21 & s1112+  s1115 :: SWord8 = if s1111 then s1113 else s1114+  s1116 :: SWord8 = s1115 >>> 1+  s1117 :: SWord8 = s19 | s1116+  s1118 :: SWord8 = s21 & s1116+  s1119 :: SWord8 = if s1107 then s1117 else s1118+  s1120 :: SWord8 = s1105 >>> 1+  s1121 :: SWord8 = s19 | s1120+  s1122 :: SWord8 = s21 & s1120+  s1123 :: SWord8 = if s1077 then s1121 else s1122+  s1124 :: SWord8 = if s24 then s1104 else s1089+  s1125 :: SWord8 = if s165 then s1123 else s1124+  s1126 :: SWord8 = s1115 + s1125+  s1127 :: SBool = s1126 < s1125+  s1128 :: SBool = s1126 < s1115+  s1129 :: SBool = s1127 | s1128+  s1130 :: SWord8 = s1126 >>> 1+  s1131 :: SWord8 = s19 | s1130+  s1132 :: SWord8 = s21 & s1130+  s1133 :: SWord8 = if s1129 then s1131 else s1132+  s1134 :: SWord8 = if s1108 then s1119 else s1133+  s1135 :: SWord8 = if s1046 then s1100 else s1134+  s1136 :: SWord8 = s1029 + s1087+  s1137 :: SWord1 = choose [0:0] s1136+  s1138 :: SBool = s14 /= s1137+  s1139 :: SWord8 = if s1138 then s1040 else s1041+  s1140 :: SWord8 = if s17 then s1139 else s1037+  s1141 :: SWord1 = choose [0:0] s1140+  s1142 :: SBool = s14 /= s1141+  s1143 :: SBool = s_2 == s1142+  s1144 :: SBool = s1136 < s1087+  s1145 :: SBool = s1136 < s1029+  s1146 :: SBool = s1144 | s1145+  s1147 :: SWord8 = s1136 >>> 1+  s1148 :: SWord8 = s19 | s1147+  s1149 :: SWord8 = s21 & s1147+  s1150 :: SWord8 = if s1146 then s1148 else s1149+  s1151 :: SWord1 = choose [0:0] s1150+  s1152 :: SBool = s14 /= s1151+  s1153 :: SWord8 = s1140 >>> 1+  s1154 :: SWord8 = s19 | s1153+  s1155 :: SWord8 = s21 & s1153+  s1156 :: SWord8 = if s1054 then s1154 else s1155+  s1157 :: SWord8 = if s17 then s1156 else s1139+  s1158 :: SWord8 = s1157 >>> 1+  s1159 :: SWord8 = s19 | s1158+  s1160 :: SWord8 = s21 & s1158+  s1161 :: SWord8 = if s1152 then s1159 else s1160+  s1162 :: SWord8 = if s17 then s1161 else s1156+  s1163 :: SWord1 = choose [0:0] s1162+  s1164 :: SBool = s14 /= s1163+  s1165 :: SBool = s_2 == s1164+  s1166 :: SWord8 = s1150 >>> 1+  s1167 :: SWord8 = s19 | s1166+  s1168 :: SWord8 = s21 & s1166+  s1169 :: SWord8 = if s1142 then s1167 else s1168+  s1170 :: SWord8 = s1169 >>> 1+  s1171 :: SWord8 = s19 | s1170+  s1172 :: SWord8 = s21 & s1170+  s1173 :: SWord8 = if s1164 then s1171 else s1172+  s1174 :: SWord1 = choose [0:0] s1157+  s1175 :: SBool = s14 /= s1174+  s1176 :: SWord8 = s1162 >>> 1+  s1177 :: SWord8 = s19 | s1176+  s1178 :: SWord8 = s21 & s1176+  s1179 :: SWord8 = if s1175 then s1177 else s1178+  s1180 :: SWord8 = if s24 then s1139 else s1087+  s1181 :: SWord8 = if s165 then s1156 else s1180+  s1182 :: SWord8 = if s24 then s1161 else s1181+  s1183 :: SWord8 = if s165 then s1179 else s1182+  s1184 :: SWord8 = s1169 + s1183+  s1185 :: SBool = s1184 < s1183+  s1186 :: SBool = s1184 < s1169+  s1187 :: SBool = s1185 | s1186+  s1188 :: SWord8 = s1184 >>> 1+  s1189 :: SWord8 = s19 | s1188+  s1190 :: SWord8 = s21 & s1188+  s1191 :: SWord8 = if s1187 then s1189 else s1190+  s1192 :: SWord8 = if s1165 then s1173 else s1191+  s1193 :: SWord8 = s1150 + s1181+  s1194 :: SWord1 = choose [0:0] s1193+  s1195 :: SBool = s14 /= s1194+  s1196 :: SWord8 = if s1195 then s1159 else s1160+  s1197 :: SWord8 = if s17 then s1196 else s1156+  s1198 :: SWord1 = choose [0:0] s1197+  s1199 :: SBool = s14 /= s1198+  s1200 :: SBool = s_2 == s1199+  s1201 :: SBool = s1193 < s1181+  s1202 :: SBool = s1193 < s1150+  s1203 :: SBool = s1201 | s1202+  s1204 :: SWord8 = s1193 >>> 1+  s1205 :: SWord8 = s19 | s1204+  s1206 :: SWord8 = s21 & s1204+  s1207 :: SWord8 = if s1203 then s1205 else s1206+  s1208 :: SWord8 = s1207 >>> 1+  s1209 :: SWord8 = s19 | s1208+  s1210 :: SWord8 = s21 & s1208+  s1211 :: SWord8 = if s1199 then s1209 else s1210+  s1212 :: SWord8 = s1197 >>> 1+  s1213 :: SWord8 = s19 | s1212+  s1214 :: SWord8 = s21 & s1212+  s1215 :: SWord8 = if s1175 then s1213 else s1214+  s1216 :: SWord8 = if s24 then s1196 else s1181+  s1217 :: SWord8 = if s165 then s1215 else s1216+  s1218 :: SWord8 = s1207 + s1217+  s1219 :: SBool = s1218 < s1217+  s1220 :: SBool = s1218 < s1207+  s1221 :: SBool = s1219 | s1220+  s1222 :: SWord8 = s1218 >>> 1+  s1223 :: SWord8 = s19 | s1222+  s1224 :: SWord8 = s21 & s1222+  s1225 :: SWord8 = if s1221 then s1223 else s1224+  s1226 :: SWord8 = if s1200 then s1211 else s1225+  s1227 :: SWord8 = if s1143 then s1192 else s1226+  s1228 :: SWord8 = if s1025 then s1135 else s1227+  s1229 :: SWord8 = s1008 + s1085+  s1230 :: SWord1 = choose [0:0] s1229+  s1231 :: SBool = s14 /= s1230+  s1232 :: SWord8 = if s1231 then s1019 else s1020+  s1233 :: SWord8 = if s17 then s1232 else s1016+  s1234 :: SWord1 = choose [0:0] s1233+  s1235 :: SBool = s14 /= s1234+  s1236 :: SBool = s_2 == s1235+  s1237 :: SBool = s1229 < s1085+  s1238 :: SBool = s1229 < s1008+  s1239 :: SBool = s1237 | s1238+  s1240 :: SWord8 = s1229 >>> 1+  s1241 :: SWord8 = s19 | s1240+  s1242 :: SWord8 = s21 & s1240+  s1243 :: SWord8 = if s1239 then s1241 else s1242+  s1244 :: SWord1 = choose [0:0] s1243+  s1245 :: SBool = s14 /= s1244+  s1246 :: SWord8 = s1233 >>> 1+  s1247 :: SWord8 = s19 | s1246+  s1248 :: SWord8 = s21 & s1246+  s1249 :: SWord8 = if s1033 then s1247 else s1248+  s1250 :: SWord8 = if s17 then s1249 else s1232+  s1251 :: SWord8 = s1250 >>> 1+  s1252 :: SWord8 = s19 | s1251+  s1253 :: SWord8 = s21 & s1251+  s1254 :: SWord8 = if s1245 then s1252 else s1253+  s1255 :: SWord8 = if s17 then s1254 else s1249+  s1256 :: SWord1 = choose [0:0] s1255+  s1257 :: SBool = s14 /= s1256+  s1258 :: SBool = s_2 == s1257+  s1259 :: SWord8 = s1243 >>> 1+  s1260 :: SWord8 = s19 | s1259+  s1261 :: SWord8 = s21 & s1259+  s1262 :: SWord8 = if s1235 then s1260 else s1261+  s1263 :: SWord1 = choose [0:0] s1262+  s1264 :: SBool = s14 /= s1263+  s1265 :: SWord1 = choose [0:0] s1250+  s1266 :: SBool = s14 /= s1265+  s1267 :: SWord8 = s1255 >>> 1+  s1268 :: SWord8 = s19 | s1267+  s1269 :: SWord8 = s21 & s1267+  s1270 :: SWord8 = if s1266 then s1268 else s1269+  s1271 :: SWord8 = if s17 then s1270 else s1254+  s1272 :: SWord8 = s1271 >>> 1+  s1273 :: SWord8 = s19 | s1272+  s1274 :: SWord8 = s21 & s1272+  s1275 :: SWord8 = if s1264 then s1273 else s1274+  s1276 :: SWord8 = if s17 then s1275 else s1270+  s1277 :: SWord1 = choose [0:0] s1276+  s1278 :: SBool = s14 /= s1277+  s1279 :: SBool = s_2 == s1278+  s1280 :: SWord8 = s1262 >>> 1+  s1281 :: SWord8 = s19 | s1280+  s1282 :: SWord8 = s21 & s1280+  s1283 :: SWord8 = if s1257 then s1281 else s1282+  s1284 :: SWord8 = s1283 >>> 1+  s1285 :: SWord8 = s19 | s1284+  s1286 :: SWord8 = s21 & s1284+  s1287 :: SWord8 = if s1278 then s1285 else s1286+  s1288 :: SWord1 = choose [0:0] s1271+  s1289 :: SBool = s14 /= s1288+  s1290 :: SWord8 = s1276 >>> 1+  s1291 :: SWord8 = s19 | s1290+  s1292 :: SWord8 = s21 & s1290+  s1293 :: SWord8 = if s1289 then s1291 else s1292+  s1294 :: SWord8 = if s24 then s1232 else s1085+  s1295 :: SWord8 = if s165 then s1249 else s1294+  s1296 :: SWord8 = if s24 then s1254 else s1295+  s1297 :: SWord8 = if s165 then s1270 else s1296+  s1298 :: SWord8 = if s24 then s1275 else s1297+  s1299 :: SWord8 = if s165 then s1293 else s1298+  s1300 :: SWord8 = s1283 + s1299+  s1301 :: SBool = s1300 < s1299+  s1302 :: SBool = s1300 < s1283+  s1303 :: SBool = s1301 | s1302+  s1304 :: SWord8 = s1300 >>> 1+  s1305 :: SWord8 = s19 | s1304+  s1306 :: SWord8 = s21 & s1304+  s1307 :: SWord8 = if s1303 then s1305 else s1306+  s1308 :: SWord8 = if s1279 then s1287 else s1307+  s1309 :: SWord8 = s1262 + s1297+  s1310 :: SWord1 = choose [0:0] s1309+  s1311 :: SBool = s14 /= s1310+  s1312 :: SWord8 = if s1311 then s1273 else s1274+  s1313 :: SWord8 = if s17 then s1312 else s1270+  s1314 :: SWord1 = choose [0:0] s1313+  s1315 :: SBool = s14 /= s1314+  s1316 :: SBool = s_2 == s1315+  s1317 :: SBool = s1309 < s1297+  s1318 :: SBool = s1309 < s1262+  s1319 :: SBool = s1317 | s1318+  s1320 :: SWord8 = s1309 >>> 1+  s1321 :: SWord8 = s19 | s1320+  s1322 :: SWord8 = s21 & s1320+  s1323 :: SWord8 = if s1319 then s1321 else s1322+  s1324 :: SWord8 = s1323 >>> 1+  s1325 :: SWord8 = s19 | s1324+  s1326 :: SWord8 = s21 & s1324+  s1327 :: SWord8 = if s1315 then s1325 else s1326+  s1328 :: SWord8 = s1313 >>> 1+  s1329 :: SWord8 = s19 | s1328+  s1330 :: SWord8 = s21 & s1328+  s1331 :: SWord8 = if s1289 then s1329 else s1330+  s1332 :: SWord8 = if s24 then s1312 else s1297+  s1333 :: SWord8 = if s165 then s1331 else s1332+  s1334 :: SWord8 = s1323 + s1333+  s1335 :: SBool = s1334 < s1333+  s1336 :: SBool = s1334 < s1323+  s1337 :: SBool = s1335 | s1336+  s1338 :: SWord8 = s1334 >>> 1+  s1339 :: SWord8 = s19 | s1338+  s1340 :: SWord8 = s21 & s1338+  s1341 :: SWord8 = if s1337 then s1339 else s1340+  s1342 :: SWord8 = if s1316 then s1327 else s1341+  s1343 :: SWord8 = if s1258 then s1308 else s1342+  s1344 :: SWord8 = s1243 + s1295+  s1345 :: SWord1 = choose [0:0] s1344+  s1346 :: SBool = s14 /= s1345+  s1347 :: SWord8 = if s1346 then s1252 else s1253+  s1348 :: SWord8 = if s17 then s1347 else s1249+  s1349 :: SWord1 = choose [0:0] s1348+  s1350 :: SBool = s14 /= s1349+  s1351 :: SBool = s_2 == s1350+  s1352 :: SBool = s1344 < s1295+  s1353 :: SBool = s1344 < s1243+  s1354 :: SBool = s1352 | s1353+  s1355 :: SWord8 = s1344 >>> 1+  s1356 :: SWord8 = s19 | s1355+  s1357 :: SWord8 = s21 & s1355+  s1358 :: SWord8 = if s1354 then s1356 else s1357+  s1359 :: SWord1 = choose [0:0] s1358+  s1360 :: SBool = s14 /= s1359+  s1361 :: SWord8 = s1348 >>> 1+  s1362 :: SWord8 = s19 | s1361+  s1363 :: SWord8 = s21 & s1361+  s1364 :: SWord8 = if s1266 then s1362 else s1363+  s1365 :: SWord8 = if s17 then s1364 else s1347+  s1366 :: SWord8 = s1365 >>> 1+  s1367 :: SWord8 = s19 | s1366+  s1368 :: SWord8 = s21 & s1366+  s1369 :: SWord8 = if s1360 then s1367 else s1368+  s1370 :: SWord8 = if s17 then s1369 else s1364+  s1371 :: SWord1 = choose [0:0] s1370+  s1372 :: SBool = s14 /= s1371+  s1373 :: SBool = s_2 == s1372+  s1374 :: SWord8 = s1358 >>> 1+  s1375 :: SWord8 = s19 | s1374+  s1376 :: SWord8 = s21 & s1374+  s1377 :: SWord8 = if s1350 then s1375 else s1376+  s1378 :: SWord8 = s1377 >>> 1+  s1379 :: SWord8 = s19 | s1378+  s1380 :: SWord8 = s21 & s1378+  s1381 :: SWord8 = if s1372 then s1379 else s1380+  s1382 :: SWord1 = choose [0:0] s1365+  s1383 :: SBool = s14 /= s1382+  s1384 :: SWord8 = s1370 >>> 1+  s1385 :: SWord8 = s19 | s1384+  s1386 :: SWord8 = s21 & s1384+  s1387 :: SWord8 = if s1383 then s1385 else s1386+  s1388 :: SWord8 = if s24 then s1347 else s1295+  s1389 :: SWord8 = if s165 then s1364 else s1388+  s1390 :: SWord8 = if s24 then s1369 else s1389+  s1391 :: SWord8 = if s165 then s1387 else s1390+  s1392 :: SWord8 = s1377 + s1391+  s1393 :: SBool = s1392 < s1391+  s1394 :: SBool = s1392 < s1377+  s1395 :: SBool = s1393 | s1394+  s1396 :: SWord8 = s1392 >>> 1+  s1397 :: SWord8 = s19 | s1396+  s1398 :: SWord8 = s21 & s1396+  s1399 :: SWord8 = if s1395 then s1397 else s1398+  s1400 :: SWord8 = if s1373 then s1381 else s1399+  s1401 :: SWord8 = s1358 + s1389+  s1402 :: SWord1 = choose [0:0] s1401+  s1403 :: SBool = s14 /= s1402+  s1404 :: SWord8 = if s1403 then s1367 else s1368+  s1405 :: SWord8 = if s17 then s1404 else s1364+  s1406 :: SWord1 = choose [0:0] s1405+  s1407 :: SBool = s14 /= s1406+  s1408 :: SBool = s_2 == s1407+  s1409 :: SBool = s1401 < s1389+  s1410 :: SBool = s1401 < s1358+  s1411 :: SBool = s1409 | s1410+  s1412 :: SWord8 = s1401 >>> 1+  s1413 :: SWord8 = s19 | s1412+  s1414 :: SWord8 = s21 & s1412+  s1415 :: SWord8 = if s1411 then s1413 else s1414+  s1416 :: SWord8 = s1415 >>> 1+  s1417 :: SWord8 = s19 | s1416+  s1418 :: SWord8 = s21 & s1416+  s1419 :: SWord8 = if s1407 then s1417 else s1418+  s1420 :: SWord8 = s1405 >>> 1+  s1421 :: SWord8 = s19 | s1420+  s1422 :: SWord8 = s21 & s1420+  s1423 :: SWord8 = if s1383 then s1421 else s1422+  s1424 :: SWord8 = if s24 then s1404 else s1389+  s1425 :: SWord8 = if s165 then s1423 else s1424+  s1426 :: SWord8 = s1415 + s1425+  s1427 :: SBool = s1426 < s1425+  s1428 :: SBool = s1426 < s1415+  s1429 :: SBool = s1427 | s1428+  s1430 :: SWord8 = s1426 >>> 1+  s1431 :: SWord8 = s19 | s1430+  s1432 :: SWord8 = s21 & s1430+  s1433 :: SWord8 = if s1429 then s1431 else s1432+  s1434 :: SWord8 = if s1408 then s1419 else s1433+  s1435 :: SWord8 = if s1351 then s1400 else s1434+  s1436 :: SWord8 = if s1236 then s1343 else s1435+  s1437 :: SWord8 = if s1004 then s1228 else s1436+  s1438 :: SWord8 = s989 + s1083+  s1439 :: SWord1 = choose [0:0] s1438+  s1440 :: SBool = s14 /= s1439+  s1441 :: SWord8 = if s1440 then s998 else s999+  s1442 :: SWord8 = if s17 then s1441 else s995+  s1443 :: SWord1 = choose [0:0] s1442+  s1444 :: SBool = s14 /= s1443+  s1445 :: SBool = s_2 == s1444+  s1446 :: SBool = s1438 < s1083+  s1447 :: SBool = s1438 < s989+  s1448 :: SBool = s1446 | s1447+  s1449 :: SWord8 = s1438 >>> 1+  s1450 :: SWord8 = s19 | s1449+  s1451 :: SWord8 = s21 & s1449+  s1452 :: SWord8 = if s1448 then s1450 else s1451+  s1453 :: SWord1 = choose [0:0] s1452+  s1454 :: SBool = s14 /= s1453+  s1455 :: SWord8 = s1442 >>> 1+  s1456 :: SWord8 = s19 | s1455+  s1457 :: SWord8 = s21 & s1455+  s1458 :: SWord8 = if s1012 then s1456 else s1457+  s1459 :: SWord8 = if s17 then s1458 else s1441+  s1460 :: SWord8 = s1459 >>> 1+  s1461 :: SWord8 = s19 | s1460+  s1462 :: SWord8 = s21 & s1460+  s1463 :: SWord8 = if s1454 then s1461 else s1462+  s1464 :: SWord8 = if s17 then s1463 else s1458+  s1465 :: SWord1 = choose [0:0] s1464+  s1466 :: SBool = s14 /= s1465+  s1467 :: SBool = s_2 == s1466+  s1468 :: SWord8 = s1452 >>> 1+  s1469 :: SWord8 = s19 | s1468+  s1470 :: SWord8 = s21 & s1468+  s1471 :: SWord8 = if s1444 then s1469 else s1470+  s1472 :: SWord1 = choose [0:0] s1471+  s1473 :: SBool = s14 /= s1472+  s1474 :: SWord1 = choose [0:0] s1459+  s1475 :: SBool = s14 /= s1474+  s1476 :: SWord8 = s1464 >>> 1+  s1477 :: SWord8 = s19 | s1476+  s1478 :: SWord8 = s21 & s1476+  s1479 :: SWord8 = if s1475 then s1477 else s1478+  s1480 :: SWord8 = if s17 then s1479 else s1463+  s1481 :: SWord8 = s1480 >>> 1+  s1482 :: SWord8 = s19 | s1481+  s1483 :: SWord8 = s21 & s1481+  s1484 :: SWord8 = if s1473 then s1482 else s1483+  s1485 :: SWord8 = if s17 then s1484 else s1479+  s1486 :: SWord1 = choose [0:0] s1485+  s1487 :: SBool = s14 /= s1486+  s1488 :: SBool = s_2 == s1487+  s1489 :: SWord8 = s1471 >>> 1+  s1490 :: SWord8 = s19 | s1489+  s1491 :: SWord8 = s21 & s1489+  s1492 :: SWord8 = if s1466 then s1490 else s1491+  s1493 :: SWord1 = choose [0:0] s1492+  s1494 :: SBool = s14 /= s1493+  s1495 :: SWord1 = choose [0:0] s1480+  s1496 :: SBool = s14 /= s1495+  s1497 :: SWord8 = s1485 >>> 1+  s1498 :: SWord8 = s19 | s1497+  s1499 :: SWord8 = s21 & s1497+  s1500 :: SWord8 = if s1496 then s1498 else s1499+  s1501 :: SWord8 = if s17 then s1500 else s1484+  s1502 :: SWord8 = s1501 >>> 1+  s1503 :: SWord8 = s19 | s1502+  s1504 :: SWord8 = s21 & s1502+  s1505 :: SWord8 = if s1494 then s1503 else s1504+  s1506 :: SWord8 = if s17 then s1505 else s1500+  s1507 :: SWord1 = choose [0:0] s1506+  s1508 :: SBool = s14 /= s1507+  s1509 :: SBool = s_2 == s1508+  s1510 :: SWord8 = s1492 >>> 1+  s1511 :: SWord8 = s19 | s1510+  s1512 :: SWord8 = s21 & s1510+  s1513 :: SWord8 = if s1487 then s1511 else s1512+  s1514 :: SWord8 = s1513 >>> 1+  s1515 :: SWord8 = s19 | s1514+  s1516 :: SWord8 = s21 & s1514+  s1517 :: SWord8 = if s1508 then s1515 else s1516+  s1518 :: SWord1 = choose [0:0] s1501+  s1519 :: SBool = s14 /= s1518+  s1520 :: SWord8 = s1506 >>> 1+  s1521 :: SWord8 = s19 | s1520+  s1522 :: SWord8 = s21 & s1520+  s1523 :: SWord8 = if s1519 then s1521 else s1522+  s1524 :: SWord8 = if s24 then s1441 else s1083+  s1525 :: SWord8 = if s165 then s1458 else s1524+  s1526 :: SWord8 = if s24 then s1463 else s1525+  s1527 :: SWord8 = if s165 then s1479 else s1526+  s1528 :: SWord8 = if s24 then s1484 else s1527+  s1529 :: SWord8 = if s165 then s1500 else s1528+  s1530 :: SWord8 = if s24 then s1505 else s1529+  s1531 :: SWord8 = if s165 then s1523 else s1530+  s1532 :: SWord8 = s1513 + s1531+  s1533 :: SBool = s1532 < s1531+  s1534 :: SBool = s1532 < s1513+  s1535 :: SBool = s1533 | s1534+  s1536 :: SWord8 = s1532 >>> 1+  s1537 :: SWord8 = s19 | s1536+  s1538 :: SWord8 = s21 & s1536+  s1539 :: SWord8 = if s1535 then s1537 else s1538+  s1540 :: SWord8 = if s1509 then s1517 else s1539+  s1541 :: SWord8 = s1492 + s1529+  s1542 :: SWord1 = choose [0:0] s1541+  s1543 :: SBool = s14 /= s1542+  s1544 :: SWord8 = if s1543 then s1503 else s1504+  s1545 :: SWord8 = if s17 then s1544 else s1500+  s1546 :: SWord1 = choose [0:0] s1545+  s1547 :: SBool = s14 /= s1546+  s1548 :: SBool = s_2 == s1547+  s1549 :: SBool = s1541 < s1529+  s1550 :: SBool = s1541 < s1492+  s1551 :: SBool = s1549 | s1550+  s1552 :: SWord8 = s1541 >>> 1+  s1553 :: SWord8 = s19 | s1552+  s1554 :: SWord8 = s21 & s1552+  s1555 :: SWord8 = if s1551 then s1553 else s1554+  s1556 :: SWord8 = s1555 >>> 1+  s1557 :: SWord8 = s19 | s1556+  s1558 :: SWord8 = s21 & s1556+  s1559 :: SWord8 = if s1547 then s1557 else s1558+  s1560 :: SWord8 = s1545 >>> 1+  s1561 :: SWord8 = s19 | s1560+  s1562 :: SWord8 = s21 & s1560+  s1563 :: SWord8 = if s1519 then s1561 else s1562+  s1564 :: SWord8 = if s24 then s1544 else s1529+  s1565 :: SWord8 = if s165 then s1563 else s1564+  s1566 :: SWord8 = s1555 + s1565+  s1567 :: SBool = s1566 < s1565+  s1568 :: SBool = s1566 < s1555+  s1569 :: SBool = s1567 | s1568+  s1570 :: SWord8 = s1566 >>> 1+  s1571 :: SWord8 = s19 | s1570+  s1572 :: SWord8 = s21 & s1570+  s1573 :: SWord8 = if s1569 then s1571 else s1572+  s1574 :: SWord8 = if s1548 then s1559 else s1573+  s1575 :: SWord8 = if s1488 then s1540 else s1574+  s1576 :: SWord8 = s1471 + s1527+  s1577 :: SWord1 = choose [0:0] s1576+  s1578 :: SBool = s14 /= s1577+  s1579 :: SWord8 = if s1578 then s1482 else s1483+  s1580 :: SWord8 = if s17 then s1579 else s1479+  s1581 :: SWord1 = choose [0:0] s1580+  s1582 :: SBool = s14 /= s1581+  s1583 :: SBool = s_2 == s1582+  s1584 :: SBool = s1576 < s1527+  s1585 :: SBool = s1576 < s1471+  s1586 :: SBool = s1584 | s1585+  s1587 :: SWord8 = s1576 >>> 1+  s1588 :: SWord8 = s19 | s1587+  s1589 :: SWord8 = s21 & s1587+  s1590 :: SWord8 = if s1586 then s1588 else s1589+  s1591 :: SWord1 = choose [0:0] s1590+  s1592 :: SBool = s14 /= s1591+  s1593 :: SWord8 = s1580 >>> 1+  s1594 :: SWord8 = s19 | s1593+  s1595 :: SWord8 = s21 & s1593+  s1596 :: SWord8 = if s1496 then s1594 else s1595+  s1597 :: SWord8 = if s17 then s1596 else s1579+  s1598 :: SWord8 = s1597 >>> 1+  s1599 :: SWord8 = s19 | s1598+  s1600 :: SWord8 = s21 & s1598+  s1601 :: SWord8 = if s1592 then s1599 else s1600+  s1602 :: SWord8 = if s17 then s1601 else s1596+  s1603 :: SWord1 = choose [0:0] s1602+  s1604 :: SBool = s14 /= s1603+  s1605 :: SBool = s_2 == s1604+  s1606 :: SWord8 = s1590 >>> 1+  s1607 :: SWord8 = s19 | s1606+  s1608 :: SWord8 = s21 & s1606+  s1609 :: SWord8 = if s1582 then s1607 else s1608+  s1610 :: SWord8 = s1609 >>> 1+  s1611 :: SWord8 = s19 | s1610+  s1612 :: SWord8 = s21 & s1610+  s1613 :: SWord8 = if s1604 then s1611 else s1612+  s1614 :: SWord1 = choose [0:0] s1597+  s1615 :: SBool = s14 /= s1614+  s1616 :: SWord8 = s1602 >>> 1+  s1617 :: SWord8 = s19 | s1616+  s1618 :: SWord8 = s21 & s1616+  s1619 :: SWord8 = if s1615 then s1617 else s1618+  s1620 :: SWord8 = if s24 then s1579 else s1527+  s1621 :: SWord8 = if s165 then s1596 else s1620+  s1622 :: SWord8 = if s24 then s1601 else s1621+  s1623 :: SWord8 = if s165 then s1619 else s1622+  s1624 :: SWord8 = s1609 + s1623+  s1625 :: SBool = s1624 < s1623+  s1626 :: SBool = s1624 < s1609+  s1627 :: SBool = s1625 | s1626+  s1628 :: SWord8 = s1624 >>> 1+  s1629 :: SWord8 = s19 | s1628+  s1630 :: SWord8 = s21 & s1628+  s1631 :: SWord8 = if s1627 then s1629 else s1630+  s1632 :: SWord8 = if s1605 then s1613 else s1631+  s1633 :: SWord8 = s1590 + s1621+  s1634 :: SWord1 = choose [0:0] s1633+  s1635 :: SBool = s14 /= s1634+  s1636 :: SWord8 = if s1635 then s1599 else s1600+  s1637 :: SWord8 = if s17 then s1636 else s1596+  s1638 :: SWord1 = choose [0:0] s1637+  s1639 :: SBool = s14 /= s1638+  s1640 :: SBool = s_2 == s1639+  s1641 :: SBool = s1633 < s1621+  s1642 :: SBool = s1633 < s1590+  s1643 :: SBool = s1641 | s1642+  s1644 :: SWord8 = s1633 >>> 1+  s1645 :: SWord8 = s19 | s1644+  s1646 :: SWord8 = s21 & s1644+  s1647 :: SWord8 = if s1643 then s1645 else s1646+  s1648 :: SWord8 = s1647 >>> 1+  s1649 :: SWord8 = s19 | s1648+  s1650 :: SWord8 = s21 & s1648+  s1651 :: SWord8 = if s1639 then s1649 else s1650+  s1652 :: SWord8 = s1637 >>> 1+  s1653 :: SWord8 = s19 | s1652+  s1654 :: SWord8 = s21 & s1652+  s1655 :: SWord8 = if s1615 then s1653 else s1654+  s1656 :: SWord8 = if s24 then s1636 else s1621+  s1657 :: SWord8 = if s165 then s1655 else s1656+  s1658 :: SWord8 = s1647 + s1657+  s1659 :: SBool = s1658 < s1657+  s1660 :: SBool = s1658 < s1647+  s1661 :: SBool = s1659 | s1660+  s1662 :: SWord8 = s1658 >>> 1+  s1663 :: SWord8 = s19 | s1662+  s1664 :: SWord8 = s21 & s1662+  s1665 :: SWord8 = if s1661 then s1663 else s1664+  s1666 :: SWord8 = if s1640 then s1651 else s1665+  s1667 :: SWord8 = if s1583 then s1632 else s1666+  s1668 :: SWord8 = if s1467 then s1575 else s1667+  s1669 :: SWord8 = s1452 + s1525+  s1670 :: SWord1 = choose [0:0] s1669+  s1671 :: SBool = s14 /= s1670+  s1672 :: SWord8 = if s1671 then s1461 else s1462+  s1673 :: SWord8 = if s17 then s1672 else s1458+  s1674 :: SWord1 = choose [0:0] s1673+  s1675 :: SBool = s14 /= s1674+  s1676 :: SBool = s_2 == s1675+  s1677 :: SBool = s1669 < s1525+  s1678 :: SBool = s1669 < s1452+  s1679 :: SBool = s1677 | s1678+  s1680 :: SWord8 = s1669 >>> 1+  s1681 :: SWord8 = s19 | s1680+  s1682 :: SWord8 = s21 & s1680+  s1683 :: SWord8 = if s1679 then s1681 else s1682+  s1684 :: SWord1 = choose [0:0] s1683+  s1685 :: SBool = s14 /= s1684+  s1686 :: SWord8 = s1673 >>> 1+  s1687 :: SWord8 = s19 | s1686+  s1688 :: SWord8 = s21 & s1686+  s1689 :: SWord8 = if s1475 then s1687 else s1688+  s1690 :: SWord8 = if s17 then s1689 else s1672+  s1691 :: SWord8 = s1690 >>> 1+  s1692 :: SWord8 = s19 | s1691+  s1693 :: SWord8 = s21 & s1691+  s1694 :: SWord8 = if s1685 then s1692 else s1693+  s1695 :: SWord8 = if s17 then s1694 else s1689+  s1696 :: SWord1 = choose [0:0] s1695+  s1697 :: SBool = s14 /= s1696+  s1698 :: SBool = s_2 == s1697+  s1699 :: SWord8 = s1683 >>> 1+  s1700 :: SWord8 = s19 | s1699+  s1701 :: SWord8 = s21 & s1699+  s1702 :: SWord8 = if s1675 then s1700 else s1701+  s1703 :: SWord1 = choose [0:0] s1702+  s1704 :: SBool = s14 /= s1703+  s1705 :: SWord1 = choose [0:0] s1690+  s1706 :: SBool = s14 /= s1705+  s1707 :: SWord8 = s1695 >>> 1+  s1708 :: SWord8 = s19 | s1707+  s1709 :: SWord8 = s21 & s1707+  s1710 :: SWord8 = if s1706 then s1708 else s1709+  s1711 :: SWord8 = if s17 then s1710 else s1694+  s1712 :: SWord8 = s1711 >>> 1+  s1713 :: SWord8 = s19 | s1712+  s1714 :: SWord8 = s21 & s1712+  s1715 :: SWord8 = if s1704 then s1713 else s1714+  s1716 :: SWord8 = if s17 then s1715 else s1710+  s1717 :: SWord1 = choose [0:0] s1716+  s1718 :: SBool = s14 /= s1717+  s1719 :: SBool = s_2 == s1718+  s1720 :: SWord8 = s1702 >>> 1+  s1721 :: SWord8 = s19 | s1720+  s1722 :: SWord8 = s21 & s1720+  s1723 :: SWord8 = if s1697 then s1721 else s1722+  s1724 :: SWord8 = s1723 >>> 1+  s1725 :: SWord8 = s19 | s1724+  s1726 :: SWord8 = s21 & s1724+  s1727 :: SWord8 = if s1718 then s1725 else s1726+  s1728 :: SWord1 = choose [0:0] s1711+  s1729 :: SBool = s14 /= s1728+  s1730 :: SWord8 = s1716 >>> 1+  s1731 :: SWord8 = s19 | s1730+  s1732 :: SWord8 = s21 & s1730+  s1733 :: SWord8 = if s1729 then s1731 else s1732+  s1734 :: SWord8 = if s24 then s1672 else s1525+  s1735 :: SWord8 = if s165 then s1689 else s1734+  s1736 :: SWord8 = if s24 then s1694 else s1735+  s1737 :: SWord8 = if s165 then s1710 else s1736+  s1738 :: SWord8 = if s24 then s1715 else s1737+  s1739 :: SWord8 = if s165 then s1733 else s1738+  s1740 :: SWord8 = s1723 + s1739+  s1741 :: SBool = s1740 < s1739+  s1742 :: SBool = s1740 < s1723+  s1743 :: SBool = s1741 | s1742+  s1744 :: SWord8 = s1740 >>> 1+  s1745 :: SWord8 = s19 | s1744+  s1746 :: SWord8 = s21 & s1744+  s1747 :: SWord8 = if s1743 then s1745 else s1746+  s1748 :: SWord8 = if s1719 then s1727 else s1747+  s1749 :: SWord8 = s1702 + s1737+  s1750 :: SWord1 = choose [0:0] s1749+  s1751 :: SBool = s14 /= s1750+  s1752 :: SWord8 = if s1751 then s1713 else s1714+  s1753 :: SWord8 = if s17 then s1752 else s1710+  s1754 :: SWord1 = choose [0:0] s1753+  s1755 :: SBool = s14 /= s1754+  s1756 :: SBool = s_2 == s1755+  s1757 :: SBool = s1749 < s1737+  s1758 :: SBool = s1749 < s1702+  s1759 :: SBool = s1757 | s1758+  s1760 :: SWord8 = s1749 >>> 1+  s1761 :: SWord8 = s19 | s1760+  s1762 :: SWord8 = s21 & s1760+  s1763 :: SWord8 = if s1759 then s1761 else s1762+  s1764 :: SWord8 = s1763 >>> 1+  s1765 :: SWord8 = s19 | s1764+  s1766 :: SWord8 = s21 & s1764+  s1767 :: SWord8 = if s1755 then s1765 else s1766+  s1768 :: SWord8 = s1753 >>> 1+  s1769 :: SWord8 = s19 | s1768+  s1770 :: SWord8 = s21 & s1768+  s1771 :: SWord8 = if s1729 then s1769 else s1770+  s1772 :: SWord8 = if s24 then s1752 else s1737+  s1773 :: SWord8 = if s165 then s1771 else s1772+  s1774 :: SWord8 = s1763 + s1773+  s1775 :: SBool = s1774 < s1773+  s1776 :: SBool = s1774 < s1763+  s1777 :: SBool = s1775 | s1776+  s1778 :: SWord8 = s1774 >>> 1+  s1779 :: SWord8 = s19 | s1778+  s1780 :: SWord8 = s21 & s1778+  s1781 :: SWord8 = if s1777 then s1779 else s1780+  s1782 :: SWord8 = if s1756 then s1767 else s1781+  s1783 :: SWord8 = if s1698 then s1748 else s1782+  s1784 :: SWord8 = s1683 + s1735+  s1785 :: SWord1 = choose [0:0] s1784+  s1786 :: SBool = s14 /= s1785+  s1787 :: SWord8 = if s1786 then s1692 else s1693+  s1788 :: SWord8 = if s17 then s1787 else s1689+  s1789 :: SWord1 = choose [0:0] s1788+  s1790 :: SBool = s14 /= s1789+  s1791 :: SBool = s_2 == s1790+  s1792 :: SBool = s1784 < s1735+  s1793 :: SBool = s1784 < s1683+  s1794 :: SBool = s1792 | s1793+  s1795 :: SWord8 = s1784 >>> 1+  s1796 :: SWord8 = s19 | s1795+  s1797 :: SWord8 = s21 & s1795+  s1798 :: SWord8 = if s1794 then s1796 else s1797+  s1799 :: SWord1 = choose [0:0] s1798+  s1800 :: SBool = s14 /= s1799+  s1801 :: SWord8 = s1788 >>> 1+  s1802 :: SWord8 = s19 | s1801+  s1803 :: SWord8 = s21 & s1801+  s1804 :: SWord8 = if s1706 then s1802 else s1803+  s1805 :: SWord8 = if s17 then s1804 else s1787+  s1806 :: SWord8 = s1805 >>> 1+  s1807 :: SWord8 = s19 | s1806+  s1808 :: SWord8 = s21 & s1806+  s1809 :: SWord8 = if s1800 then s1807 else s1808+  s1810 :: SWord8 = if s17 then s1809 else s1804+  s1811 :: SWord1 = choose [0:0] s1810+  s1812 :: SBool = s14 /= s1811+  s1813 :: SBool = s_2 == s1812+  s1814 :: SWord8 = s1798 >>> 1+  s1815 :: SWord8 = s19 | s1814+  s1816 :: SWord8 = s21 & s1814+  s1817 :: SWord8 = if s1790 then s1815 else s1816+  s1818 :: SWord8 = s1817 >>> 1+  s1819 :: SWord8 = s19 | s1818+  s1820 :: SWord8 = s21 & s1818+  s1821 :: SWord8 = if s1812 then s1819 else s1820+  s1822 :: SWord1 = choose [0:0] s1805+  s1823 :: SBool = s14 /= s1822+  s1824 :: SWord8 = s1810 >>> 1+  s1825 :: SWord8 = s19 | s1824+  s1826 :: SWord8 = s21 & s1824+  s1827 :: SWord8 = if s1823 then s1825 else s1826+  s1828 :: SWord8 = if s24 then s1787 else s1735+  s1829 :: SWord8 = if s165 then s1804 else s1828+  s1830 :: SWord8 = if s24 then s1809 else s1829+  s1831 :: SWord8 = if s165 then s1827 else s1830+  s1832 :: SWord8 = s1817 + s1831+  s1833 :: SBool = s1832 < s1831+  s1834 :: SBool = s1832 < s1817+  s1835 :: SBool = s1833 | s1834+  s1836 :: SWord8 = s1832 >>> 1+  s1837 :: SWord8 = s19 | s1836+  s1838 :: SWord8 = s21 & s1836+  s1839 :: SWord8 = if s1835 then s1837 else s1838+  s1840 :: SWord8 = if s1813 then s1821 else s1839+  s1841 :: SWord8 = s1798 + s1829+  s1842 :: SWord1 = choose [0:0] s1841+  s1843 :: SBool = s14 /= s1842+  s1844 :: SWord8 = if s1843 then s1807 else s1808+  s1845 :: SWord8 = if s17 then s1844 else s1804+  s1846 :: SWord1 = choose [0:0] s1845+  s1847 :: SBool = s14 /= s1846+  s1848 :: SBool = s_2 == s1847+  s1849 :: SBool = s1841 < s1829+  s1850 :: SBool = s1841 < s1798+  s1851 :: SBool = s1849 | s1850+  s1852 :: SWord8 = s1841 >>> 1+  s1853 :: SWord8 = s19 | s1852+  s1854 :: SWord8 = s21 & s1852+  s1855 :: SWord8 = if s1851 then s1853 else s1854+  s1856 :: SWord8 = s1855 >>> 1+  s1857 :: SWord8 = s19 | s1856+  s1858 :: SWord8 = s21 & s1856+  s1859 :: SWord8 = if s1847 then s1857 else s1858+  s1860 :: SWord8 = s1845 >>> 1+  s1861 :: SWord8 = s19 | s1860+  s1862 :: SWord8 = s21 & s1860+  s1863 :: SWord8 = if s1823 then s1861 else s1862+  s1864 :: SWord8 = if s24 then s1844 else s1829+  s1865 :: SWord8 = if s165 then s1863 else s1864+  s1866 :: SWord8 = s1855 + s1865+  s1867 :: SBool = s1866 < s1865+  s1868 :: SBool = s1866 < s1855+  s1869 :: SBool = s1867 | s1868+  s1870 :: SWord8 = s1866 >>> 1+  s1871 :: SWord8 = s19 | s1870+  s1872 :: SWord8 = s21 & s1870+  s1873 :: SWord8 = if s1869 then s1871 else s1872+  s1874 :: SWord8 = if s1848 then s1859 else s1873+  s1875 :: SWord8 = if s1791 then s1840 else s1874+  s1876 :: SWord8 = if s1676 then s1783 else s1875+  s1877 :: SWord8 = if s1445 then s1668 else s1876+  s1878 :: SWord8 = if s982 then s1437 else s1877+  s1879 :: SWord8 = if s51 then s974 else s1878+  s1880 :: SWord8 = s34 + s175+  s1881 :: SWord1 = choose [0:0] s1880+  s1882 :: SBool = s14 /= s1881+  s1883 :: SWord8 = if s1882 then s45 else s46+  s1884 :: SWord8 = if s17 then s1883 else s42+  s1885 :: SWord1 = choose [0:0] s1884+  s1886 :: SBool = s14 /= s1885+  s1887 :: SBool = s_2 == s1886+  s1888 :: SBool = s1880 < s175+  s1889 :: SBool = s1880 < s34+  s1890 :: SBool = s1888 | s1889+  s1891 :: SWord8 = s1880 >>> 1+  s1892 :: SWord8 = s19 | s1891+  s1893 :: SWord8 = s21 & s1891+  s1894 :: SWord8 = if s1890 then s1892 else s1893+  s1895 :: SWord1 = choose [0:0] s1894+  s1896 :: SBool = s14 /= s1895+  s1897 :: SWord8 = s1884 >>> 1+  s1898 :: SWord8 = s19 | s1897+  s1899 :: SWord8 = s21 & s1897+  s1900 :: SWord8 = if s59 then s1898 else s1899+  s1901 :: SWord8 = if s17 then s1900 else s1883+  s1902 :: SWord8 = s1901 >>> 1+  s1903 :: SWord8 = s19 | s1902+  s1904 :: SWord8 = s21 & s1902+  s1905 :: SWord8 = if s1896 then s1903 else s1904+  s1906 :: SWord8 = if s17 then s1905 else s1900+  s1907 :: SWord1 = choose [0:0] s1906+  s1908 :: SBool = s14 /= s1907+  s1909 :: SBool = s_2 == s1908+  s1910 :: SWord8 = s1894 >>> 1+  s1911 :: SWord8 = s19 | s1910+  s1912 :: SWord8 = s21 & s1910+  s1913 :: SWord8 = if s1886 then s1911 else s1912+  s1914 :: SWord1 = choose [0:0] s1913+  s1915 :: SBool = s14 /= s1914+  s1916 :: SWord1 = choose [0:0] s1901+  s1917 :: SBool = s14 /= s1916+  s1918 :: SWord8 = s1906 >>> 1+  s1919 :: SWord8 = s19 | s1918+  s1920 :: SWord8 = s21 & s1918+  s1921 :: SWord8 = if s1917 then s1919 else s1920+  s1922 :: SWord8 = if s17 then s1921 else s1905+  s1923 :: SWord8 = s1922 >>> 1+  s1924 :: SWord8 = s19 | s1923+  s1925 :: SWord8 = s21 & s1923+  s1926 :: SWord8 = if s1915 then s1924 else s1925+  s1927 :: SWord8 = if s17 then s1926 else s1921+  s1928 :: SWord1 = choose [0:0] s1927+  s1929 :: SBool = s14 /= s1928+  s1930 :: SBool = s_2 == s1929+  s1931 :: SWord8 = s1913 >>> 1+  s1932 :: SWord8 = s19 | s1931+  s1933 :: SWord8 = s21 & s1931+  s1934 :: SWord8 = if s1908 then s1932 else s1933+  s1935 :: SWord1 = choose [0:0] s1934+  s1936 :: SBool = s14 /= s1935+  s1937 :: SWord1 = choose [0:0] s1922+  s1938 :: SBool = s14 /= s1937+  s1939 :: SWord8 = s1927 >>> 1+  s1940 :: SWord8 = s19 | s1939+  s1941 :: SWord8 = s21 & s1939+  s1942 :: SWord8 = if s1938 then s1940 else s1941+  s1943 :: SWord8 = if s17 then s1942 else s1926+  s1944 :: SWord8 = s1943 >>> 1+  s1945 :: SWord8 = s19 | s1944+  s1946 :: SWord8 = s21 & s1944+  s1947 :: SWord8 = if s1936 then s1945 else s1946+  s1948 :: SWord8 = if s17 then s1947 else s1942+  s1949 :: SWord1 = choose [0:0] s1948+  s1950 :: SBool = s14 /= s1949+  s1951 :: SBool = s_2 == s1950+  s1952 :: SWord8 = s1934 >>> 1+  s1953 :: SWord8 = s19 | s1952+  s1954 :: SWord8 = s21 & s1952+  s1955 :: SWord8 = if s1929 then s1953 else s1954+  s1956 :: SWord1 = choose [0:0] s1955+  s1957 :: SBool = s14 /= s1956+  s1958 :: SWord1 = choose [0:0] s1943+  s1959 :: SBool = s14 /= s1958+  s1960 :: SWord8 = s1948 >>> 1+  s1961 :: SWord8 = s19 | s1960+  s1962 :: SWord8 = s21 & s1960+  s1963 :: SWord8 = if s1959 then s1961 else s1962+  s1964 :: SWord8 = if s17 then s1963 else s1947+  s1965 :: SWord8 = s1964 >>> 1+  s1966 :: SWord8 = s19 | s1965+  s1967 :: SWord8 = s21 & s1965+  s1968 :: SWord8 = if s1957 then s1966 else s1967+  s1969 :: SWord8 = if s17 then s1968 else s1963+  s1970 :: SWord1 = choose [0:0] s1969+  s1971 :: SBool = s14 /= s1970+  s1972 :: SBool = s_2 == s1971+  s1973 :: SWord8 = s1955 >>> 1+  s1974 :: SWord8 = s19 | s1973+  s1975 :: SWord8 = s21 & s1973+  s1976 :: SWord8 = if s1950 then s1974 else s1975+  s1977 :: SWord1 = choose [0:0] s1976+  s1978 :: SBool = s14 /= s1977+  s1979 :: SWord1 = choose [0:0] s1964+  s1980 :: SBool = s14 /= s1979+  s1981 :: SWord8 = s1969 >>> 1+  s1982 :: SWord8 = s19 | s1981+  s1983 :: SWord8 = s21 & s1981+  s1984 :: SWord8 = if s1980 then s1982 else s1983+  s1985 :: SWord8 = if s17 then s1984 else s1968+  s1986 :: SWord8 = s1985 >>> 1+  s1987 :: SWord8 = s19 | s1986+  s1988 :: SWord8 = s21 & s1986+  s1989 :: SWord8 = if s1978 then s1987 else s1988+  s1990 :: SWord8 = if s17 then s1989 else s1984+  s1991 :: SWord1 = choose [0:0] s1990+  s1992 :: SBool = s14 /= s1991+  s1993 :: SBool = s_2 == s1992+  s1994 :: SWord8 = s1976 >>> 1+  s1995 :: SWord8 = s19 | s1994+  s1996 :: SWord8 = s21 & s1994+  s1997 :: SWord8 = if s1971 then s1995 else s1996+  s1998 :: SWord8 = s1997 >>> 1+  s1999 :: SWord8 = s19 | s1998+  s2000 :: SWord8 = s21 & s1998+  s2001 :: SWord8 = if s1992 then s1999 else s2000+  s2002 :: SWord1 = choose [0:0] s1985+  s2003 :: SBool = s14 /= s2002+  s2004 :: SWord8 = s1990 >>> 1+  s2005 :: SWord8 = s19 | s2004+  s2006 :: SWord8 = s21 & s2004+  s2007 :: SWord8 = if s2003 then s2005 else s2006+  s2008 :: SWord8 = if s24 then s1883 else s175+  s2009 :: SWord8 = if s165 then s1900 else s2008+  s2010 :: SWord8 = if s24 then s1905 else s2009+  s2011 :: SWord8 = if s165 then s1921 else s2010+  s2012 :: SWord8 = if s24 then s1926 else s2011+  s2013 :: SWord8 = if s165 then s1942 else s2012+  s2014 :: SWord8 = if s24 then s1947 else s2013+  s2015 :: SWord8 = if s165 then s1963 else s2014+  s2016 :: SWord8 = if s24 then s1968 else s2015+  s2017 :: SWord8 = if s165 then s1984 else s2016+  s2018 :: SWord8 = if s24 then s1989 else s2017+  s2019 :: SWord8 = if s165 then s2007 else s2018+  s2020 :: SWord8 = s1997 + s2019+  s2021 :: SBool = s2020 < s2019+  s2022 :: SBool = s2020 < s1997+  s2023 :: SBool = s2021 | s2022+  s2024 :: SWord8 = s2020 >>> 1+  s2025 :: SWord8 = s19 | s2024+  s2026 :: SWord8 = s21 & s2024+  s2027 :: SWord8 = if s2023 then s2025 else s2026+  s2028 :: SWord8 = if s1993 then s2001 else s2027+  s2029 :: SWord8 = s1976 + s2017+  s2030 :: SWord1 = choose [0:0] s2029+  s2031 :: SBool = s14 /= s2030+  s2032 :: SWord8 = if s2031 then s1987 else s1988+  s2033 :: SWord8 = if s17 then s2032 else s1984+  s2034 :: SWord1 = choose [0:0] s2033+  s2035 :: SBool = s14 /= s2034+  s2036 :: SBool = s_2 == s2035+  s2037 :: SBool = s2029 < s2017+  s2038 :: SBool = s2029 < s1976+  s2039 :: SBool = s2037 | s2038+  s2040 :: SWord8 = s2029 >>> 1+  s2041 :: SWord8 = s19 | s2040+  s2042 :: SWord8 = s21 & s2040+  s2043 :: SWord8 = if s2039 then s2041 else s2042+  s2044 :: SWord8 = s2043 >>> 1+  s2045 :: SWord8 = s19 | s2044+  s2046 :: SWord8 = s21 & s2044+  s2047 :: SWord8 = if s2035 then s2045 else s2046+  s2048 :: SWord8 = s2033 >>> 1+  s2049 :: SWord8 = s19 | s2048+  s2050 :: SWord8 = s21 & s2048+  s2051 :: SWord8 = if s2003 then s2049 else s2050+  s2052 :: SWord8 = if s24 then s2032 else s2017+  s2053 :: SWord8 = if s165 then s2051 else s2052+  s2054 :: SWord8 = s2043 + s2053+  s2055 :: SBool = s2054 < s2053+  s2056 :: SBool = s2054 < s2043+  s2057 :: SBool = s2055 | s2056+  s2058 :: SWord8 = s2054 >>> 1+  s2059 :: SWord8 = s19 | s2058+  s2060 :: SWord8 = s21 & s2058+  s2061 :: SWord8 = if s2057 then s2059 else s2060+  s2062 :: SWord8 = if s2036 then s2047 else s2061+  s2063 :: SWord8 = if s1972 then s2028 else s2062+  s2064 :: SWord8 = s1955 + s2015+  s2065 :: SWord1 = choose [0:0] s2064+  s2066 :: SBool = s14 /= s2065+  s2067 :: SWord8 = if s2066 then s1966 else s1967+  s2068 :: SWord8 = if s17 then s2067 else s1963+  s2069 :: SWord1 = choose [0:0] s2068+  s2070 :: SBool = s14 /= s2069+  s2071 :: SBool = s_2 == s2070+  s2072 :: SBool = s2064 < s2015+  s2073 :: SBool = s2064 < s1955+  s2074 :: SBool = s2072 | s2073+  s2075 :: SWord8 = s2064 >>> 1+  s2076 :: SWord8 = s19 | s2075+  s2077 :: SWord8 = s21 & s2075+  s2078 :: SWord8 = if s2074 then s2076 else s2077+  s2079 :: SWord1 = choose [0:0] s2078+  s2080 :: SBool = s14 /= s2079+  s2081 :: SWord8 = s2068 >>> 1+  s2082 :: SWord8 = s19 | s2081+  s2083 :: SWord8 = s21 & s2081+  s2084 :: SWord8 = if s1980 then s2082 else s2083+  s2085 :: SWord8 = if s17 then s2084 else s2067+  s2086 :: SWord8 = s2085 >>> 1+  s2087 :: SWord8 = s19 | s2086+  s2088 :: SWord8 = s21 & s2086+  s2089 :: SWord8 = if s2080 then s2087 else s2088+  s2090 :: SWord8 = if s17 then s2089 else s2084+  s2091 :: SWord1 = choose [0:0] s2090+  s2092 :: SBool = s14 /= s2091+  s2093 :: SBool = s_2 == s2092+  s2094 :: SWord8 = s2078 >>> 1+  s2095 :: SWord8 = s19 | s2094+  s2096 :: SWord8 = s21 & s2094+  s2097 :: SWord8 = if s2070 then s2095 else s2096+  s2098 :: SWord8 = s2097 >>> 1+  s2099 :: SWord8 = s19 | s2098+  s2100 :: SWord8 = s21 & s2098+  s2101 :: SWord8 = if s2092 then s2099 else s2100+  s2102 :: SWord1 = choose [0:0] s2085+  s2103 :: SBool = s14 /= s2102+  s2104 :: SWord8 = s2090 >>> 1+  s2105 :: SWord8 = s19 | s2104+  s2106 :: SWord8 = s21 & s2104+  s2107 :: SWord8 = if s2103 then s2105 else s2106+  s2108 :: SWord8 = if s24 then s2067 else s2015+  s2109 :: SWord8 = if s165 then s2084 else s2108+  s2110 :: SWord8 = if s24 then s2089 else s2109+  s2111 :: SWord8 = if s165 then s2107 else s2110+  s2112 :: SWord8 = s2097 + s2111+  s2113 :: SBool = s2112 < s2111+  s2114 :: SBool = s2112 < s2097+  s2115 :: SBool = s2113 | s2114+  s2116 :: SWord8 = s2112 >>> 1+  s2117 :: SWord8 = s19 | s2116+  s2118 :: SWord8 = s21 & s2116+  s2119 :: SWord8 = if s2115 then s2117 else s2118+  s2120 :: SWord8 = if s2093 then s2101 else s2119+  s2121 :: SWord8 = s2078 + s2109+  s2122 :: SWord1 = choose [0:0] s2121+  s2123 :: SBool = s14 /= s2122+  s2124 :: SWord8 = if s2123 then s2087 else s2088+  s2125 :: SWord8 = if s17 then s2124 else s2084+  s2126 :: SWord1 = choose [0:0] s2125+  s2127 :: SBool = s14 /= s2126+  s2128 :: SBool = s_2 == s2127+  s2129 :: SBool = s2121 < s2109+  s2130 :: SBool = s2121 < s2078+  s2131 :: SBool = s2129 | s2130+  s2132 :: SWord8 = s2121 >>> 1+  s2133 :: SWord8 = s19 | s2132+  s2134 :: SWord8 = s21 & s2132+  s2135 :: SWord8 = if s2131 then s2133 else s2134+  s2136 :: SWord8 = s2135 >>> 1+  s2137 :: SWord8 = s19 | s2136+  s2138 :: SWord8 = s21 & s2136+  s2139 :: SWord8 = if s2127 then s2137 else s2138+  s2140 :: SWord8 = s2125 >>> 1+  s2141 :: SWord8 = s19 | s2140+  s2142 :: SWord8 = s21 & s2140+  s2143 :: SWord8 = if s2103 then s2141 else s2142+  s2144 :: SWord8 = if s24 then s2124 else s2109+  s2145 :: SWord8 = if s165 then s2143 else s2144+  s2146 :: SWord8 = s2135 + s2145+  s2147 :: SBool = s2146 < s2145+  s2148 :: SBool = s2146 < s2135+  s2149 :: SBool = s2147 | s2148+  s2150 :: SWord8 = s2146 >>> 1+  s2151 :: SWord8 = s19 | s2150+  s2152 :: SWord8 = s21 & s2150+  s2153 :: SWord8 = if s2149 then s2151 else s2152+  s2154 :: SWord8 = if s2128 then s2139 else s2153+  s2155 :: SWord8 = if s2071 then s2120 else s2154+  s2156 :: SWord8 = if s1951 then s2063 else s2155+  s2157 :: SWord8 = s1934 + s2013+  s2158 :: SWord1 = choose [0:0] s2157+  s2159 :: SBool = s14 /= s2158+  s2160 :: SWord8 = if s2159 then s1945 else s1946+  s2161 :: SWord8 = if s17 then s2160 else s1942+  s2162 :: SWord1 = choose [0:0] s2161+  s2163 :: SBool = s14 /= s2162+  s2164 :: SBool = s_2 == s2163+  s2165 :: SBool = s2157 < s2013+  s2166 :: SBool = s2157 < s1934+  s2167 :: SBool = s2165 | s2166+  s2168 :: SWord8 = s2157 >>> 1+  s2169 :: SWord8 = s19 | s2168+  s2170 :: SWord8 = s21 & s2168+  s2171 :: SWord8 = if s2167 then s2169 else s2170+  s2172 :: SWord1 = choose [0:0] s2171+  s2173 :: SBool = s14 /= s2172+  s2174 :: SWord8 = s2161 >>> 1+  s2175 :: SWord8 = s19 | s2174+  s2176 :: SWord8 = s21 & s2174+  s2177 :: SWord8 = if s1959 then s2175 else s2176+  s2178 :: SWord8 = if s17 then s2177 else s2160+  s2179 :: SWord8 = s2178 >>> 1+  s2180 :: SWord8 = s19 | s2179+  s2181 :: SWord8 = s21 & s2179+  s2182 :: SWord8 = if s2173 then s2180 else s2181+  s2183 :: SWord8 = if s17 then s2182 else s2177+  s2184 :: SWord1 = choose [0:0] s2183+  s2185 :: SBool = s14 /= s2184+  s2186 :: SBool = s_2 == s2185+  s2187 :: SWord8 = s2171 >>> 1+  s2188 :: SWord8 = s19 | s2187+  s2189 :: SWord8 = s21 & s2187+  s2190 :: SWord8 = if s2163 then s2188 else s2189+  s2191 :: SWord1 = choose [0:0] s2190+  s2192 :: SBool = s14 /= s2191+  s2193 :: SWord1 = choose [0:0] s2178+  s2194 :: SBool = s14 /= s2193+  s2195 :: SWord8 = s2183 >>> 1+  s2196 :: SWord8 = s19 | s2195+  s2197 :: SWord8 = s21 & s2195+  s2198 :: SWord8 = if s2194 then s2196 else s2197+  s2199 :: SWord8 = if s17 then s2198 else s2182+  s2200 :: SWord8 = s2199 >>> 1+  s2201 :: SWord8 = s19 | s2200+  s2202 :: SWord8 = s21 & s2200+  s2203 :: SWord8 = if s2192 then s2201 else s2202+  s2204 :: SWord8 = if s17 then s2203 else s2198+  s2205 :: SWord1 = choose [0:0] s2204+  s2206 :: SBool = s14 /= s2205+  s2207 :: SBool = s_2 == s2206+  s2208 :: SWord8 = s2190 >>> 1+  s2209 :: SWord8 = s19 | s2208+  s2210 :: SWord8 = s21 & s2208+  s2211 :: SWord8 = if s2185 then s2209 else s2210+  s2212 :: SWord8 = s2211 >>> 1+  s2213 :: SWord8 = s19 | s2212+  s2214 :: SWord8 = s21 & s2212+  s2215 :: SWord8 = if s2206 then s2213 else s2214+  s2216 :: SWord1 = choose [0:0] s2199+  s2217 :: SBool = s14 /= s2216+  s2218 :: SWord8 = s2204 >>> 1+  s2219 :: SWord8 = s19 | s2218+  s2220 :: SWord8 = s21 & s2218+  s2221 :: SWord8 = if s2217 then s2219 else s2220+  s2222 :: SWord8 = if s24 then s2160 else s2013+  s2223 :: SWord8 = if s165 then s2177 else s2222+  s2224 :: SWord8 = if s24 then s2182 else s2223+  s2225 :: SWord8 = if s165 then s2198 else s2224+  s2226 :: SWord8 = if s24 then s2203 else s2225+  s2227 :: SWord8 = if s165 then s2221 else s2226+  s2228 :: SWord8 = s2211 + s2227+  s2229 :: SBool = s2228 < s2227+  s2230 :: SBool = s2228 < s2211+  s2231 :: SBool = s2229 | s2230+  s2232 :: SWord8 = s2228 >>> 1+  s2233 :: SWord8 = s19 | s2232+  s2234 :: SWord8 = s21 & s2232+  s2235 :: SWord8 = if s2231 then s2233 else s2234+  s2236 :: SWord8 = if s2207 then s2215 else s2235+  s2237 :: SWord8 = s2190 + s2225+  s2238 :: SWord1 = choose [0:0] s2237+  s2239 :: SBool = s14 /= s2238+  s2240 :: SWord8 = if s2239 then s2201 else s2202+  s2241 :: SWord8 = if s17 then s2240 else s2198+  s2242 :: SWord1 = choose [0:0] s2241+  s2243 :: SBool = s14 /= s2242+  s2244 :: SBool = s_2 == s2243+  s2245 :: SBool = s2237 < s2225+  s2246 :: SBool = s2237 < s2190+  s2247 :: SBool = s2245 | s2246+  s2248 :: SWord8 = s2237 >>> 1+  s2249 :: SWord8 = s19 | s2248+  s2250 :: SWord8 = s21 & s2248+  s2251 :: SWord8 = if s2247 then s2249 else s2250+  s2252 :: SWord8 = s2251 >>> 1+  s2253 :: SWord8 = s19 | s2252+  s2254 :: SWord8 = s21 & s2252+  s2255 :: SWord8 = if s2243 then s2253 else s2254+  s2256 :: SWord8 = s2241 >>> 1+  s2257 :: SWord8 = s19 | s2256+  s2258 :: SWord8 = s21 & s2256+  s2259 :: SWord8 = if s2217 then s2257 else s2258+  s2260 :: SWord8 = if s24 then s2240 else s2225+  s2261 :: SWord8 = if s165 then s2259 else s2260+  s2262 :: SWord8 = s2251 + s2261+  s2263 :: SBool = s2262 < s2261+  s2264 :: SBool = s2262 < s2251+  s2265 :: SBool = s2263 | s2264+  s2266 :: SWord8 = s2262 >>> 1+  s2267 :: SWord8 = s19 | s2266+  s2268 :: SWord8 = s21 & s2266+  s2269 :: SWord8 = if s2265 then s2267 else s2268+  s2270 :: SWord8 = if s2244 then s2255 else s2269+  s2271 :: SWord8 = if s2186 then s2236 else s2270+  s2272 :: SWord8 = s2171 + s2223+  s2273 :: SWord1 = choose [0:0] s2272+  s2274 :: SBool = s14 /= s2273+  s2275 :: SWord8 = if s2274 then s2180 else s2181+  s2276 :: SWord8 = if s17 then s2275 else s2177+  s2277 :: SWord1 = choose [0:0] s2276+  s2278 :: SBool = s14 /= s2277+  s2279 :: SBool = s_2 == s2278+  s2280 :: SBool = s2272 < s2223+  s2281 :: SBool = s2272 < s2171+  s2282 :: SBool = s2280 | s2281+  s2283 :: SWord8 = s2272 >>> 1+  s2284 :: SWord8 = s19 | s2283+  s2285 :: SWord8 = s21 & s2283+  s2286 :: SWord8 = if s2282 then s2284 else s2285+  s2287 :: SWord1 = choose [0:0] s2286+  s2288 :: SBool = s14 /= s2287+  s2289 :: SWord8 = s2276 >>> 1+  s2290 :: SWord8 = s19 | s2289+  s2291 :: SWord8 = s21 & s2289+  s2292 :: SWord8 = if s2194 then s2290 else s2291+  s2293 :: SWord8 = if s17 then s2292 else s2275+  s2294 :: SWord8 = s2293 >>> 1+  s2295 :: SWord8 = s19 | s2294+  s2296 :: SWord8 = s21 & s2294+  s2297 :: SWord8 = if s2288 then s2295 else s2296+  s2298 :: SWord8 = if s17 then s2297 else s2292+  s2299 :: SWord1 = choose [0:0] s2298+  s2300 :: SBool = s14 /= s2299+  s2301 :: SBool = s_2 == s2300+  s2302 :: SWord8 = s2286 >>> 1+  s2303 :: SWord8 = s19 | s2302+  s2304 :: SWord8 = s21 & s2302+  s2305 :: SWord8 = if s2278 then s2303 else s2304+  s2306 :: SWord8 = s2305 >>> 1+  s2307 :: SWord8 = s19 | s2306+  s2308 :: SWord8 = s21 & s2306+  s2309 :: SWord8 = if s2300 then s2307 else s2308+  s2310 :: SWord1 = choose [0:0] s2293+  s2311 :: SBool = s14 /= s2310+  s2312 :: SWord8 = s2298 >>> 1+  s2313 :: SWord8 = s19 | s2312+  s2314 :: SWord8 = s21 & s2312+  s2315 :: SWord8 = if s2311 then s2313 else s2314+  s2316 :: SWord8 = if s24 then s2275 else s2223+  s2317 :: SWord8 = if s165 then s2292 else s2316+  s2318 :: SWord8 = if s24 then s2297 else s2317+  s2319 :: SWord8 = if s165 then s2315 else s2318+  s2320 :: SWord8 = s2305 + s2319+  s2321 :: SBool = s2320 < s2319+  s2322 :: SBool = s2320 < s2305+  s2323 :: SBool = s2321 | s2322+  s2324 :: SWord8 = s2320 >>> 1+  s2325 :: SWord8 = s19 | s2324+  s2326 :: SWord8 = s21 & s2324+  s2327 :: SWord8 = if s2323 then s2325 else s2326+  s2328 :: SWord8 = if s2301 then s2309 else s2327+  s2329 :: SWord8 = s2286 + s2317+  s2330 :: SWord1 = choose [0:0] s2329+  s2331 :: SBool = s14 /= s2330+  s2332 :: SWord8 = if s2331 then s2295 else s2296+  s2333 :: SWord8 = if s17 then s2332 else s2292+  s2334 :: SWord1 = choose [0:0] s2333+  s2335 :: SBool = s14 /= s2334+  s2336 :: SBool = s_2 == s2335+  s2337 :: SBool = s2329 < s2317+  s2338 :: SBool = s2329 < s2286+  s2339 :: SBool = s2337 | s2338+  s2340 :: SWord8 = s2329 >>> 1+  s2341 :: SWord8 = s19 | s2340+  s2342 :: SWord8 = s21 & s2340+  s2343 :: SWord8 = if s2339 then s2341 else s2342+  s2344 :: SWord8 = s2343 >>> 1+  s2345 :: SWord8 = s19 | s2344+  s2346 :: SWord8 = s21 & s2344+  s2347 :: SWord8 = if s2335 then s2345 else s2346+  s2348 :: SWord8 = s2333 >>> 1+  s2349 :: SWord8 = s19 | s2348+  s2350 :: SWord8 = s21 & s2348+  s2351 :: SWord8 = if s2311 then s2349 else s2350+  s2352 :: SWord8 = if s24 then s2332 else s2317+  s2353 :: SWord8 = if s165 then s2351 else s2352+  s2354 :: SWord8 = s2343 + s2353+  s2355 :: SBool = s2354 < s2353+  s2356 :: SBool = s2354 < s2343+  s2357 :: SBool = s2355 | s2356+  s2358 :: SWord8 = s2354 >>> 1+  s2359 :: SWord8 = s19 | s2358+  s2360 :: SWord8 = s21 & s2358+  s2361 :: SWord8 = if s2357 then s2359 else s2360+  s2362 :: SWord8 = if s2336 then s2347 else s2361+  s2363 :: SWord8 = if s2279 then s2328 else s2362+  s2364 :: SWord8 = if s2164 then s2271 else s2363+  s2365 :: SWord8 = if s1930 then s2156 else s2364+  s2366 :: SWord8 = s1913 + s2011+  s2367 :: SWord1 = choose [0:0] s2366+  s2368 :: SBool = s14 /= s2367+  s2369 :: SWord8 = if s2368 then s1924 else s1925+  s2370 :: SWord8 = if s17 then s2369 else s1921+  s2371 :: SWord1 = choose [0:0] s2370+  s2372 :: SBool = s14 /= s2371+  s2373 :: SBool = s_2 == s2372+  s2374 :: SBool = s2366 < s2011+  s2375 :: SBool = s2366 < s1913+  s2376 :: SBool = s2374 | s2375+  s2377 :: SWord8 = s2366 >>> 1+  s2378 :: SWord8 = s19 | s2377+  s2379 :: SWord8 = s21 & s2377+  s2380 :: SWord8 = if s2376 then s2378 else s2379+  s2381 :: SWord1 = choose [0:0] s2380+  s2382 :: SBool = s14 /= s2381+  s2383 :: SWord8 = s2370 >>> 1+  s2384 :: SWord8 = s19 | s2383+  s2385 :: SWord8 = s21 & s2383+  s2386 :: SWord8 = if s1938 then s2384 else s2385+  s2387 :: SWord8 = if s17 then s2386 else s2369+  s2388 :: SWord8 = s2387 >>> 1+  s2389 :: SWord8 = s19 | s2388+  s2390 :: SWord8 = s21 & s2388+  s2391 :: SWord8 = if s2382 then s2389 else s2390+  s2392 :: SWord8 = if s17 then s2391 else s2386+  s2393 :: SWord1 = choose [0:0] s2392+  s2394 :: SBool = s14 /= s2393+  s2395 :: SBool = s_2 == s2394+  s2396 :: SWord8 = s2380 >>> 1+  s2397 :: SWord8 = s19 | s2396+  s2398 :: SWord8 = s21 & s2396+  s2399 :: SWord8 = if s2372 then s2397 else s2398+  s2400 :: SWord1 = choose [0:0] s2399+  s2401 :: SBool = s14 /= s2400+  s2402 :: SWord1 = choose [0:0] s2387+  s2403 :: SBool = s14 /= s2402+  s2404 :: SWord8 = s2392 >>> 1+  s2405 :: SWord8 = s19 | s2404+  s2406 :: SWord8 = s21 & s2404+  s2407 :: SWord8 = if s2403 then s2405 else s2406+  s2408 :: SWord8 = if s17 then s2407 else s2391+  s2409 :: SWord8 = s2408 >>> 1+  s2410 :: SWord8 = s19 | s2409+  s2411 :: SWord8 = s21 & s2409+  s2412 :: SWord8 = if s2401 then s2410 else s2411+  s2413 :: SWord8 = if s17 then s2412 else s2407+  s2414 :: SWord1 = choose [0:0] s2413+  s2415 :: SBool = s14 /= s2414+  s2416 :: SBool = s_2 == s2415+  s2417 :: SWord8 = s2399 >>> 1+  s2418 :: SWord8 = s19 | s2417+  s2419 :: SWord8 = s21 & s2417+  s2420 :: SWord8 = if s2394 then s2418 else s2419+  s2421 :: SWord1 = choose [0:0] s2420+  s2422 :: SBool = s14 /= s2421+  s2423 :: SWord1 = choose [0:0] s2408+  s2424 :: SBool = s14 /= s2423+  s2425 :: SWord8 = s2413 >>> 1+  s2426 :: SWord8 = s19 | s2425+  s2427 :: SWord8 = s21 & s2425+  s2428 :: SWord8 = if s2424 then s2426 else s2427+  s2429 :: SWord8 = if s17 then s2428 else s2412+  s2430 :: SWord8 = s2429 >>> 1+  s2431 :: SWord8 = s19 | s2430+  s2432 :: SWord8 = s21 & s2430+  s2433 :: SWord8 = if s2422 then s2431 else s2432+  s2434 :: SWord8 = if s17 then s2433 else s2428+  s2435 :: SWord1 = choose [0:0] s2434+  s2436 :: SBool = s14 /= s2435+  s2437 :: SBool = s_2 == s2436+  s2438 :: SWord8 = s2420 >>> 1+  s2439 :: SWord8 = s19 | s2438+  s2440 :: SWord8 = s21 & s2438+  s2441 :: SWord8 = if s2415 then s2439 else s2440+  s2442 :: SWord8 = s2441 >>> 1+  s2443 :: SWord8 = s19 | s2442+  s2444 :: SWord8 = s21 & s2442+  s2445 :: SWord8 = if s2436 then s2443 else s2444+  s2446 :: SWord1 = choose [0:0] s2429+  s2447 :: SBool = s14 /= s2446+  s2448 :: SWord8 = s2434 >>> 1+  s2449 :: SWord8 = s19 | s2448+  s2450 :: SWord8 = s21 & s2448+  s2451 :: SWord8 = if s2447 then s2449 else s2450+  s2452 :: SWord8 = if s24 then s2369 else s2011+  s2453 :: SWord8 = if s165 then s2386 else s2452+  s2454 :: SWord8 = if s24 then s2391 else s2453+  s2455 :: SWord8 = if s165 then s2407 else s2454+  s2456 :: SWord8 = if s24 then s2412 else s2455+  s2457 :: SWord8 = if s165 then s2428 else s2456+  s2458 :: SWord8 = if s24 then s2433 else s2457+  s2459 :: SWord8 = if s165 then s2451 else s2458+  s2460 :: SWord8 = s2441 + s2459+  s2461 :: SBool = s2460 < s2459+  s2462 :: SBool = s2460 < s2441+  s2463 :: SBool = s2461 | s2462+  s2464 :: SWord8 = s2460 >>> 1+  s2465 :: SWord8 = s19 | s2464+  s2466 :: SWord8 = s21 & s2464+  s2467 :: SWord8 = if s2463 then s2465 else s2466+  s2468 :: SWord8 = if s2437 then s2445 else s2467+  s2469 :: SWord8 = s2420 + s2457+  s2470 :: SWord1 = choose [0:0] s2469+  s2471 :: SBool = s14 /= s2470+  s2472 :: SWord8 = if s2471 then s2431 else s2432+  s2473 :: SWord8 = if s17 then s2472 else s2428+  s2474 :: SWord1 = choose [0:0] s2473+  s2475 :: SBool = s14 /= s2474+  s2476 :: SBool = s_2 == s2475+  s2477 :: SBool = s2469 < s2457+  s2478 :: SBool = s2469 < s2420+  s2479 :: SBool = s2477 | s2478+  s2480 :: SWord8 = s2469 >>> 1+  s2481 :: SWord8 = s19 | s2480+  s2482 :: SWord8 = s21 & s2480+  s2483 :: SWord8 = if s2479 then s2481 else s2482+  s2484 :: SWord8 = s2483 >>> 1+  s2485 :: SWord8 = s19 | s2484+  s2486 :: SWord8 = s21 & s2484+  s2487 :: SWord8 = if s2475 then s2485 else s2486+  s2488 :: SWord8 = s2473 >>> 1+  s2489 :: SWord8 = s19 | s2488+  s2490 :: SWord8 = s21 & s2488+  s2491 :: SWord8 = if s2447 then s2489 else s2490+  s2492 :: SWord8 = if s24 then s2472 else s2457+  s2493 :: SWord8 = if s165 then s2491 else s2492+  s2494 :: SWord8 = s2483 + s2493+  s2495 :: SBool = s2494 < s2493+  s2496 :: SBool = s2494 < s2483+  s2497 :: SBool = s2495 | s2496+  s2498 :: SWord8 = s2494 >>> 1+  s2499 :: SWord8 = s19 | s2498+  s2500 :: SWord8 = s21 & s2498+  s2501 :: SWord8 = if s2497 then s2499 else s2500+  s2502 :: SWord8 = if s2476 then s2487 else s2501+  s2503 :: SWord8 = if s2416 then s2468 else s2502+  s2504 :: SWord8 = s2399 + s2455+  s2505 :: SWord1 = choose [0:0] s2504+  s2506 :: SBool = s14 /= s2505+  s2507 :: SWord8 = if s2506 then s2410 else s2411+  s2508 :: SWord8 = if s17 then s2507 else s2407+  s2509 :: SWord1 = choose [0:0] s2508+  s2510 :: SBool = s14 /= s2509+  s2511 :: SBool = s_2 == s2510+  s2512 :: SBool = s2504 < s2455+  s2513 :: SBool = s2504 < s2399+  s2514 :: SBool = s2512 | s2513+  s2515 :: SWord8 = s2504 >>> 1+  s2516 :: SWord8 = s19 | s2515+  s2517 :: SWord8 = s21 & s2515+  s2518 :: SWord8 = if s2514 then s2516 else s2517+  s2519 :: SWord1 = choose [0:0] s2518+  s2520 :: SBool = s14 /= s2519+  s2521 :: SWord8 = s2508 >>> 1+  s2522 :: SWord8 = s19 | s2521+  s2523 :: SWord8 = s21 & s2521+  s2524 :: SWord8 = if s2424 then s2522 else s2523+  s2525 :: SWord8 = if s17 then s2524 else s2507+  s2526 :: SWord8 = s2525 >>> 1+  s2527 :: SWord8 = s19 | s2526+  s2528 :: SWord8 = s21 & s2526+  s2529 :: SWord8 = if s2520 then s2527 else s2528+  s2530 :: SWord8 = if s17 then s2529 else s2524+  s2531 :: SWord1 = choose [0:0] s2530+  s2532 :: SBool = s14 /= s2531+  s2533 :: SBool = s_2 == s2532+  s2534 :: SWord8 = s2518 >>> 1+  s2535 :: SWord8 = s19 | s2534+  s2536 :: SWord8 = s21 & s2534+  s2537 :: SWord8 = if s2510 then s2535 else s2536+  s2538 :: SWord8 = s2537 >>> 1+  s2539 :: SWord8 = s19 | s2538+  s2540 :: SWord8 = s21 & s2538+  s2541 :: SWord8 = if s2532 then s2539 else s2540+  s2542 :: SWord1 = choose [0:0] s2525+  s2543 :: SBool = s14 /= s2542+  s2544 :: SWord8 = s2530 >>> 1+  s2545 :: SWord8 = s19 | s2544+  s2546 :: SWord8 = s21 & s2544+  s2547 :: SWord8 = if s2543 then s2545 else s2546+  s2548 :: SWord8 = if s24 then s2507 else s2455+  s2549 :: SWord8 = if s165 then s2524 else s2548+  s2550 :: SWord8 = if s24 then s2529 else s2549+  s2551 :: SWord8 = if s165 then s2547 else s2550+  s2552 :: SWord8 = s2537 + s2551+  s2553 :: SBool = s2552 < s2551+  s2554 :: SBool = s2552 < s2537+  s2555 :: SBool = s2553 | s2554+  s2556 :: SWord8 = s2552 >>> 1+  s2557 :: SWord8 = s19 | s2556+  s2558 :: SWord8 = s21 & s2556+  s2559 :: SWord8 = if s2555 then s2557 else s2558+  s2560 :: SWord8 = if s2533 then s2541 else s2559+  s2561 :: SWord8 = s2518 + s2549+  s2562 :: SWord1 = choose [0:0] s2561+  s2563 :: SBool = s14 /= s2562+  s2564 :: SWord8 = if s2563 then s2527 else s2528+  s2565 :: SWord8 = if s17 then s2564 else s2524+  s2566 :: SWord1 = choose [0:0] s2565+  s2567 :: SBool = s14 /= s2566+  s2568 :: SBool = s_2 == s2567+  s2569 :: SBool = s2561 < s2549+  s2570 :: SBool = s2561 < s2518+  s2571 :: SBool = s2569 | s2570+  s2572 :: SWord8 = s2561 >>> 1+  s2573 :: SWord8 = s19 | s2572+  s2574 :: SWord8 = s21 & s2572+  s2575 :: SWord8 = if s2571 then s2573 else s2574+  s2576 :: SWord8 = s2575 >>> 1+  s2577 :: SWord8 = s19 | s2576+  s2578 :: SWord8 = s21 & s2576+  s2579 :: SWord8 = if s2567 then s2577 else s2578+  s2580 :: SWord8 = s2565 >>> 1+  s2581 :: SWord8 = s19 | s2580+  s2582 :: SWord8 = s21 & s2580+  s2583 :: SWord8 = if s2543 then s2581 else s2582+  s2584 :: SWord8 = if s24 then s2564 else s2549+  s2585 :: SWord8 = if s165 then s2583 else s2584+  s2586 :: SWord8 = s2575 + s2585+  s2587 :: SBool = s2586 < s2585+  s2588 :: SBool = s2586 < s2575+  s2589 :: SBool = s2587 | s2588+  s2590 :: SWord8 = s2586 >>> 1+  s2591 :: SWord8 = s19 | s2590+  s2592 :: SWord8 = s21 & s2590+  s2593 :: SWord8 = if s2589 then s2591 else s2592+  s2594 :: SWord8 = if s2568 then s2579 else s2593+  s2595 :: SWord8 = if s2511 then s2560 else s2594+  s2596 :: SWord8 = if s2395 then s2503 else s2595+  s2597 :: SWord8 = s2380 + s2453+  s2598 :: SWord1 = choose [0:0] s2597+  s2599 :: SBool = s14 /= s2598+  s2600 :: SWord8 = if s2599 then s2389 else s2390+  s2601 :: SWord8 = if s17 then s2600 else s2386+  s2602 :: SWord1 = choose [0:0] s2601+  s2603 :: SBool = s14 /= s2602+  s2604 :: SBool = s_2 == s2603+  s2605 :: SBool = s2597 < s2453+  s2606 :: SBool = s2597 < s2380+  s2607 :: SBool = s2605 | s2606+  s2608 :: SWord8 = s2597 >>> 1+  s2609 :: SWord8 = s19 | s2608+  s2610 :: SWord8 = s21 & s2608+  s2611 :: SWord8 = if s2607 then s2609 else s2610+  s2612 :: SWord1 = choose [0:0] s2611+  s2613 :: SBool = s14 /= s2612+  s2614 :: SWord8 = s2601 >>> 1+  s2615 :: SWord8 = s19 | s2614+  s2616 :: SWord8 = s21 & s2614+  s2617 :: SWord8 = if s2403 then s2615 else s2616+  s2618 :: SWord8 = if s17 then s2617 else s2600+  s2619 :: SWord8 = s2618 >>> 1+  s2620 :: SWord8 = s19 | s2619+  s2621 :: SWord8 = s21 & s2619+  s2622 :: SWord8 = if s2613 then s2620 else s2621+  s2623 :: SWord8 = if s17 then s2622 else s2617+  s2624 :: SWord1 = choose [0:0] s2623+  s2625 :: SBool = s14 /= s2624+  s2626 :: SBool = s_2 == s2625+  s2627 :: SWord8 = s2611 >>> 1+  s2628 :: SWord8 = s19 | s2627+  s2629 :: SWord8 = s21 & s2627+  s2630 :: SWord8 = if s2603 then s2628 else s2629+  s2631 :: SWord1 = choose [0:0] s2630+  s2632 :: SBool = s14 /= s2631+  s2633 :: SWord1 = choose [0:0] s2618+  s2634 :: SBool = s14 /= s2633+  s2635 :: SWord8 = s2623 >>> 1+  s2636 :: SWord8 = s19 | s2635+  s2637 :: SWord8 = s21 & s2635+  s2638 :: SWord8 = if s2634 then s2636 else s2637+  s2639 :: SWord8 = if s17 then s2638 else s2622+  s2640 :: SWord8 = s2639 >>> 1+  s2641 :: SWord8 = s19 | s2640+  s2642 :: SWord8 = s21 & s2640+  s2643 :: SWord8 = if s2632 then s2641 else s2642+  s2644 :: SWord8 = if s17 then s2643 else s2638+  s2645 :: SWord1 = choose [0:0] s2644+  s2646 :: SBool = s14 /= s2645+  s2647 :: SBool = s_2 == s2646+  s2648 :: SWord8 = s2630 >>> 1+  s2649 :: SWord8 = s19 | s2648+  s2650 :: SWord8 = s21 & s2648+  s2651 :: SWord8 = if s2625 then s2649 else s2650+  s2652 :: SWord8 = s2651 >>> 1+  s2653 :: SWord8 = s19 | s2652+  s2654 :: SWord8 = s21 & s2652+  s2655 :: SWord8 = if s2646 then s2653 else s2654+  s2656 :: SWord1 = choose [0:0] s2639+  s2657 :: SBool = s14 /= s2656+  s2658 :: SWord8 = s2644 >>> 1+  s2659 :: SWord8 = s19 | s2658+  s2660 :: SWord8 = s21 & s2658+  s2661 :: SWord8 = if s2657 then s2659 else s2660+  s2662 :: SWord8 = if s24 then s2600 else s2453+  s2663 :: SWord8 = if s165 then s2617 else s2662+  s2664 :: SWord8 = if s24 then s2622 else s2663+  s2665 :: SWord8 = if s165 then s2638 else s2664+  s2666 :: SWord8 = if s24 then s2643 else s2665+  s2667 :: SWord8 = if s165 then s2661 else s2666+  s2668 :: SWord8 = s2651 + s2667+  s2669 :: SBool = s2668 < s2667+  s2670 :: SBool = s2668 < s2651+  s2671 :: SBool = s2669 | s2670+  s2672 :: SWord8 = s2668 >>> 1+  s2673 :: SWord8 = s19 | s2672+  s2674 :: SWord8 = s21 & s2672+  s2675 :: SWord8 = if s2671 then s2673 else s2674+  s2676 :: SWord8 = if s2647 then s2655 else s2675+  s2677 :: SWord8 = s2630 + s2665+  s2678 :: SWord1 = choose [0:0] s2677+  s2679 :: SBool = s14 /= s2678+  s2680 :: SWord8 = if s2679 then s2641 else s2642+  s2681 :: SWord8 = if s17 then s2680 else s2638+  s2682 :: SWord1 = choose [0:0] s2681+  s2683 :: SBool = s14 /= s2682+  s2684 :: SBool = s_2 == s2683+  s2685 :: SBool = s2677 < s2665+  s2686 :: SBool = s2677 < s2630+  s2687 :: SBool = s2685 | s2686+  s2688 :: SWord8 = s2677 >>> 1+  s2689 :: SWord8 = s19 | s2688+  s2690 :: SWord8 = s21 & s2688+  s2691 :: SWord8 = if s2687 then s2689 else s2690+  s2692 :: SWord8 = s2691 >>> 1+  s2693 :: SWord8 = s19 | s2692+  s2694 :: SWord8 = s21 & s2692+  s2695 :: SWord8 = if s2683 then s2693 else s2694+  s2696 :: SWord8 = s2681 >>> 1+  s2697 :: SWord8 = s19 | s2696+  s2698 :: SWord8 = s21 & s2696+  s2699 :: SWord8 = if s2657 then s2697 else s2698+  s2700 :: SWord8 = if s24 then s2680 else s2665+  s2701 :: SWord8 = if s165 then s2699 else s2700+  s2702 :: SWord8 = s2691 + s2701+  s2703 :: SBool = s2702 < s2701+  s2704 :: SBool = s2702 < s2691+  s2705 :: SBool = s2703 | s2704+  s2706 :: SWord8 = s2702 >>> 1+  s2707 :: SWord8 = s19 | s2706+  s2708 :: SWord8 = s21 & s2706+  s2709 :: SWord8 = if s2705 then s2707 else s2708+  s2710 :: SWord8 = if s2684 then s2695 else s2709+  s2711 :: SWord8 = if s2626 then s2676 else s2710+  s2712 :: SWord8 = s2611 + s2663+  s2713 :: SWord1 = choose [0:0] s2712+  s2714 :: SBool = s14 /= s2713+  s2715 :: SWord8 = if s2714 then s2620 else s2621+  s2716 :: SWord8 = if s17 then s2715 else s2617+  s2717 :: SWord1 = choose [0:0] s2716+  s2718 :: SBool = s14 /= s2717+  s2719 :: SBool = s_2 == s2718+  s2720 :: SBool = s2712 < s2663+  s2721 :: SBool = s2712 < s2611+  s2722 :: SBool = s2720 | s2721+  s2723 :: SWord8 = s2712 >>> 1+  s2724 :: SWord8 = s19 | s2723+  s2725 :: SWord8 = s21 & s2723+  s2726 :: SWord8 = if s2722 then s2724 else s2725+  s2727 :: SWord1 = choose [0:0] s2726+  s2728 :: SBool = s14 /= s2727+  s2729 :: SWord8 = s2716 >>> 1+  s2730 :: SWord8 = s19 | s2729+  s2731 :: SWord8 = s21 & s2729+  s2732 :: SWord8 = if s2634 then s2730 else s2731+  s2733 :: SWord8 = if s17 then s2732 else s2715+  s2734 :: SWord8 = s2733 >>> 1+  s2735 :: SWord8 = s19 | s2734+  s2736 :: SWord8 = s21 & s2734+  s2737 :: SWord8 = if s2728 then s2735 else s2736+  s2738 :: SWord8 = if s17 then s2737 else s2732+  s2739 :: SWord1 = choose [0:0] s2738+  s2740 :: SBool = s14 /= s2739+  s2741 :: SBool = s_2 == s2740+  s2742 :: SWord8 = s2726 >>> 1+  s2743 :: SWord8 = s19 | s2742+  s2744 :: SWord8 = s21 & s2742+  s2745 :: SWord8 = if s2718 then s2743 else s2744+  s2746 :: SWord8 = s2745 >>> 1+  s2747 :: SWord8 = s19 | s2746+  s2748 :: SWord8 = s21 & s2746+  s2749 :: SWord8 = if s2740 then s2747 else s2748+  s2750 :: SWord1 = choose [0:0] s2733+  s2751 :: SBool = s14 /= s2750+  s2752 :: SWord8 = s2738 >>> 1+  s2753 :: SWord8 = s19 | s2752+  s2754 :: SWord8 = s21 & s2752+  s2755 :: SWord8 = if s2751 then s2753 else s2754+  s2756 :: SWord8 = if s24 then s2715 else s2663+  s2757 :: SWord8 = if s165 then s2732 else s2756+  s2758 :: SWord8 = if s24 then s2737 else s2757+  s2759 :: SWord8 = if s165 then s2755 else s2758+  s2760 :: SWord8 = s2745 + s2759+  s2761 :: SBool = s2760 < s2759+  s2762 :: SBool = s2760 < s2745+  s2763 :: SBool = s2761 | s2762+  s2764 :: SWord8 = s2760 >>> 1+  s2765 :: SWord8 = s19 | s2764+  s2766 :: SWord8 = s21 & s2764+  s2767 :: SWord8 = if s2763 then s2765 else s2766+  s2768 :: SWord8 = if s2741 then s2749 else s2767+  s2769 :: SWord8 = s2726 + s2757+  s2770 :: SWord1 = choose [0:0] s2769+  s2771 :: SBool = s14 /= s2770+  s2772 :: SWord8 = if s2771 then s2735 else s2736+  s2773 :: SWord8 = if s17 then s2772 else s2732+  s2774 :: SWord1 = choose [0:0] s2773+  s2775 :: SBool = s14 /= s2774+  s2776 :: SBool = s_2 == s2775+  s2777 :: SBool = s2769 < s2757+  s2778 :: SBool = s2769 < s2726+  s2779 :: SBool = s2777 | s2778+  s2780 :: SWord8 = s2769 >>> 1+  s2781 :: SWord8 = s19 | s2780+  s2782 :: SWord8 = s21 & s2780+  s2783 :: SWord8 = if s2779 then s2781 else s2782+  s2784 :: SWord8 = s2783 >>> 1+  s2785 :: SWord8 = s19 | s2784+  s2786 :: SWord8 = s21 & s2784+  s2787 :: SWord8 = if s2775 then s2785 else s2786+  s2788 :: SWord8 = s2773 >>> 1+  s2789 :: SWord8 = s19 | s2788+  s2790 :: SWord8 = s21 & s2788+  s2791 :: SWord8 = if s2751 then s2789 else s2790+  s2792 :: SWord8 = if s24 then s2772 else s2757+  s2793 :: SWord8 = if s165 then s2791 else s2792+  s2794 :: SWord8 = s2783 + s2793+  s2795 :: SBool = s2794 < s2793+  s2796 :: SBool = s2794 < s2783+  s2797 :: SBool = s2795 | s2796+  s2798 :: SWord8 = s2794 >>> 1+  s2799 :: SWord8 = s19 | s2798+  s2800 :: SWord8 = s21 & s2798+  s2801 :: SWord8 = if s2797 then s2799 else s2800+  s2802 :: SWord8 = if s2776 then s2787 else s2801+  s2803 :: SWord8 = if s2719 then s2768 else s2802+  s2804 :: SWord8 = if s2604 then s2711 else s2803+  s2805 :: SWord8 = if s2373 then s2596 else s2804+  s2806 :: SWord8 = if s1909 then s2365 else s2805+  s2807 :: SWord8 = s1894 + s2009+  s2808 :: SWord1 = choose [0:0] s2807+  s2809 :: SBool = s14 /= s2808+  s2810 :: SWord8 = if s2809 then s1903 else s1904+  s2811 :: SWord8 = if s17 then s2810 else s1900+  s2812 :: SWord1 = choose [0:0] s2811+  s2813 :: SBool = s14 /= s2812+  s2814 :: SBool = s_2 == s2813+  s2815 :: SBool = s2807 < s2009+  s2816 :: SBool = s2807 < s1894+  s2817 :: SBool = s2815 | s2816+  s2818 :: SWord8 = s2807 >>> 1+  s2819 :: SWord8 = s19 | s2818+  s2820 :: SWord8 = s21 & s2818+  s2821 :: SWord8 = if s2817 then s2819 else s2820+  s2822 :: SWord1 = choose [0:0] s2821+  s2823 :: SBool = s14 /= s2822+  s2824 :: SWord8 = s2811 >>> 1+  s2825 :: SWord8 = s19 | s2824+  s2826 :: SWord8 = s21 & s2824+  s2827 :: SWord8 = if s1917 then s2825 else s2826+  s2828 :: SWord8 = if s17 then s2827 else s2810+  s2829 :: SWord8 = s2828 >>> 1+  s2830 :: SWord8 = s19 | s2829+  s2831 :: SWord8 = s21 & s2829+  s2832 :: SWord8 = if s2823 then s2830 else s2831+  s2833 :: SWord8 = if s17 then s2832 else s2827+  s2834 :: SWord1 = choose [0:0] s2833+  s2835 :: SBool = s14 /= s2834+  s2836 :: SBool = s_2 == s2835+  s2837 :: SWord8 = s2821 >>> 1+  s2838 :: SWord8 = s19 | s2837+  s2839 :: SWord8 = s21 & s2837+  s2840 :: SWord8 = if s2813 then s2838 else s2839+  s2841 :: SWord1 = choose [0:0] s2840+  s2842 :: SBool = s14 /= s2841+  s2843 :: SWord1 = choose [0:0] s2828+  s2844 :: SBool = s14 /= s2843+  s2845 :: SWord8 = s2833 >>> 1+  s2846 :: SWord8 = s19 | s2845+  s2847 :: SWord8 = s21 & s2845+  s2848 :: SWord8 = if s2844 then s2846 else s2847+  s2849 :: SWord8 = if s17 then s2848 else s2832+  s2850 :: SWord8 = s2849 >>> 1+  s2851 :: SWord8 = s19 | s2850+  s2852 :: SWord8 = s21 & s2850+  s2853 :: SWord8 = if s2842 then s2851 else s2852+  s2854 :: SWord8 = if s17 then s2853 else s2848+  s2855 :: SWord1 = choose [0:0] s2854+  s2856 :: SBool = s14 /= s2855+  s2857 :: SBool = s_2 == s2856+  s2858 :: SWord8 = s2840 >>> 1+  s2859 :: SWord8 = s19 | s2858+  s2860 :: SWord8 = s21 & s2858+  s2861 :: SWord8 = if s2835 then s2859 else s2860+  s2862 :: SWord1 = choose [0:0] s2861+  s2863 :: SBool = s14 /= s2862+  s2864 :: SWord1 = choose [0:0] s2849+  s2865 :: SBool = s14 /= s2864+  s2866 :: SWord8 = s2854 >>> 1+  s2867 :: SWord8 = s19 | s2866+  s2868 :: SWord8 = s21 & s2866+  s2869 :: SWord8 = if s2865 then s2867 else s2868+  s2870 :: SWord8 = if s17 then s2869 else s2853+  s2871 :: SWord8 = s2870 >>> 1+  s2872 :: SWord8 = s19 | s2871+  s2873 :: SWord8 = s21 & s2871+  s2874 :: SWord8 = if s2863 then s2872 else s2873+  s2875 :: SWord8 = if s17 then s2874 else s2869+  s2876 :: SWord1 = choose [0:0] s2875+  s2877 :: SBool = s14 /= s2876+  s2878 :: SBool = s_2 == s2877+  s2879 :: SWord8 = s2861 >>> 1+  s2880 :: SWord8 = s19 | s2879+  s2881 :: SWord8 = s21 & s2879+  s2882 :: SWord8 = if s2856 then s2880 else s2881+  s2883 :: SWord1 = choose [0:0] s2882+  s2884 :: SBool = s14 /= s2883+  s2885 :: SWord1 = choose [0:0] s2870+  s2886 :: SBool = s14 /= s2885+  s2887 :: SWord8 = s2875 >>> 1+  s2888 :: SWord8 = s19 | s2887+  s2889 :: SWord8 = s21 & s2887+  s2890 :: SWord8 = if s2886 then s2888 else s2889+  s2891 :: SWord8 = if s17 then s2890 else s2874+  s2892 :: SWord8 = s2891 >>> 1+  s2893 :: SWord8 = s19 | s2892+  s2894 :: SWord8 = s21 & s2892+  s2895 :: SWord8 = if s2884 then s2893 else s2894+  s2896 :: SWord8 = if s17 then s2895 else s2890+  s2897 :: SWord1 = choose [0:0] s2896+  s2898 :: SBool = s14 /= s2897+  s2899 :: SBool = s_2 == s2898+  s2900 :: SWord8 = s2882 >>> 1+  s2901 :: SWord8 = s19 | s2900+  s2902 :: SWord8 = s21 & s2900+  s2903 :: SWord8 = if s2877 then s2901 else s2902+  s2904 :: SWord8 = s2903 >>> 1+  s2905 :: SWord8 = s19 | s2904+  s2906 :: SWord8 = s21 & s2904+  s2907 :: SWord8 = if s2898 then s2905 else s2906+  s2908 :: SWord1 = choose [0:0] s2891+  s2909 :: SBool = s14 /= s2908+  s2910 :: SWord8 = s2896 >>> 1+  s2911 :: SWord8 = s19 | s2910+  s2912 :: SWord8 = s21 & s2910+  s2913 :: SWord8 = if s2909 then s2911 else s2912+  s2914 :: SWord8 = if s24 then s2810 else s2009+  s2915 :: SWord8 = if s165 then s2827 else s2914+  s2916 :: SWord8 = if s24 then s2832 else s2915+  s2917 :: SWord8 = if s165 then s2848 else s2916+  s2918 :: SWord8 = if s24 then s2853 else s2917+  s2919 :: SWord8 = if s165 then s2869 else s2918+  s2920 :: SWord8 = if s24 then s2874 else s2919+  s2921 :: SWord8 = if s165 then s2890 else s2920+  s2922 :: SWord8 = if s24 then s2895 else s2921+  s2923 :: SWord8 = if s165 then s2913 else s2922+  s2924 :: SWord8 = s2903 + s2923+  s2925 :: SBool = s2924 < s2923+  s2926 :: SBool = s2924 < s2903+  s2927 :: SBool = s2925 | s2926+  s2928 :: SWord8 = s2924 >>> 1+  s2929 :: SWord8 = s19 | s2928+  s2930 :: SWord8 = s21 & s2928+  s2931 :: SWord8 = if s2927 then s2929 else s2930+  s2932 :: SWord8 = if s2899 then s2907 else s2931+  s2933 :: SWord8 = s2882 + s2921+  s2934 :: SWord1 = choose [0:0] s2933+  s2935 :: SBool = s14 /= s2934+  s2936 :: SWord8 = if s2935 then s2893 else s2894+  s2937 :: SWord8 = if s17 then s2936 else s2890+  s2938 :: SWord1 = choose [0:0] s2937+  s2939 :: SBool = s14 /= s2938+  s2940 :: SBool = s_2 == s2939+  s2941 :: SBool = s2933 < s2921+  s2942 :: SBool = s2933 < s2882+  s2943 :: SBool = s2941 | s2942+  s2944 :: SWord8 = s2933 >>> 1+  s2945 :: SWord8 = s19 | s2944+  s2946 :: SWord8 = s21 & s2944+  s2947 :: SWord8 = if s2943 then s2945 else s2946+  s2948 :: SWord8 = s2947 >>> 1+  s2949 :: SWord8 = s19 | s2948+  s2950 :: SWord8 = s21 & s2948+  s2951 :: SWord8 = if s2939 then s2949 else s2950+  s2952 :: SWord8 = s2937 >>> 1+  s2953 :: SWord8 = s19 | s2952+  s2954 :: SWord8 = s21 & s2952+  s2955 :: SWord8 = if s2909 then s2953 else s2954+  s2956 :: SWord8 = if s24 then s2936 else s2921+  s2957 :: SWord8 = if s165 then s2955 else s2956+  s2958 :: SWord8 = s2947 + s2957+  s2959 :: SBool = s2958 < s2957+  s2960 :: SBool = s2958 < s2947+  s2961 :: SBool = s2959 | s2960+  s2962 :: SWord8 = s2958 >>> 1+  s2963 :: SWord8 = s19 | s2962+  s2964 :: SWord8 = s21 & s2962+  s2965 :: SWord8 = if s2961 then s2963 else s2964+  s2966 :: SWord8 = if s2940 then s2951 else s2965+  s2967 :: SWord8 = if s2878 then s2932 else s2966+  s2968 :: SWord8 = s2861 + s2919+  s2969 :: SWord1 = choose [0:0] s2968+  s2970 :: SBool = s14 /= s2969+  s2971 :: SWord8 = if s2970 then s2872 else s2873+  s2972 :: SWord8 = if s17 then s2971 else s2869+  s2973 :: SWord1 = choose [0:0] s2972+  s2974 :: SBool = s14 /= s2973+  s2975 :: SBool = s_2 == s2974+  s2976 :: SBool = s2968 < s2919+  s2977 :: SBool = s2968 < s2861+  s2978 :: SBool = s2976 | s2977+  s2979 :: SWord8 = s2968 >>> 1+  s2980 :: SWord8 = s19 | s2979+  s2981 :: SWord8 = s21 & s2979+  s2982 :: SWord8 = if s2978 then s2980 else s2981+  s2983 :: SWord1 = choose [0:0] s2982+  s2984 :: SBool = s14 /= s2983+  s2985 :: SWord8 = s2972 >>> 1+  s2986 :: SWord8 = s19 | s2985+  s2987 :: SWord8 = s21 & s2985+  s2988 :: SWord8 = if s2886 then s2986 else s2987+  s2989 :: SWord8 = if s17 then s2988 else s2971+  s2990 :: SWord8 = s2989 >>> 1+  s2991 :: SWord8 = s19 | s2990+  s2992 :: SWord8 = s21 & s2990+  s2993 :: SWord8 = if s2984 then s2991 else s2992+  s2994 :: SWord8 = if s17 then s2993 else s2988+  s2995 :: SWord1 = choose [0:0] s2994+  s2996 :: SBool = s14 /= s2995+  s2997 :: SBool = s_2 == s2996+  s2998 :: SWord8 = s2982 >>> 1+  s2999 :: SWord8 = s19 | s2998+  s3000 :: SWord8 = s21 & s2998+  s3001 :: SWord8 = if s2974 then s2999 else s3000+  s3002 :: SWord8 = s3001 >>> 1+  s3003 :: SWord8 = s19 | s3002+  s3004 :: SWord8 = s21 & s3002+  s3005 :: SWord8 = if s2996 then s3003 else s3004+  s3006 :: SWord1 = choose [0:0] s2989+  s3007 :: SBool = s14 /= s3006+  s3008 :: SWord8 = s2994 >>> 1+  s3009 :: SWord8 = s19 | s3008+  s3010 :: SWord8 = s21 & s3008+  s3011 :: SWord8 = if s3007 then s3009 else s3010+  s3012 :: SWord8 = if s24 then s2971 else s2919+  s3013 :: SWord8 = if s165 then s2988 else s3012+  s3014 :: SWord8 = if s24 then s2993 else s3013+  s3015 :: SWord8 = if s165 then s3011 else s3014+  s3016 :: SWord8 = s3001 + s3015+  s3017 :: SBool = s3016 < s3015+  s3018 :: SBool = s3016 < s3001+  s3019 :: SBool = s3017 | s3018+  s3020 :: SWord8 = s3016 >>> 1+  s3021 :: SWord8 = s19 | s3020+  s3022 :: SWord8 = s21 & s3020+  s3023 :: SWord8 = if s3019 then s3021 else s3022+  s3024 :: SWord8 = if s2997 then s3005 else s3023+  s3025 :: SWord8 = s2982 + s3013+  s3026 :: SWord1 = choose [0:0] s3025+  s3027 :: SBool = s14 /= s3026+  s3028 :: SWord8 = if s3027 then s2991 else s2992+  s3029 :: SWord8 = if s17 then s3028 else s2988+  s3030 :: SWord1 = choose [0:0] s3029+  s3031 :: SBool = s14 /= s3030+  s3032 :: SBool = s_2 == s3031+  s3033 :: SBool = s3025 < s3013+  s3034 :: SBool = s3025 < s2982+  s3035 :: SBool = s3033 | s3034+  s3036 :: SWord8 = s3025 >>> 1+  s3037 :: SWord8 = s19 | s3036+  s3038 :: SWord8 = s21 & s3036+  s3039 :: SWord8 = if s3035 then s3037 else s3038+  s3040 :: SWord8 = s3039 >>> 1+  s3041 :: SWord8 = s19 | s3040+  s3042 :: SWord8 = s21 & s3040+  s3043 :: SWord8 = if s3031 then s3041 else s3042+  s3044 :: SWord8 = s3029 >>> 1+  s3045 :: SWord8 = s19 | s3044+  s3046 :: SWord8 = s21 & s3044+  s3047 :: SWord8 = if s3007 then s3045 else s3046+  s3048 :: SWord8 = if s24 then s3028 else s3013+  s3049 :: SWord8 = if s165 then s3047 else s3048+  s3050 :: SWord8 = s3039 + s3049+  s3051 :: SBool = s3050 < s3049+  s3052 :: SBool = s3050 < s3039+  s3053 :: SBool = s3051 | s3052+  s3054 :: SWord8 = s3050 >>> 1+  s3055 :: SWord8 = s19 | s3054+  s3056 :: SWord8 = s21 & s3054+  s3057 :: SWord8 = if s3053 then s3055 else s3056+  s3058 :: SWord8 = if s3032 then s3043 else s3057+  s3059 :: SWord8 = if s2975 then s3024 else s3058+  s3060 :: SWord8 = if s2857 then s2967 else s3059+  s3061 :: SWord8 = s2840 + s2917+  s3062 :: SWord1 = choose [0:0] s3061+  s3063 :: SBool = s14 /= s3062+  s3064 :: SWord8 = if s3063 then s2851 else s2852+  s3065 :: SWord8 = if s17 then s3064 else s2848+  s3066 :: SWord1 = choose [0:0] s3065+  s3067 :: SBool = s14 /= s3066+  s3068 :: SBool = s_2 == s3067+  s3069 :: SBool = s3061 < s2917+  s3070 :: SBool = s3061 < s2840+  s3071 :: SBool = s3069 | s3070+  s3072 :: SWord8 = s3061 >>> 1+  s3073 :: SWord8 = s19 | s3072+  s3074 :: SWord8 = s21 & s3072+  s3075 :: SWord8 = if s3071 then s3073 else s3074+  s3076 :: SWord1 = choose [0:0] s3075+  s3077 :: SBool = s14 /= s3076+  s3078 :: SWord8 = s3065 >>> 1+  s3079 :: SWord8 = s19 | s3078+  s3080 :: SWord8 = s21 & s3078+  s3081 :: SWord8 = if s2865 then s3079 else s3080+  s3082 :: SWord8 = if s17 then s3081 else s3064+  s3083 :: SWord8 = s3082 >>> 1+  s3084 :: SWord8 = s19 | s3083+  s3085 :: SWord8 = s21 & s3083+  s3086 :: SWord8 = if s3077 then s3084 else s3085+  s3087 :: SWord8 = if s17 then s3086 else s3081+  s3088 :: SWord1 = choose [0:0] s3087+  s3089 :: SBool = s14 /= s3088+  s3090 :: SBool = s_2 == s3089+  s3091 :: SWord8 = s3075 >>> 1+  s3092 :: SWord8 = s19 | s3091+  s3093 :: SWord8 = s21 & s3091+  s3094 :: SWord8 = if s3067 then s3092 else s3093+  s3095 :: SWord1 = choose [0:0] s3094+  s3096 :: SBool = s14 /= s3095+  s3097 :: SWord1 = choose [0:0] s3082+  s3098 :: SBool = s14 /= s3097+  s3099 :: SWord8 = s3087 >>> 1+  s3100 :: SWord8 = s19 | s3099+  s3101 :: SWord8 = s21 & s3099+  s3102 :: SWord8 = if s3098 then s3100 else s3101+  s3103 :: SWord8 = if s17 then s3102 else s3086+  s3104 :: SWord8 = s3103 >>> 1+  s3105 :: SWord8 = s19 | s3104+  s3106 :: SWord8 = s21 & s3104+  s3107 :: SWord8 = if s3096 then s3105 else s3106+  s3108 :: SWord8 = if s17 then s3107 else s3102+  s3109 :: SWord1 = choose [0:0] s3108+  s3110 :: SBool = s14 /= s3109+  s3111 :: SBool = s_2 == s3110+  s3112 :: SWord8 = s3094 >>> 1+  s3113 :: SWord8 = s19 | s3112+  s3114 :: SWord8 = s21 & s3112+  s3115 :: SWord8 = if s3089 then s3113 else s3114+  s3116 :: SWord8 = s3115 >>> 1+  s3117 :: SWord8 = s19 | s3116+  s3118 :: SWord8 = s21 & s3116+  s3119 :: SWord8 = if s3110 then s3117 else s3118+  s3120 :: SWord1 = choose [0:0] s3103+  s3121 :: SBool = s14 /= s3120+  s3122 :: SWord8 = s3108 >>> 1+  s3123 :: SWord8 = s19 | s3122+  s3124 :: SWord8 = s21 & s3122+  s3125 :: SWord8 = if s3121 then s3123 else s3124+  s3126 :: SWord8 = if s24 then s3064 else s2917+  s3127 :: SWord8 = if s165 then s3081 else s3126+  s3128 :: SWord8 = if s24 then s3086 else s3127+  s3129 :: SWord8 = if s165 then s3102 else s3128+  s3130 :: SWord8 = if s24 then s3107 else s3129+  s3131 :: SWord8 = if s165 then s3125 else s3130+  s3132 :: SWord8 = s3115 + s3131+  s3133 :: SBool = s3132 < s3131+  s3134 :: SBool = s3132 < s3115+  s3135 :: SBool = s3133 | s3134+  s3136 :: SWord8 = s3132 >>> 1+  s3137 :: SWord8 = s19 | s3136+  s3138 :: SWord8 = s21 & s3136+  s3139 :: SWord8 = if s3135 then s3137 else s3138+  s3140 :: SWord8 = if s3111 then s3119 else s3139+  s3141 :: SWord8 = s3094 + s3129+  s3142 :: SWord1 = choose [0:0] s3141+  s3143 :: SBool = s14 /= s3142+  s3144 :: SWord8 = if s3143 then s3105 else s3106+  s3145 :: SWord8 = if s17 then s3144 else s3102+  s3146 :: SWord1 = choose [0:0] s3145+  s3147 :: SBool = s14 /= s3146+  s3148 :: SBool = s_2 == s3147+  s3149 :: SBool = s3141 < s3129+  s3150 :: SBool = s3141 < s3094+  s3151 :: SBool = s3149 | s3150+  s3152 :: SWord8 = s3141 >>> 1+  s3153 :: SWord8 = s19 | s3152+  s3154 :: SWord8 = s21 & s3152+  s3155 :: SWord8 = if s3151 then s3153 else s3154+  s3156 :: SWord8 = s3155 >>> 1+  s3157 :: SWord8 = s19 | s3156+  s3158 :: SWord8 = s21 & s3156+  s3159 :: SWord8 = if s3147 then s3157 else s3158+  s3160 :: SWord8 = s3145 >>> 1+  s3161 :: SWord8 = s19 | s3160+  s3162 :: SWord8 = s21 & s3160+  s3163 :: SWord8 = if s3121 then s3161 else s3162+  s3164 :: SWord8 = if s24 then s3144 else s3129+  s3165 :: SWord8 = if s165 then s3163 else s3164+  s3166 :: SWord8 = s3155 + s3165+  s3167 :: SBool = s3166 < s3165+  s3168 :: SBool = s3166 < s3155+  s3169 :: SBool = s3167 | s3168+  s3170 :: SWord8 = s3166 >>> 1+  s3171 :: SWord8 = s19 | s3170+  s3172 :: SWord8 = s21 & s3170+  s3173 :: SWord8 = if s3169 then s3171 else s3172+  s3174 :: SWord8 = if s3148 then s3159 else s3173+  s3175 :: SWord8 = if s3090 then s3140 else s3174+  s3176 :: SWord8 = s3075 + s3127+  s3177 :: SWord1 = choose [0:0] s3176+  s3178 :: SBool = s14 /= s3177+  s3179 :: SWord8 = if s3178 then s3084 else s3085+  s3180 :: SWord8 = if s17 then s3179 else s3081+  s3181 :: SWord1 = choose [0:0] s3180+  s3182 :: SBool = s14 /= s3181+  s3183 :: SBool = s_2 == s3182+  s3184 :: SBool = s3176 < s3127+  s3185 :: SBool = s3176 < s3075+  s3186 :: SBool = s3184 | s3185+  s3187 :: SWord8 = s3176 >>> 1+  s3188 :: SWord8 = s19 | s3187+  s3189 :: SWord8 = s21 & s3187+  s3190 :: SWord8 = if s3186 then s3188 else s3189+  s3191 :: SWord1 = choose [0:0] s3190+  s3192 :: SBool = s14 /= s3191+  s3193 :: SWord8 = s3180 >>> 1+  s3194 :: SWord8 = s19 | s3193+  s3195 :: SWord8 = s21 & s3193+  s3196 :: SWord8 = if s3098 then s3194 else s3195+  s3197 :: SWord8 = if s17 then s3196 else s3179+  s3198 :: SWord8 = s3197 >>> 1+  s3199 :: SWord8 = s19 | s3198+  s3200 :: SWord8 = s21 & s3198+  s3201 :: SWord8 = if s3192 then s3199 else s3200+  s3202 :: SWord8 = if s17 then s3201 else s3196+  s3203 :: SWord1 = choose [0:0] s3202+  s3204 :: SBool = s14 /= s3203+  s3205 :: SBool = s_2 == s3204+  s3206 :: SWord8 = s3190 >>> 1+  s3207 :: SWord8 = s19 | s3206+  s3208 :: SWord8 = s21 & s3206+  s3209 :: SWord8 = if s3182 then s3207 else s3208+  s3210 :: SWord8 = s3209 >>> 1+  s3211 :: SWord8 = s19 | s3210+  s3212 :: SWord8 = s21 & s3210+  s3213 :: SWord8 = if s3204 then s3211 else s3212+  s3214 :: SWord1 = choose [0:0] s3197+  s3215 :: SBool = s14 /= s3214+  s3216 :: SWord8 = s3202 >>> 1+  s3217 :: SWord8 = s19 | s3216+  s3218 :: SWord8 = s21 & s3216+  s3219 :: SWord8 = if s3215 then s3217 else s3218+  s3220 :: SWord8 = if s24 then s3179 else s3127+  s3221 :: SWord8 = if s165 then s3196 else s3220+  s3222 :: SWord8 = if s24 then s3201 else s3221+  s3223 :: SWord8 = if s165 then s3219 else s3222+  s3224 :: SWord8 = s3209 + s3223+  s3225 :: SBool = s3224 < s3223+  s3226 :: SBool = s3224 < s3209+  s3227 :: SBool = s3225 | s3226+  s3228 :: SWord8 = s3224 >>> 1+  s3229 :: SWord8 = s19 | s3228+  s3230 :: SWord8 = s21 & s3228+  s3231 :: SWord8 = if s3227 then s3229 else s3230+  s3232 :: SWord8 = if s3205 then s3213 else s3231+  s3233 :: SWord8 = s3190 + s3221+  s3234 :: SWord1 = choose [0:0] s3233+  s3235 :: SBool = s14 /= s3234+  s3236 :: SWord8 = if s3235 then s3199 else s3200+  s3237 :: SWord8 = if s17 then s3236 else s3196+  s3238 :: SWord1 = choose [0:0] s3237+  s3239 :: SBool = s14 /= s3238+  s3240 :: SBool = s_2 == s3239+  s3241 :: SBool = s3233 < s3221+  s3242 :: SBool = s3233 < s3190+  s3243 :: SBool = s3241 | s3242+  s3244 :: SWord8 = s3233 >>> 1+  s3245 :: SWord8 = s19 | s3244+  s3246 :: SWord8 = s21 & s3244+  s3247 :: SWord8 = if s3243 then s3245 else s3246+  s3248 :: SWord8 = s3247 >>> 1+  s3249 :: SWord8 = s19 | s3248+  s3250 :: SWord8 = s21 & s3248+  s3251 :: SWord8 = if s3239 then s3249 else s3250+  s3252 :: SWord8 = s3237 >>> 1+  s3253 :: SWord8 = s19 | s3252+  s3254 :: SWord8 = s21 & s3252+  s3255 :: SWord8 = if s3215 then s3253 else s3254+  s3256 :: SWord8 = if s24 then s3236 else s3221+  s3257 :: SWord8 = if s165 then s3255 else s3256+  s3258 :: SWord8 = s3247 + s3257+  s3259 :: SBool = s3258 < s3257+  s3260 :: SBool = s3258 < s3247+  s3261 :: SBool = s3259 | s3260+  s3262 :: SWord8 = s3258 >>> 1+  s3263 :: SWord8 = s19 | s3262+  s3264 :: SWord8 = s21 & s3262+  s3265 :: SWord8 = if s3261 then s3263 else s3264+  s3266 :: SWord8 = if s3240 then s3251 else s3265+  s3267 :: SWord8 = if s3183 then s3232 else s3266+  s3268 :: SWord8 = if s3068 then s3175 else s3267+  s3269 :: SWord8 = if s2836 then s3060 else s3268+  s3270 :: SWord8 = s2821 + s2915+  s3271 :: SWord1 = choose [0:0] s3270+  s3272 :: SBool = s14 /= s3271+  s3273 :: SWord8 = if s3272 then s2830 else s2831+  s3274 :: SWord8 = if s17 then s3273 else s2827+  s3275 :: SWord1 = choose [0:0] s3274+  s3276 :: SBool = s14 /= s3275+  s3277 :: SBool = s_2 == s3276+  s3278 :: SBool = s3270 < s2915+  s3279 :: SBool = s3270 < s2821+  s3280 :: SBool = s3278 | s3279+  s3281 :: SWord8 = s3270 >>> 1+  s3282 :: SWord8 = s19 | s3281+  s3283 :: SWord8 = s21 & s3281+  s3284 :: SWord8 = if s3280 then s3282 else s3283+  s3285 :: SWord1 = choose [0:0] s3284+  s3286 :: SBool = s14 /= s3285+  s3287 :: SWord8 = s3274 >>> 1+  s3288 :: SWord8 = s19 | s3287+  s3289 :: SWord8 = s21 & s3287+  s3290 :: SWord8 = if s2844 then s3288 else s3289+  s3291 :: SWord8 = if s17 then s3290 else s3273+  s3292 :: SWord8 = s3291 >>> 1+  s3293 :: SWord8 = s19 | s3292+  s3294 :: SWord8 = s21 & s3292+  s3295 :: SWord8 = if s3286 then s3293 else s3294+  s3296 :: SWord8 = if s17 then s3295 else s3290+  s3297 :: SWord1 = choose [0:0] s3296+  s3298 :: SBool = s14 /= s3297+  s3299 :: SBool = s_2 == s3298+  s3300 :: SWord8 = s3284 >>> 1+  s3301 :: SWord8 = s19 | s3300+  s3302 :: SWord8 = s21 & s3300+  s3303 :: SWord8 = if s3276 then s3301 else s3302+  s3304 :: SWord1 = choose [0:0] s3303+  s3305 :: SBool = s14 /= s3304+  s3306 :: SWord1 = choose [0:0] s3291+  s3307 :: SBool = s14 /= s3306+  s3308 :: SWord8 = s3296 >>> 1+  s3309 :: SWord8 = s19 | s3308+  s3310 :: SWord8 = s21 & s3308+  s3311 :: SWord8 = if s3307 then s3309 else s3310+  s3312 :: SWord8 = if s17 then s3311 else s3295+  s3313 :: SWord8 = s3312 >>> 1+  s3314 :: SWord8 = s19 | s3313+  s3315 :: SWord8 = s21 & s3313+  s3316 :: SWord8 = if s3305 then s3314 else s3315+  s3317 :: SWord8 = if s17 then s3316 else s3311+  s3318 :: SWord1 = choose [0:0] s3317+  s3319 :: SBool = s14 /= s3318+  s3320 :: SBool = s_2 == s3319+  s3321 :: SWord8 = s3303 >>> 1+  s3322 :: SWord8 = s19 | s3321+  s3323 :: SWord8 = s21 & s3321+  s3324 :: SWord8 = if s3298 then s3322 else s3323+  s3325 :: SWord1 = choose [0:0] s3324+  s3326 :: SBool = s14 /= s3325+  s3327 :: SWord1 = choose [0:0] s3312+  s3328 :: SBool = s14 /= s3327+  s3329 :: SWord8 = s3317 >>> 1+  s3330 :: SWord8 = s19 | s3329+  s3331 :: SWord8 = s21 & s3329+  s3332 :: SWord8 = if s3328 then s3330 else s3331+  s3333 :: SWord8 = if s17 then s3332 else s3316+  s3334 :: SWord8 = s3333 >>> 1+  s3335 :: SWord8 = s19 | s3334+  s3336 :: SWord8 = s21 & s3334+  s3337 :: SWord8 = if s3326 then s3335 else s3336+  s3338 :: SWord8 = if s17 then s3337 else s3332+  s3339 :: SWord1 = choose [0:0] s3338+  s3340 :: SBool = s14 /= s3339+  s3341 :: SBool = s_2 == s3340+  s3342 :: SWord8 = s3324 >>> 1+  s3343 :: SWord8 = s19 | s3342+  s3344 :: SWord8 = s21 & s3342+  s3345 :: SWord8 = if s3319 then s3343 else s3344+  s3346 :: SWord8 = s3345 >>> 1+  s3347 :: SWord8 = s19 | s3346+  s3348 :: SWord8 = s21 & s3346+  s3349 :: SWord8 = if s3340 then s3347 else s3348+  s3350 :: SWord1 = choose [0:0] s3333+  s3351 :: SBool = s14 /= s3350+  s3352 :: SWord8 = s3338 >>> 1+  s3353 :: SWord8 = s19 | s3352+  s3354 :: SWord8 = s21 & s3352+  s3355 :: SWord8 = if s3351 then s3353 else s3354+  s3356 :: SWord8 = if s24 then s3273 else s2915+  s3357 :: SWord8 = if s165 then s3290 else s3356+  s3358 :: SWord8 = if s24 then s3295 else s3357+  s3359 :: SWord8 = if s165 then s3311 else s3358+  s3360 :: SWord8 = if s24 then s3316 else s3359+  s3361 :: SWord8 = if s165 then s3332 else s3360+  s3362 :: SWord8 = if s24 then s3337 else s3361+  s3363 :: SWord8 = if s165 then s3355 else s3362+  s3364 :: SWord8 = s3345 + s3363+  s3365 :: SBool = s3364 < s3363+  s3366 :: SBool = s3364 < s3345+  s3367 :: SBool = s3365 | s3366+  s3368 :: SWord8 = s3364 >>> 1+  s3369 :: SWord8 = s19 | s3368+  s3370 :: SWord8 = s21 & s3368+  s3371 :: SWord8 = if s3367 then s3369 else s3370+  s3372 :: SWord8 = if s3341 then s3349 else s3371+  s3373 :: SWord8 = s3324 + s3361+  s3374 :: SWord1 = choose [0:0] s3373+  s3375 :: SBool = s14 /= s3374+  s3376 :: SWord8 = if s3375 then s3335 else s3336+  s3377 :: SWord8 = if s17 then s3376 else s3332+  s3378 :: SWord1 = choose [0:0] s3377+  s3379 :: SBool = s14 /= s3378+  s3380 :: SBool = s_2 == s3379+  s3381 :: SBool = s3373 < s3361+  s3382 :: SBool = s3373 < s3324+  s3383 :: SBool = s3381 | s3382+  s3384 :: SWord8 = s3373 >>> 1+  s3385 :: SWord8 = s19 | s3384+  s3386 :: SWord8 = s21 & s3384+  s3387 :: SWord8 = if s3383 then s3385 else s3386+  s3388 :: SWord8 = s3387 >>> 1+  s3389 :: SWord8 = s19 | s3388+  s3390 :: SWord8 = s21 & s3388+  s3391 :: SWord8 = if s3379 then s3389 else s3390+  s3392 :: SWord8 = s3377 >>> 1+  s3393 :: SWord8 = s19 | s3392+  s3394 :: SWord8 = s21 & s3392+  s3395 :: SWord8 = if s3351 then s3393 else s3394+  s3396 :: SWord8 = if s24 then s3376 else s3361+  s3397 :: SWord8 = if s165 then s3395 else s3396+  s3398 :: SWord8 = s3387 + s3397+  s3399 :: SBool = s3398 < s3397+  s3400 :: SBool = s3398 < s3387+  s3401 :: SBool = s3399 | s3400+  s3402 :: SWord8 = s3398 >>> 1+  s3403 :: SWord8 = s19 | s3402+  s3404 :: SWord8 = s21 & s3402+  s3405 :: SWord8 = if s3401 then s3403 else s3404+  s3406 :: SWord8 = if s3380 then s3391 else s3405+  s3407 :: SWord8 = if s3320 then s3372 else s3406+  s3408 :: SWord8 = s3303 + s3359+  s3409 :: SWord1 = choose [0:0] s3408+  s3410 :: SBool = s14 /= s3409+  s3411 :: SWord8 = if s3410 then s3314 else s3315+  s3412 :: SWord8 = if s17 then s3411 else s3311+  s3413 :: SWord1 = choose [0:0] s3412+  s3414 :: SBool = s14 /= s3413+  s3415 :: SBool = s_2 == s3414+  s3416 :: SBool = s3408 < s3359+  s3417 :: SBool = s3408 < s3303+  s3418 :: SBool = s3416 | s3417+  s3419 :: SWord8 = s3408 >>> 1+  s3420 :: SWord8 = s19 | s3419+  s3421 :: SWord8 = s21 & s3419+  s3422 :: SWord8 = if s3418 then s3420 else s3421+  s3423 :: SWord1 = choose [0:0] s3422+  s3424 :: SBool = s14 /= s3423+  s3425 :: SWord8 = s3412 >>> 1+  s3426 :: SWord8 = s19 | s3425+  s3427 :: SWord8 = s21 & s3425+  s3428 :: SWord8 = if s3328 then s3426 else s3427+  s3429 :: SWord8 = if s17 then s3428 else s3411+  s3430 :: SWord8 = s3429 >>> 1+  s3431 :: SWord8 = s19 | s3430+  s3432 :: SWord8 = s21 & s3430+  s3433 :: SWord8 = if s3424 then s3431 else s3432+  s3434 :: SWord8 = if s17 then s3433 else s3428+  s3435 :: SWord1 = choose [0:0] s3434+  s3436 :: SBool = s14 /= s3435+  s3437 :: SBool = s_2 == s3436+  s3438 :: SWord8 = s3422 >>> 1+  s3439 :: SWord8 = s19 | s3438+  s3440 :: SWord8 = s21 & s3438+  s3441 :: SWord8 = if s3414 then s3439 else s3440+  s3442 :: SWord8 = s3441 >>> 1+  s3443 :: SWord8 = s19 | s3442+  s3444 :: SWord8 = s21 & s3442+  s3445 :: SWord8 = if s3436 then s3443 else s3444+  s3446 :: SWord1 = choose [0:0] s3429+  s3447 :: SBool = s14 /= s3446+  s3448 :: SWord8 = s3434 >>> 1+  s3449 :: SWord8 = s19 | s3448+  s3450 :: SWord8 = s21 & s3448+  s3451 :: SWord8 = if s3447 then s3449 else s3450+  s3452 :: SWord8 = if s24 then s3411 else s3359+  s3453 :: SWord8 = if s165 then s3428 else s3452+  s3454 :: SWord8 = if s24 then s3433 else s3453+  s3455 :: SWord8 = if s165 then s3451 else s3454+  s3456 :: SWord8 = s3441 + s3455+  s3457 :: SBool = s3456 < s3455+  s3458 :: SBool = s3456 < s3441+  s3459 :: SBool = s3457 | s3458+  s3460 :: SWord8 = s3456 >>> 1+  s3461 :: SWord8 = s19 | s3460+  s3462 :: SWord8 = s21 & s3460+  s3463 :: SWord8 = if s3459 then s3461 else s3462+  s3464 :: SWord8 = if s3437 then s3445 else s3463+  s3465 :: SWord8 = s3422 + s3453+  s3466 :: SWord1 = choose [0:0] s3465+  s3467 :: SBool = s14 /= s3466+  s3468 :: SWord8 = if s3467 then s3431 else s3432+  s3469 :: SWord8 = if s17 then s3468 else s3428+  s3470 :: SWord1 = choose [0:0] s3469+  s3471 :: SBool = s14 /= s3470+  s3472 :: SBool = s_2 == s3471+  s3473 :: SBool = s3465 < s3453+  s3474 :: SBool = s3465 < s3422+  s3475 :: SBool = s3473 | s3474+  s3476 :: SWord8 = s3465 >>> 1+  s3477 :: SWord8 = s19 | s3476+  s3478 :: SWord8 = s21 & s3476+  s3479 :: SWord8 = if s3475 then s3477 else s3478+  s3480 :: SWord8 = s3479 >>> 1+  s3481 :: SWord8 = s19 | s3480+  s3482 :: SWord8 = s21 & s3480+  s3483 :: SWord8 = if s3471 then s3481 else s3482+  s3484 :: SWord8 = s3469 >>> 1+  s3485 :: SWord8 = s19 | s3484+  s3486 :: SWord8 = s21 & s3484+  s3487 :: SWord8 = if s3447 then s3485 else s3486+  s3488 :: SWord8 = if s24 then s3468 else s3453+  s3489 :: SWord8 = if s165 then s3487 else s3488+  s3490 :: SWord8 = s3479 + s3489+  s3491 :: SBool = s3490 < s3489+  s3492 :: SBool = s3490 < s3479+  s3493 :: SBool = s3491 | s3492+  s3494 :: SWord8 = s3490 >>> 1+  s3495 :: SWord8 = s19 | s3494+  s3496 :: SWord8 = s21 & s3494+  s3497 :: SWord8 = if s3493 then s3495 else s3496+  s3498 :: SWord8 = if s3472 then s3483 else s3497+  s3499 :: SWord8 = if s3415 then s3464 else s3498+  s3500 :: SWord8 = if s3299 then s3407 else s3499+  s3501 :: SWord8 = s3284 + s3357+  s3502 :: SWord1 = choose [0:0] s3501+  s3503 :: SBool = s14 /= s3502+  s3504 :: SWord8 = if s3503 then s3293 else s3294+  s3505 :: SWord8 = if s17 then s3504 else s3290+  s3506 :: SWord1 = choose [0:0] s3505+  s3507 :: SBool = s14 /= s3506+  s3508 :: SBool = s_2 == s3507+  s3509 :: SBool = s3501 < s3357+  s3510 :: SBool = s3501 < s3284+  s3511 :: SBool = s3509 | s3510+  s3512 :: SWord8 = s3501 >>> 1+  s3513 :: SWord8 = s19 | s3512+  s3514 :: SWord8 = s21 & s3512+  s3515 :: SWord8 = if s3511 then s3513 else s3514+  s3516 :: SWord1 = choose [0:0] s3515+  s3517 :: SBool = s14 /= s3516+  s3518 :: SWord8 = s3505 >>> 1+  s3519 :: SWord8 = s19 | s3518+  s3520 :: SWord8 = s21 & s3518+  s3521 :: SWord8 = if s3307 then s3519 else s3520+  s3522 :: SWord8 = if s17 then s3521 else s3504+  s3523 :: SWord8 = s3522 >>> 1+  s3524 :: SWord8 = s19 | s3523+  s3525 :: SWord8 = s21 & s3523+  s3526 :: SWord8 = if s3517 then s3524 else s3525+  s3527 :: SWord8 = if s17 then s3526 else s3521+  s3528 :: SWord1 = choose [0:0] s3527+  s3529 :: SBool = s14 /= s3528+  s3530 :: SBool = s_2 == s3529+  s3531 :: SWord8 = s3515 >>> 1+  s3532 :: SWord8 = s19 | s3531+  s3533 :: SWord8 = s21 & s3531+  s3534 :: SWord8 = if s3507 then s3532 else s3533+  s3535 :: SWord1 = choose [0:0] s3534+  s3536 :: SBool = s14 /= s3535+  s3537 :: SWord1 = choose [0:0] s3522+  s3538 :: SBool = s14 /= s3537+  s3539 :: SWord8 = s3527 >>> 1+  s3540 :: SWord8 = s19 | s3539+  s3541 :: SWord8 = s21 & s3539+  s3542 :: SWord8 = if s3538 then s3540 else s3541+  s3543 :: SWord8 = if s17 then s3542 else s3526+  s3544 :: SWord8 = s3543 >>> 1+  s3545 :: SWord8 = s19 | s3544+  s3546 :: SWord8 = s21 & s3544+  s3547 :: SWord8 = if s3536 then s3545 else s3546+  s3548 :: SWord8 = if s17 then s3547 else s3542+  s3549 :: SWord1 = choose [0:0] s3548+  s3550 :: SBool = s14 /= s3549+  s3551 :: SBool = s_2 == s3550+  s3552 :: SWord8 = s3534 >>> 1+  s3553 :: SWord8 = s19 | s3552+  s3554 :: SWord8 = s21 & s3552+  s3555 :: SWord8 = if s3529 then s3553 else s3554+  s3556 :: SWord8 = s3555 >>> 1+  s3557 :: SWord8 = s19 | s3556+  s3558 :: SWord8 = s21 & s3556+  s3559 :: SWord8 = if s3550 then s3557 else s3558+  s3560 :: SWord1 = choose [0:0] s3543+  s3561 :: SBool = s14 /= s3560+  s3562 :: SWord8 = s3548 >>> 1+  s3563 :: SWord8 = s19 | s3562+  s3564 :: SWord8 = s21 & s3562+  s3565 :: SWord8 = if s3561 then s3563 else s3564+  s3566 :: SWord8 = if s24 then s3504 else s3357+  s3567 :: SWord8 = if s165 then s3521 else s3566+  s3568 :: SWord8 = if s24 then s3526 else s3567+  s3569 :: SWord8 = if s165 then s3542 else s3568+  s3570 :: SWord8 = if s24 then s3547 else s3569+  s3571 :: SWord8 = if s165 then s3565 else s3570+  s3572 :: SWord8 = s3555 + s3571+  s3573 :: SBool = s3572 < s3571+  s3574 :: SBool = s3572 < s3555+  s3575 :: SBool = s3573 | s3574+  s3576 :: SWord8 = s3572 >>> 1+  s3577 :: SWord8 = s19 | s3576+  s3578 :: SWord8 = s21 & s3576+  s3579 :: SWord8 = if s3575 then s3577 else s3578+  s3580 :: SWord8 = if s3551 then s3559 else s3579+  s3581 :: SWord8 = s3534 + s3569+  s3582 :: SWord1 = choose [0:0] s3581+  s3583 :: SBool = s14 /= s3582+  s3584 :: SWord8 = if s3583 then s3545 else s3546+  s3585 :: SWord8 = if s17 then s3584 else s3542+  s3586 :: SWord1 = choose [0:0] s3585+  s3587 :: SBool = s14 /= s3586+  s3588 :: SBool = s_2 == s3587+  s3589 :: SBool = s3581 < s3569+  s3590 :: SBool = s3581 < s3534+  s3591 :: SBool = s3589 | s3590+  s3592 :: SWord8 = s3581 >>> 1+  s3593 :: SWord8 = s19 | s3592+  s3594 :: SWord8 = s21 & s3592+  s3595 :: SWord8 = if s3591 then s3593 else s3594+  s3596 :: SWord8 = s3595 >>> 1+  s3597 :: SWord8 = s19 | s3596+  s3598 :: SWord8 = s21 & s3596+  s3599 :: SWord8 = if s3587 then s3597 else s3598+  s3600 :: SWord8 = s3585 >>> 1+  s3601 :: SWord8 = s19 | s3600+  s3602 :: SWord8 = s21 & s3600+  s3603 :: SWord8 = if s3561 then s3601 else s3602+  s3604 :: SWord8 = if s24 then s3584 else s3569+  s3605 :: SWord8 = if s165 then s3603 else s3604+  s3606 :: SWord8 = s3595 + s3605+  s3607 :: SBool = s3606 < s3605+  s3608 :: SBool = s3606 < s3595+  s3609 :: SBool = s3607 | s3608+  s3610 :: SWord8 = s3606 >>> 1+  s3611 :: SWord8 = s19 | s3610+  s3612 :: SWord8 = s21 & s3610+  s3613 :: SWord8 = if s3609 then s3611 else s3612+  s3614 :: SWord8 = if s3588 then s3599 else s3613+  s3615 :: SWord8 = if s3530 then s3580 else s3614+  s3616 :: SWord8 = s3515 + s3567+  s3617 :: SWord1 = choose [0:0] s3616+  s3618 :: SBool = s14 /= s3617+  s3619 :: SWord8 = if s3618 then s3524 else s3525+  s3620 :: SWord8 = if s17 then s3619 else s3521+  s3621 :: SWord1 = choose [0:0] s3620+  s3622 :: SBool = s14 /= s3621+  s3623 :: SBool = s_2 == s3622+  s3624 :: SBool = s3616 < s3567+  s3625 :: SBool = s3616 < s3515+  s3626 :: SBool = s3624 | s3625+  s3627 :: SWord8 = s3616 >>> 1+  s3628 :: SWord8 = s19 | s3627+  s3629 :: SWord8 = s21 & s3627+  s3630 :: SWord8 = if s3626 then s3628 else s3629+  s3631 :: SWord1 = choose [0:0] s3630+  s3632 :: SBool = s14 /= s3631+  s3633 :: SWord8 = s3620 >>> 1+  s3634 :: SWord8 = s19 | s3633+  s3635 :: SWord8 = s21 & s3633+  s3636 :: SWord8 = if s3538 then s3634 else s3635+  s3637 :: SWord8 = if s17 then s3636 else s3619+  s3638 :: SWord8 = s3637 >>> 1+  s3639 :: SWord8 = s19 | s3638+  s3640 :: SWord8 = s21 & s3638+  s3641 :: SWord8 = if s3632 then s3639 else s3640+  s3642 :: SWord8 = if s17 then s3641 else s3636+  s3643 :: SWord1 = choose [0:0] s3642+  s3644 :: SBool = s14 /= s3643+  s3645 :: SBool = s_2 == s3644+  s3646 :: SWord8 = s3630 >>> 1+  s3647 :: SWord8 = s19 | s3646+  s3648 :: SWord8 = s21 & s3646+  s3649 :: SWord8 = if s3622 then s3647 else s3648+  s3650 :: SWord8 = s3649 >>> 1+  s3651 :: SWord8 = s19 | s3650+  s3652 :: SWord8 = s21 & s3650+  s3653 :: SWord8 = if s3644 then s3651 else s3652+  s3654 :: SWord1 = choose [0:0] s3637+  s3655 :: SBool = s14 /= s3654+  s3656 :: SWord8 = s3642 >>> 1+  s3657 :: SWord8 = s19 | s3656+  s3658 :: SWord8 = s21 & s3656+  s3659 :: SWord8 = if s3655 then s3657 else s3658+  s3660 :: SWord8 = if s24 then s3619 else s3567+  s3661 :: SWord8 = if s165 then s3636 else s3660+  s3662 :: SWord8 = if s24 then s3641 else s3661+  s3663 :: SWord8 = if s165 then s3659 else s3662+  s3664 :: SWord8 = s3649 + s3663+  s3665 :: SBool = s3664 < s3663+  s3666 :: SBool = s3664 < s3649+  s3667 :: SBool = s3665 | s3666+  s3668 :: SWord8 = s3664 >>> 1+  s3669 :: SWord8 = s19 | s3668+  s3670 :: SWord8 = s21 & s3668+  s3671 :: SWord8 = if s3667 then s3669 else s3670+  s3672 :: SWord8 = if s3645 then s3653 else s3671+  s3673 :: SWord8 = s3630 + s3661+  s3674 :: SWord1 = choose [0:0] s3673+  s3675 :: SBool = s14 /= s3674+  s3676 :: SWord8 = if s3675 then s3639 else s3640+  s3677 :: SWord8 = if s17 then s3676 else s3636+  s3678 :: SWord1 = choose [0:0] s3677+  s3679 :: SBool = s14 /= s3678+  s3680 :: SBool = s_2 == s3679+  s3681 :: SBool = s3673 < s3661+  s3682 :: SBool = s3673 < s3630+  s3683 :: SBool = s3681 | s3682+  s3684 :: SWord8 = s3673 >>> 1+  s3685 :: SWord8 = s19 | s3684+  s3686 :: SWord8 = s21 & s3684+  s3687 :: SWord8 = if s3683 then s3685 else s3686+  s3688 :: SWord8 = s3687 >>> 1+  s3689 :: SWord8 = s19 | s3688+  s3690 :: SWord8 = s21 & s3688+  s3691 :: SWord8 = if s3679 then s3689 else s3690+  s3692 :: SWord8 = s3677 >>> 1+  s3693 :: SWord8 = s19 | s3692+  s3694 :: SWord8 = s21 & s3692+  s3695 :: SWord8 = if s3655 then s3693 else s3694+  s3696 :: SWord8 = if s24 then s3676 else s3661+  s3697 :: SWord8 = if s165 then s3695 else s3696+  s3698 :: SWord8 = s3687 + s3697+  s3699 :: SBool = s3698 < s3697+  s3700 :: SBool = s3698 < s3687+  s3701 :: SBool = s3699 | s3700+  s3702 :: SWord8 = s3698 >>> 1+  s3703 :: SWord8 = s19 | s3702+  s3704 :: SWord8 = s21 & s3702+  s3705 :: SWord8 = if s3701 then s3703 else s3704+  s3706 :: SWord8 = if s3680 then s3691 else s3705+  s3707 :: SWord8 = if s3623 then s3672 else s3706+  s3708 :: SWord8 = if s3508 then s3615 else s3707+  s3709 :: SWord8 = if s3277 then s3500 else s3708+  s3710 :: SWord8 = if s2814 then s3269 else s3709+  s3711 :: SWord8 = if s1887 then s2806 else s3710+  s3712 :: SWord8 = if s33 then s1879 else s3711+  s3713 :: SWord1 = choose [0:0] s173+  s3714 :: SBool = s14 /= s3713+  s3715 :: SWord8 = s19 | s28+  s3716 :: SWord8 = if s3714 then s3715 else s29+  s3717 :: SWord8 = if s17 then s3716 else s23+  s3718 :: SWord1 = choose [0:0] s3717+  s3719 :: SBool = s14 /= s3718+  s3720 :: SBool = s_2 == s3719+  s3721 :: SWord8 = s173 >>> 1+  s3722 :: SWord8 = s21 & s3721+  s3723 :: SWord1 = choose [0:0] s3722+  s3724 :: SBool = s14 /= s3723+  s3725 :: SWord8 = s3717 >>> 1+  s3726 :: SWord8 = s19 | s3725+  s3727 :: SWord8 = s21 & s3725+  s3728 :: SWord8 = if s38 then s3726 else s3727+  s3729 :: SWord8 = if s17 then s3728 else s3716+  s3730 :: SWord8 = s3729 >>> 1+  s3731 :: SWord8 = s19 | s3730+  s3732 :: SWord8 = s21 & s3730+  s3733 :: SWord8 = if s3724 then s3731 else s3732+  s3734 :: SWord8 = if s17 then s3733 else s3728+  s3735 :: SWord1 = choose [0:0] s3734+  s3736 :: SBool = s14 /= s3735+  s3737 :: SBool = s_2 == s3736+  s3738 :: SWord8 = s3722 >>> 1+  s3739 :: SWord8 = s19 | s3738+  s3740 :: SWord8 = s21 & s3738+  s3741 :: SWord8 = if s3719 then s3739 else s3740+  s3742 :: SWord1 = choose [0:0] s3741+  s3743 :: SBool = s14 /= s3742+  s3744 :: SWord1 = choose [0:0] s3729+  s3745 :: SBool = s14 /= s3744+  s3746 :: SWord8 = s3734 >>> 1+  s3747 :: SWord8 = s19 | s3746+  s3748 :: SWord8 = s21 & s3746+  s3749 :: SWord8 = if s3745 then s3747 else s3748+  s3750 :: SWord8 = if s17 then s3749 else s3733+  s3751 :: SWord8 = s3750 >>> 1+  s3752 :: SWord8 = s19 | s3751+  s3753 :: SWord8 = s21 & s3751+  s3754 :: SWord8 = if s3743 then s3752 else s3753+  s3755 :: SWord8 = if s17 then s3754 else s3749+  s3756 :: SWord1 = choose [0:0] s3755+  s3757 :: SBool = s14 /= s3756+  s3758 :: SBool = s_2 == s3757+  s3759 :: SWord8 = s3741 >>> 1+  s3760 :: SWord8 = s19 | s3759+  s3761 :: SWord8 = s21 & s3759+  s3762 :: SWord8 = if s3736 then s3760 else s3761+  s3763 :: SWord1 = choose [0:0] s3762+  s3764 :: SBool = s14 /= s3763+  s3765 :: SWord1 = choose [0:0] s3750+  s3766 :: SBool = s14 /= s3765+  s3767 :: SWord8 = s3755 >>> 1+  s3768 :: SWord8 = s19 | s3767+  s3769 :: SWord8 = s21 & s3767+  s3770 :: SWord8 = if s3766 then s3768 else s3769+  s3771 :: SWord8 = if s17 then s3770 else s3754+  s3772 :: SWord8 = s3771 >>> 1+  s3773 :: SWord8 = s19 | s3772+  s3774 :: SWord8 = s21 & s3772+  s3775 :: SWord8 = if s3764 then s3773 else s3774+  s3776 :: SWord8 = if s17 then s3775 else s3770+  s3777 :: SWord1 = choose [0:0] s3776+  s3778 :: SBool = s14 /= s3777+  s3779 :: SBool = s_2 == s3778+  s3780 :: SWord8 = s3762 >>> 1+  s3781 :: SWord8 = s19 | s3780+  s3782 :: SWord8 = s21 & s3780+  s3783 :: SWord8 = if s3757 then s3781 else s3782+  s3784 :: SWord1 = choose [0:0] s3783+  s3785 :: SBool = s14 /= s3784+  s3786 :: SWord1 = choose [0:0] s3771+  s3787 :: SBool = s14 /= s3786+  s3788 :: SWord8 = s3776 >>> 1+  s3789 :: SWord8 = s19 | s3788+  s3790 :: SWord8 = s21 & s3788+  s3791 :: SWord8 = if s3787 then s3789 else s3790+  s3792 :: SWord8 = if s17 then s3791 else s3775+  s3793 :: SWord8 = s3792 >>> 1+  s3794 :: SWord8 = s19 | s3793+  s3795 :: SWord8 = s21 & s3793+  s3796 :: SWord8 = if s3785 then s3794 else s3795+  s3797 :: SWord8 = if s17 then s3796 else s3791+  s3798 :: SWord1 = choose [0:0] s3797+  s3799 :: SBool = s14 /= s3798+  s3800 :: SBool = s_2 == s3799+  s3801 :: SWord8 = s3783 >>> 1+  s3802 :: SWord8 = s19 | s3801+  s3803 :: SWord8 = s21 & s3801+  s3804 :: SWord8 = if s3778 then s3802 else s3803+  s3805 :: SWord1 = choose [0:0] s3804+  s3806 :: SBool = s14 /= s3805+  s3807 :: SWord1 = choose [0:0] s3792+  s3808 :: SBool = s14 /= s3807+  s3809 :: SWord8 = s3797 >>> 1+  s3810 :: SWord8 = s19 | s3809+  s3811 :: SWord8 = s21 & s3809+  s3812 :: SWord8 = if s3808 then s3810 else s3811+  s3813 :: SWord8 = if s17 then s3812 else s3796+  s3814 :: SWord8 = s3813 >>> 1+  s3815 :: SWord8 = s19 | s3814+  s3816 :: SWord8 = s21 & s3814+  s3817 :: SWord8 = if s3806 then s3815 else s3816+  s3818 :: SWord8 = if s17 then s3817 else s3812+  s3819 :: SWord1 = choose [0:0] s3818+  s3820 :: SBool = s14 /= s3819+  s3821 :: SBool = s_2 == s3820+  s3822 :: SWord8 = s3804 >>> 1+  s3823 :: SWord8 = s19 | s3822+  s3824 :: SWord8 = s21 & s3822+  s3825 :: SWord8 = if s3799 then s3823 else s3824+  s3826 :: SWord1 = choose [0:0] s3825+  s3827 :: SBool = s14 /= s3826+  s3828 :: SWord1 = choose [0:0] s3813+  s3829 :: SBool = s14 /= s3828+  s3830 :: SWord8 = s3818 >>> 1+  s3831 :: SWord8 = s19 | s3830+  s3832 :: SWord8 = s21 & s3830+  s3833 :: SWord8 = if s3829 then s3831 else s3832+  s3834 :: SWord8 = if s17 then s3833 else s3817+  s3835 :: SWord8 = s3834 >>> 1+  s3836 :: SWord8 = s19 | s3835+  s3837 :: SWord8 = s21 & s3835+  s3838 :: SWord8 = if s3827 then s3836 else s3837+  s3839 :: SWord8 = if s17 then s3838 else s3833+  s3840 :: SWord1 = choose [0:0] s3839+  s3841 :: SBool = s14 /= s3840+  s3842 :: SBool = s_2 == s3841+  s3843 :: SWord8 = s3825 >>> 1+  s3844 :: SWord8 = s19 | s3843+  s3845 :: SWord8 = s21 & s3843+  s3846 :: SWord8 = if s3820 then s3844 else s3845+  s3847 :: SWord8 = s3846 >>> 1+  s3848 :: SWord8 = s19 | s3847+  s3849 :: SWord8 = s21 & s3847+  s3850 :: SWord8 = if s3841 then s3848 else s3849+  s3851 :: SWord1 = choose [0:0] s3834+  s3852 :: SBool = s14 /= s3851+  s3853 :: SWord8 = s3839 >>> 1+  s3854 :: SWord8 = s19 | s3853+  s3855 :: SWord8 = s21 & s3853+  s3856 :: SWord8 = if s3852 then s3854 else s3855+  s3857 :: SWord8 = if s24 then s3716 else s173+  s3858 :: SWord8 = if s165 then s3728 else s3857+  s3859 :: SWord8 = if s24 then s3733 else s3858+  s3860 :: SWord8 = if s165 then s3749 else s3859+  s3861 :: SWord8 = if s24 then s3754 else s3860+  s3862 :: SWord8 = if s165 then s3770 else s3861+  s3863 :: SWord8 = if s24 then s3775 else s3862+  s3864 :: SWord8 = if s165 then s3791 else s3863+  s3865 :: SWord8 = if s24 then s3796 else s3864+  s3866 :: SWord8 = if s165 then s3812 else s3865+  s3867 :: SWord8 = if s24 then s3817 else s3866+  s3868 :: SWord8 = if s165 then s3833 else s3867+  s3869 :: SWord8 = if s24 then s3838 else s3868+  s3870 :: SWord8 = if s165 then s3856 else s3869+  s3871 :: SWord8 = s3846 + s3870+  s3872 :: SBool = s3871 < s3870+  s3873 :: SBool = s3871 < s3846+  s3874 :: SBool = s3872 | s3873+  s3875 :: SWord8 = s3871 >>> 1+  s3876 :: SWord8 = s19 | s3875+  s3877 :: SWord8 = s21 & s3875+  s3878 :: SWord8 = if s3874 then s3876 else s3877+  s3879 :: SWord8 = if s3842 then s3850 else s3878+  s3880 :: SWord8 = s3825 + s3868+  s3881 :: SWord1 = choose [0:0] s3880+  s3882 :: SBool = s14 /= s3881+  s3883 :: SWord8 = if s3882 then s3836 else s3837+  s3884 :: SWord8 = if s17 then s3883 else s3833+  s3885 :: SWord1 = choose [0:0] s3884+  s3886 :: SBool = s14 /= s3885+  s3887 :: SBool = s_2 == s3886+  s3888 :: SBool = s3880 < s3868+  s3889 :: SBool = s3880 < s3825+  s3890 :: SBool = s3888 | s3889+  s3891 :: SWord8 = s3880 >>> 1+  s3892 :: SWord8 = s19 | s3891+  s3893 :: SWord8 = s21 & s3891+  s3894 :: SWord8 = if s3890 then s3892 else s3893+  s3895 :: SWord8 = s3894 >>> 1+  s3896 :: SWord8 = s19 | s3895+  s3897 :: SWord8 = s21 & s3895+  s3898 :: SWord8 = if s3886 then s3896 else s3897+  s3899 :: SWord8 = s3884 >>> 1+  s3900 :: SWord8 = s19 | s3899+  s3901 :: SWord8 = s21 & s3899+  s3902 :: SWord8 = if s3852 then s3900 else s3901+  s3903 :: SWord8 = if s24 then s3883 else s3868+  s3904 :: SWord8 = if s165 then s3902 else s3903+  s3905 :: SWord8 = s3894 + s3904+  s3906 :: SBool = s3905 < s3904+  s3907 :: SBool = s3905 < s3894+  s3908 :: SBool = s3906 | s3907+  s3909 :: SWord8 = s3905 >>> 1+  s3910 :: SWord8 = s19 | s3909+  s3911 :: SWord8 = s21 & s3909+  s3912 :: SWord8 = if s3908 then s3910 else s3911+  s3913 :: SWord8 = if s3887 then s3898 else s3912+  s3914 :: SWord8 = if s3821 then s3879 else s3913+  s3915 :: SWord8 = s3804 + s3866+  s3916 :: SWord1 = choose [0:0] s3915+  s3917 :: SBool = s14 /= s3916+  s3918 :: SWord8 = if s3917 then s3815 else s3816+  s3919 :: SWord8 = if s17 then s3918 else s3812+  s3920 :: SWord1 = choose [0:0] s3919+  s3921 :: SBool = s14 /= s3920+  s3922 :: SBool = s_2 == s3921+  s3923 :: SBool = s3915 < s3866+  s3924 :: SBool = s3915 < s3804+  s3925 :: SBool = s3923 | s3924+  s3926 :: SWord8 = s3915 >>> 1+  s3927 :: SWord8 = s19 | s3926+  s3928 :: SWord8 = s21 & s3926+  s3929 :: SWord8 = if s3925 then s3927 else s3928+  s3930 :: SWord1 = choose [0:0] s3929+  s3931 :: SBool = s14 /= s3930+  s3932 :: SWord8 = s3919 >>> 1+  s3933 :: SWord8 = s19 | s3932+  s3934 :: SWord8 = s21 & s3932+  s3935 :: SWord8 = if s3829 then s3933 else s3934+  s3936 :: SWord8 = if s17 then s3935 else s3918+  s3937 :: SWord8 = s3936 >>> 1+  s3938 :: SWord8 = s19 | s3937+  s3939 :: SWord8 = s21 & s3937+  s3940 :: SWord8 = if s3931 then s3938 else s3939+  s3941 :: SWord8 = if s17 then s3940 else s3935+  s3942 :: SWord1 = choose [0:0] s3941+  s3943 :: SBool = s14 /= s3942+  s3944 :: SBool = s_2 == s3943+  s3945 :: SWord8 = s3929 >>> 1+  s3946 :: SWord8 = s19 | s3945+  s3947 :: SWord8 = s21 & s3945+  s3948 :: SWord8 = if s3921 then s3946 else s3947+  s3949 :: SWord8 = s3948 >>> 1+  s3950 :: SWord8 = s19 | s3949+  s3951 :: SWord8 = s21 & s3949+  s3952 :: SWord8 = if s3943 then s3950 else s3951+  s3953 :: SWord1 = choose [0:0] s3936+  s3954 :: SBool = s14 /= s3953+  s3955 :: SWord8 = s3941 >>> 1+  s3956 :: SWord8 = s19 | s3955+  s3957 :: SWord8 = s21 & s3955+  s3958 :: SWord8 = if s3954 then s3956 else s3957+  s3959 :: SWord8 = if s24 then s3918 else s3866+  s3960 :: SWord8 = if s165 then s3935 else s3959+  s3961 :: SWord8 = if s24 then s3940 else s3960+  s3962 :: SWord8 = if s165 then s3958 else s3961+  s3963 :: SWord8 = s3948 + s3962+  s3964 :: SBool = s3963 < s3962+  s3965 :: SBool = s3963 < s3948+  s3966 :: SBool = s3964 | s3965+  s3967 :: SWord8 = s3963 >>> 1+  s3968 :: SWord8 = s19 | s3967+  s3969 :: SWord8 = s21 & s3967+  s3970 :: SWord8 = if s3966 then s3968 else s3969+  s3971 :: SWord8 = if s3944 then s3952 else s3970+  s3972 :: SWord8 = s3929 + s3960+  s3973 :: SWord1 = choose [0:0] s3972+  s3974 :: SBool = s14 /= s3973+  s3975 :: SWord8 = if s3974 then s3938 else s3939+  s3976 :: SWord8 = if s17 then s3975 else s3935+  s3977 :: SWord1 = choose [0:0] s3976+  s3978 :: SBool = s14 /= s3977+  s3979 :: SBool = s_2 == s3978+  s3980 :: SBool = s3972 < s3960+  s3981 :: SBool = s3972 < s3929+  s3982 :: SBool = s3980 | s3981+  s3983 :: SWord8 = s3972 >>> 1+  s3984 :: SWord8 = s19 | s3983+  s3985 :: SWord8 = s21 & s3983+  s3986 :: SWord8 = if s3982 then s3984 else s3985+  s3987 :: SWord8 = s3986 >>> 1+  s3988 :: SWord8 = s19 | s3987+  s3989 :: SWord8 = s21 & s3987+  s3990 :: SWord8 = if s3978 then s3988 else s3989+  s3991 :: SWord8 = s3976 >>> 1+  s3992 :: SWord8 = s19 | s3991+  s3993 :: SWord8 = s21 & s3991+  s3994 :: SWord8 = if s3954 then s3992 else s3993+  s3995 :: SWord8 = if s24 then s3975 else s3960+  s3996 :: SWord8 = if s165 then s3994 else s3995+  s3997 :: SWord8 = s3986 + s3996+  s3998 :: SBool = s3997 < s3996+  s3999 :: SBool = s3997 < s3986+  s4000 :: SBool = s3998 | s3999+  s4001 :: SWord8 = s3997 >>> 1+  s4002 :: SWord8 = s19 | s4001+  s4003 :: SWord8 = s21 & s4001+  s4004 :: SWord8 = if s4000 then s4002 else s4003+  s4005 :: SWord8 = if s3979 then s3990 else s4004+  s4006 :: SWord8 = if s3922 then s3971 else s4005+  s4007 :: SWord8 = if s3800 then s3914 else s4006+  s4008 :: SWord8 = s3783 + s3864+  s4009 :: SWord1 = choose [0:0] s4008+  s4010 :: SBool = s14 /= s4009+  s4011 :: SWord8 = if s4010 then s3794 else s3795+  s4012 :: SWord8 = if s17 then s4011 else s3791+  s4013 :: SWord1 = choose [0:0] s4012+  s4014 :: SBool = s14 /= s4013+  s4015 :: SBool = s_2 == s4014+  s4016 :: SBool = s4008 < s3864+  s4017 :: SBool = s4008 < s3783+  s4018 :: SBool = s4016 | s4017+  s4019 :: SWord8 = s4008 >>> 1+  s4020 :: SWord8 = s19 | s4019+  s4021 :: SWord8 = s21 & s4019+  s4022 :: SWord8 = if s4018 then s4020 else s4021+  s4023 :: SWord1 = choose [0:0] s4022+  s4024 :: SBool = s14 /= s4023+  s4025 :: SWord8 = s4012 >>> 1+  s4026 :: SWord8 = s19 | s4025+  s4027 :: SWord8 = s21 & s4025+  s4028 :: SWord8 = if s3808 then s4026 else s4027+  s4029 :: SWord8 = if s17 then s4028 else s4011+  s4030 :: SWord8 = s4029 >>> 1+  s4031 :: SWord8 = s19 | s4030+  s4032 :: SWord8 = s21 & s4030+  s4033 :: SWord8 = if s4024 then s4031 else s4032+  s4034 :: SWord8 = if s17 then s4033 else s4028+  s4035 :: SWord1 = choose [0:0] s4034+  s4036 :: SBool = s14 /= s4035+  s4037 :: SBool = s_2 == s4036+  s4038 :: SWord8 = s4022 >>> 1+  s4039 :: SWord8 = s19 | s4038+  s4040 :: SWord8 = s21 & s4038+  s4041 :: SWord8 = if s4014 then s4039 else s4040+  s4042 :: SWord1 = choose [0:0] s4041+  s4043 :: SBool = s14 /= s4042+  s4044 :: SWord1 = choose [0:0] s4029+  s4045 :: SBool = s14 /= s4044+  s4046 :: SWord8 = s4034 >>> 1+  s4047 :: SWord8 = s19 | s4046+  s4048 :: SWord8 = s21 & s4046+  s4049 :: SWord8 = if s4045 then s4047 else s4048+  s4050 :: SWord8 = if s17 then s4049 else s4033+  s4051 :: SWord8 = s4050 >>> 1+  s4052 :: SWord8 = s19 | s4051+  s4053 :: SWord8 = s21 & s4051+  s4054 :: SWord8 = if s4043 then s4052 else s4053+  s4055 :: SWord8 = if s17 then s4054 else s4049+  s4056 :: SWord1 = choose [0:0] s4055+  s4057 :: SBool = s14 /= s4056+  s4058 :: SBool = s_2 == s4057+  s4059 :: SWord8 = s4041 >>> 1+  s4060 :: SWord8 = s19 | s4059+  s4061 :: SWord8 = s21 & s4059+  s4062 :: SWord8 = if s4036 then s4060 else s4061+  s4063 :: SWord8 = s4062 >>> 1+  s4064 :: SWord8 = s19 | s4063+  s4065 :: SWord8 = s21 & s4063+  s4066 :: SWord8 = if s4057 then s4064 else s4065+  s4067 :: SWord1 = choose [0:0] s4050+  s4068 :: SBool = s14 /= s4067+  s4069 :: SWord8 = s4055 >>> 1+  s4070 :: SWord8 = s19 | s4069+  s4071 :: SWord8 = s21 & s4069+  s4072 :: SWord8 = if s4068 then s4070 else s4071+  s4073 :: SWord8 = if s24 then s4011 else s3864+  s4074 :: SWord8 = if s165 then s4028 else s4073+  s4075 :: SWord8 = if s24 then s4033 else s4074+  s4076 :: SWord8 = if s165 then s4049 else s4075+  s4077 :: SWord8 = if s24 then s4054 else s4076+  s4078 :: SWord8 = if s165 then s4072 else s4077+  s4079 :: SWord8 = s4062 + s4078+  s4080 :: SBool = s4079 < s4078+  s4081 :: SBool = s4079 < s4062+  s4082 :: SBool = s4080 | s4081+  s4083 :: SWord8 = s4079 >>> 1+  s4084 :: SWord8 = s19 | s4083+  s4085 :: SWord8 = s21 & s4083+  s4086 :: SWord8 = if s4082 then s4084 else s4085+  s4087 :: SWord8 = if s4058 then s4066 else s4086+  s4088 :: SWord8 = s4041 + s4076+  s4089 :: SWord1 = choose [0:0] s4088+  s4090 :: SBool = s14 /= s4089+  s4091 :: SWord8 = if s4090 then s4052 else s4053+  s4092 :: SWord8 = if s17 then s4091 else s4049+  s4093 :: SWord1 = choose [0:0] s4092+  s4094 :: SBool = s14 /= s4093+  s4095 :: SBool = s_2 == s4094+  s4096 :: SBool = s4088 < s4076+  s4097 :: SBool = s4088 < s4041+  s4098 :: SBool = s4096 | s4097+  s4099 :: SWord8 = s4088 >>> 1+  s4100 :: SWord8 = s19 | s4099+  s4101 :: SWord8 = s21 & s4099+  s4102 :: SWord8 = if s4098 then s4100 else s4101+  s4103 :: SWord8 = s4102 >>> 1+  s4104 :: SWord8 = s19 | s4103+  s4105 :: SWord8 = s21 & s4103+  s4106 :: SWord8 = if s4094 then s4104 else s4105+  s4107 :: SWord8 = s4092 >>> 1+  s4108 :: SWord8 = s19 | s4107+  s4109 :: SWord8 = s21 & s4107+  s4110 :: SWord8 = if s4068 then s4108 else s4109+  s4111 :: SWord8 = if s24 then s4091 else s4076+  s4112 :: SWord8 = if s165 then s4110 else s4111+  s4113 :: SWord8 = s4102 + s4112+  s4114 :: SBool = s4113 < s4112+  s4115 :: SBool = s4113 < s4102+  s4116 :: SBool = s4114 | s4115+  s4117 :: SWord8 = s4113 >>> 1+  s4118 :: SWord8 = s19 | s4117+  s4119 :: SWord8 = s21 & s4117+  s4120 :: SWord8 = if s4116 then s4118 else s4119+  s4121 :: SWord8 = if s4095 then s4106 else s4120+  s4122 :: SWord8 = if s4037 then s4087 else s4121+  s4123 :: SWord8 = s4022 + s4074+  s4124 :: SWord1 = choose [0:0] s4123+  s4125 :: SBool = s14 /= s4124+  s4126 :: SWord8 = if s4125 then s4031 else s4032+  s4127 :: SWord8 = if s17 then s4126 else s4028+  s4128 :: SWord1 = choose [0:0] s4127+  s4129 :: SBool = s14 /= s4128+  s4130 :: SBool = s_2 == s4129+  s4131 :: SBool = s4123 < s4074+  s4132 :: SBool = s4123 < s4022+  s4133 :: SBool = s4131 | s4132+  s4134 :: SWord8 = s4123 >>> 1+  s4135 :: SWord8 = s19 | s4134+  s4136 :: SWord8 = s21 & s4134+  s4137 :: SWord8 = if s4133 then s4135 else s4136+  s4138 :: SWord1 = choose [0:0] s4137+  s4139 :: SBool = s14 /= s4138+  s4140 :: SWord8 = s4127 >>> 1+  s4141 :: SWord8 = s19 | s4140+  s4142 :: SWord8 = s21 & s4140+  s4143 :: SWord8 = if s4045 then s4141 else s4142+  s4144 :: SWord8 = if s17 then s4143 else s4126+  s4145 :: SWord8 = s4144 >>> 1+  s4146 :: SWord8 = s19 | s4145+  s4147 :: SWord8 = s21 & s4145+  s4148 :: SWord8 = if s4139 then s4146 else s4147+  s4149 :: SWord8 = if s17 then s4148 else s4143+  s4150 :: SWord1 = choose [0:0] s4149+  s4151 :: SBool = s14 /= s4150+  s4152 :: SBool = s_2 == s4151+  s4153 :: SWord8 = s4137 >>> 1+  s4154 :: SWord8 = s19 | s4153+  s4155 :: SWord8 = s21 & s4153+  s4156 :: SWord8 = if s4129 then s4154 else s4155+  s4157 :: SWord8 = s4156 >>> 1+  s4158 :: SWord8 = s19 | s4157+  s4159 :: SWord8 = s21 & s4157+  s4160 :: SWord8 = if s4151 then s4158 else s4159+  s4161 :: SWord1 = choose [0:0] s4144+  s4162 :: SBool = s14 /= s4161+  s4163 :: SWord8 = s4149 >>> 1+  s4164 :: SWord8 = s19 | s4163+  s4165 :: SWord8 = s21 & s4163+  s4166 :: SWord8 = if s4162 then s4164 else s4165+  s4167 :: SWord8 = if s24 then s4126 else s4074+  s4168 :: SWord8 = if s165 then s4143 else s4167+  s4169 :: SWord8 = if s24 then s4148 else s4168+  s4170 :: SWord8 = if s165 then s4166 else s4169+  s4171 :: SWord8 = s4156 + s4170+  s4172 :: SBool = s4171 < s4170+  s4173 :: SBool = s4171 < s4156+  s4174 :: SBool = s4172 | s4173+  s4175 :: SWord8 = s4171 >>> 1+  s4176 :: SWord8 = s19 | s4175+  s4177 :: SWord8 = s21 & s4175+  s4178 :: SWord8 = if s4174 then s4176 else s4177+  s4179 :: SWord8 = if s4152 then s4160 else s4178+  s4180 :: SWord8 = s4137 + s4168+  s4181 :: SWord1 = choose [0:0] s4180+  s4182 :: SBool = s14 /= s4181+  s4183 :: SWord8 = if s4182 then s4146 else s4147+  s4184 :: SWord8 = if s17 then s4183 else s4143+  s4185 :: SWord1 = choose [0:0] s4184+  s4186 :: SBool = s14 /= s4185+  s4187 :: SBool = s_2 == s4186+  s4188 :: SBool = s4180 < s4168+  s4189 :: SBool = s4180 < s4137+  s4190 :: SBool = s4188 | s4189+  s4191 :: SWord8 = s4180 >>> 1+  s4192 :: SWord8 = s19 | s4191+  s4193 :: SWord8 = s21 & s4191+  s4194 :: SWord8 = if s4190 then s4192 else s4193+  s4195 :: SWord8 = s4194 >>> 1+  s4196 :: SWord8 = s19 | s4195+  s4197 :: SWord8 = s21 & s4195+  s4198 :: SWord8 = if s4186 then s4196 else s4197+  s4199 :: SWord8 = s4184 >>> 1+  s4200 :: SWord8 = s19 | s4199+  s4201 :: SWord8 = s21 & s4199+  s4202 :: SWord8 = if s4162 then s4200 else s4201+  s4203 :: SWord8 = if s24 then s4183 else s4168+  s4204 :: SWord8 = if s165 then s4202 else s4203+  s4205 :: SWord8 = s4194 + s4204+  s4206 :: SBool = s4205 < s4204+  s4207 :: SBool = s4205 < s4194+  s4208 :: SBool = s4206 | s4207+  s4209 :: SWord8 = s4205 >>> 1+  s4210 :: SWord8 = s19 | s4209+  s4211 :: SWord8 = s21 & s4209+  s4212 :: SWord8 = if s4208 then s4210 else s4211+  s4213 :: SWord8 = if s4187 then s4198 else s4212+  s4214 :: SWord8 = if s4130 then s4179 else s4213+  s4215 :: SWord8 = if s4015 then s4122 else s4214+  s4216 :: SWord8 = if s3779 then s4007 else s4215+  s4217 :: SWord8 = s3762 + s3862+  s4218 :: SWord1 = choose [0:0] s4217+  s4219 :: SBool = s14 /= s4218+  s4220 :: SWord8 = if s4219 then s3773 else s3774+  s4221 :: SWord8 = if s17 then s4220 else s3770+  s4222 :: SWord1 = choose [0:0] s4221+  s4223 :: SBool = s14 /= s4222+  s4224 :: SBool = s_2 == s4223+  s4225 :: SBool = s4217 < s3862+  s4226 :: SBool = s4217 < s3762+  s4227 :: SBool = s4225 | s4226+  s4228 :: SWord8 = s4217 >>> 1+  s4229 :: SWord8 = s19 | s4228+  s4230 :: SWord8 = s21 & s4228+  s4231 :: SWord8 = if s4227 then s4229 else s4230+  s4232 :: SWord1 = choose [0:0] s4231+  s4233 :: SBool = s14 /= s4232+  s4234 :: SWord8 = s4221 >>> 1+  s4235 :: SWord8 = s19 | s4234+  s4236 :: SWord8 = s21 & s4234+  s4237 :: SWord8 = if s3787 then s4235 else s4236+  s4238 :: SWord8 = if s17 then s4237 else s4220+  s4239 :: SWord8 = s4238 >>> 1+  s4240 :: SWord8 = s19 | s4239+  s4241 :: SWord8 = s21 & s4239+  s4242 :: SWord8 = if s4233 then s4240 else s4241+  s4243 :: SWord8 = if s17 then s4242 else s4237+  s4244 :: SWord1 = choose [0:0] s4243+  s4245 :: SBool = s14 /= s4244+  s4246 :: SBool = s_2 == s4245+  s4247 :: SWord8 = s4231 >>> 1+  s4248 :: SWord8 = s19 | s4247+  s4249 :: SWord8 = s21 & s4247+  s4250 :: SWord8 = if s4223 then s4248 else s4249+  s4251 :: SWord1 = choose [0:0] s4250+  s4252 :: SBool = s14 /= s4251+  s4253 :: SWord1 = choose [0:0] s4238+  s4254 :: SBool = s14 /= s4253+  s4255 :: SWord8 = s4243 >>> 1+  s4256 :: SWord8 = s19 | s4255+  s4257 :: SWord8 = s21 & s4255+  s4258 :: SWord8 = if s4254 then s4256 else s4257+  s4259 :: SWord8 = if s17 then s4258 else s4242+  s4260 :: SWord8 = s4259 >>> 1+  s4261 :: SWord8 = s19 | s4260+  s4262 :: SWord8 = s21 & s4260+  s4263 :: SWord8 = if s4252 then s4261 else s4262+  s4264 :: SWord8 = if s17 then s4263 else s4258+  s4265 :: SWord1 = choose [0:0] s4264+  s4266 :: SBool = s14 /= s4265+  s4267 :: SBool = s_2 == s4266+  s4268 :: SWord8 = s4250 >>> 1+  s4269 :: SWord8 = s19 | s4268+  s4270 :: SWord8 = s21 & s4268+  s4271 :: SWord8 = if s4245 then s4269 else s4270+  s4272 :: SWord1 = choose [0:0] s4271+  s4273 :: SBool = s14 /= s4272+  s4274 :: SWord1 = choose [0:0] s4259+  s4275 :: SBool = s14 /= s4274+  s4276 :: SWord8 = s4264 >>> 1+  s4277 :: SWord8 = s19 | s4276+  s4278 :: SWord8 = s21 & s4276+  s4279 :: SWord8 = if s4275 then s4277 else s4278+  s4280 :: SWord8 = if s17 then s4279 else s4263+  s4281 :: SWord8 = s4280 >>> 1+  s4282 :: SWord8 = s19 | s4281+  s4283 :: SWord8 = s21 & s4281+  s4284 :: SWord8 = if s4273 then s4282 else s4283+  s4285 :: SWord8 = if s17 then s4284 else s4279+  s4286 :: SWord1 = choose [0:0] s4285+  s4287 :: SBool = s14 /= s4286+  s4288 :: SBool = s_2 == s4287+  s4289 :: SWord8 = s4271 >>> 1+  s4290 :: SWord8 = s19 | s4289+  s4291 :: SWord8 = s21 & s4289+  s4292 :: SWord8 = if s4266 then s4290 else s4291+  s4293 :: SWord8 = s4292 >>> 1+  s4294 :: SWord8 = s19 | s4293+  s4295 :: SWord8 = s21 & s4293+  s4296 :: SWord8 = if s4287 then s4294 else s4295+  s4297 :: SWord1 = choose [0:0] s4280+  s4298 :: SBool = s14 /= s4297+  s4299 :: SWord8 = s4285 >>> 1+  s4300 :: SWord8 = s19 | s4299+  s4301 :: SWord8 = s21 & s4299+  s4302 :: SWord8 = if s4298 then s4300 else s4301+  s4303 :: SWord8 = if s24 then s4220 else s3862+  s4304 :: SWord8 = if s165 then s4237 else s4303+  s4305 :: SWord8 = if s24 then s4242 else s4304+  s4306 :: SWord8 = if s165 then s4258 else s4305+  s4307 :: SWord8 = if s24 then s4263 else s4306+  s4308 :: SWord8 = if s165 then s4279 else s4307+  s4309 :: SWord8 = if s24 then s4284 else s4308+  s4310 :: SWord8 = if s165 then s4302 else s4309+  s4311 :: SWord8 = s4292 + s4310+  s4312 :: SBool = s4311 < s4310+  s4313 :: SBool = s4311 < s4292+  s4314 :: SBool = s4312 | s4313+  s4315 :: SWord8 = s4311 >>> 1+  s4316 :: SWord8 = s19 | s4315+  s4317 :: SWord8 = s21 & s4315+  s4318 :: SWord8 = if s4314 then s4316 else s4317+  s4319 :: SWord8 = if s4288 then s4296 else s4318+  s4320 :: SWord8 = s4271 + s4308+  s4321 :: SWord1 = choose [0:0] s4320+  s4322 :: SBool = s14 /= s4321+  s4323 :: SWord8 = if s4322 then s4282 else s4283+  s4324 :: SWord8 = if s17 then s4323 else s4279+  s4325 :: SWord1 = choose [0:0] s4324+  s4326 :: SBool = s14 /= s4325+  s4327 :: SBool = s_2 == s4326+  s4328 :: SBool = s4320 < s4308+  s4329 :: SBool = s4320 < s4271+  s4330 :: SBool = s4328 | s4329+  s4331 :: SWord8 = s4320 >>> 1+  s4332 :: SWord8 = s19 | s4331+  s4333 :: SWord8 = s21 & s4331+  s4334 :: SWord8 = if s4330 then s4332 else s4333+  s4335 :: SWord8 = s4334 >>> 1+  s4336 :: SWord8 = s19 | s4335+  s4337 :: SWord8 = s21 & s4335+  s4338 :: SWord8 = if s4326 then s4336 else s4337+  s4339 :: SWord8 = s4324 >>> 1+  s4340 :: SWord8 = s19 | s4339+  s4341 :: SWord8 = s21 & s4339+  s4342 :: SWord8 = if s4298 then s4340 else s4341+  s4343 :: SWord8 = if s24 then s4323 else s4308+  s4344 :: SWord8 = if s165 then s4342 else s4343+  s4345 :: SWord8 = s4334 + s4344+  s4346 :: SBool = s4345 < s4344+  s4347 :: SBool = s4345 < s4334+  s4348 :: SBool = s4346 | s4347+  s4349 :: SWord8 = s4345 >>> 1+  s4350 :: SWord8 = s19 | s4349+  s4351 :: SWord8 = s21 & s4349+  s4352 :: SWord8 = if s4348 then s4350 else s4351+  s4353 :: SWord8 = if s4327 then s4338 else s4352+  s4354 :: SWord8 = if s4267 then s4319 else s4353+  s4355 :: SWord8 = s4250 + s4306+  s4356 :: SWord1 = choose [0:0] s4355+  s4357 :: SBool = s14 /= s4356+  s4358 :: SWord8 = if s4357 then s4261 else s4262+  s4359 :: SWord8 = if s17 then s4358 else s4258+  s4360 :: SWord1 = choose [0:0] s4359+  s4361 :: SBool = s14 /= s4360+  s4362 :: SBool = s_2 == s4361+  s4363 :: SBool = s4355 < s4306+  s4364 :: SBool = s4355 < s4250+  s4365 :: SBool = s4363 | s4364+  s4366 :: SWord8 = s4355 >>> 1+  s4367 :: SWord8 = s19 | s4366+  s4368 :: SWord8 = s21 & s4366+  s4369 :: SWord8 = if s4365 then s4367 else s4368+  s4370 :: SWord1 = choose [0:0] s4369+  s4371 :: SBool = s14 /= s4370+  s4372 :: SWord8 = s4359 >>> 1+  s4373 :: SWord8 = s19 | s4372+  s4374 :: SWord8 = s21 & s4372+  s4375 :: SWord8 = if s4275 then s4373 else s4374+  s4376 :: SWord8 = if s17 then s4375 else s4358+  s4377 :: SWord8 = s4376 >>> 1+  s4378 :: SWord8 = s19 | s4377+  s4379 :: SWord8 = s21 & s4377+  s4380 :: SWord8 = if s4371 then s4378 else s4379+  s4381 :: SWord8 = if s17 then s4380 else s4375+  s4382 :: SWord1 = choose [0:0] s4381+  s4383 :: SBool = s14 /= s4382+  s4384 :: SBool = s_2 == s4383+  s4385 :: SWord8 = s4369 >>> 1+  s4386 :: SWord8 = s19 | s4385+  s4387 :: SWord8 = s21 & s4385+  s4388 :: SWord8 = if s4361 then s4386 else s4387+  s4389 :: SWord8 = s4388 >>> 1+  s4390 :: SWord8 = s19 | s4389+  s4391 :: SWord8 = s21 & s4389+  s4392 :: SWord8 = if s4383 then s4390 else s4391+  s4393 :: SWord1 = choose [0:0] s4376+  s4394 :: SBool = s14 /= s4393+  s4395 :: SWord8 = s4381 >>> 1+  s4396 :: SWord8 = s19 | s4395+  s4397 :: SWord8 = s21 & s4395+  s4398 :: SWord8 = if s4394 then s4396 else s4397+  s4399 :: SWord8 = if s24 then s4358 else s4306+  s4400 :: SWord8 = if s165 then s4375 else s4399+  s4401 :: SWord8 = if s24 then s4380 else s4400+  s4402 :: SWord8 = if s165 then s4398 else s4401+  s4403 :: SWord8 = s4388 + s4402+  s4404 :: SBool = s4403 < s4402+  s4405 :: SBool = s4403 < s4388+  s4406 :: SBool = s4404 | s4405+  s4407 :: SWord8 = s4403 >>> 1+  s4408 :: SWord8 = s19 | s4407+  s4409 :: SWord8 = s21 & s4407+  s4410 :: SWord8 = if s4406 then s4408 else s4409+  s4411 :: SWord8 = if s4384 then s4392 else s4410+  s4412 :: SWord8 = s4369 + s4400+  s4413 :: SWord1 = choose [0:0] s4412+  s4414 :: SBool = s14 /= s4413+  s4415 :: SWord8 = if s4414 then s4378 else s4379+  s4416 :: SWord8 = if s17 then s4415 else s4375+  s4417 :: SWord1 = choose [0:0] s4416+  s4418 :: SBool = s14 /= s4417+  s4419 :: SBool = s_2 == s4418+  s4420 :: SBool = s4412 < s4400+  s4421 :: SBool = s4412 < s4369+  s4422 :: SBool = s4420 | s4421+  s4423 :: SWord8 = s4412 >>> 1+  s4424 :: SWord8 = s19 | s4423+  s4425 :: SWord8 = s21 & s4423+  s4426 :: SWord8 = if s4422 then s4424 else s4425+  s4427 :: SWord8 = s4426 >>> 1+  s4428 :: SWord8 = s19 | s4427+  s4429 :: SWord8 = s21 & s4427+  s4430 :: SWord8 = if s4418 then s4428 else s4429+  s4431 :: SWord8 = s4416 >>> 1+  s4432 :: SWord8 = s19 | s4431+  s4433 :: SWord8 = s21 & s4431+  s4434 :: SWord8 = if s4394 then s4432 else s4433+  s4435 :: SWord8 = if s24 then s4415 else s4400+  s4436 :: SWord8 = if s165 then s4434 else s4435+  s4437 :: SWord8 = s4426 + s4436+  s4438 :: SBool = s4437 < s4436+  s4439 :: SBool = s4437 < s4426+  s4440 :: SBool = s4438 | s4439+  s4441 :: SWord8 = s4437 >>> 1+  s4442 :: SWord8 = s19 | s4441+  s4443 :: SWord8 = s21 & s4441+  s4444 :: SWord8 = if s4440 then s4442 else s4443+  s4445 :: SWord8 = if s4419 then s4430 else s4444+  s4446 :: SWord8 = if s4362 then s4411 else s4445+  s4447 :: SWord8 = if s4246 then s4354 else s4446+  s4448 :: SWord8 = s4231 + s4304+  s4449 :: SWord1 = choose [0:0] s4448+  s4450 :: SBool = s14 /= s4449+  s4451 :: SWord8 = if s4450 then s4240 else s4241+  s4452 :: SWord8 = if s17 then s4451 else s4237+  s4453 :: SWord1 = choose [0:0] s4452+  s4454 :: SBool = s14 /= s4453+  s4455 :: SBool = s_2 == s4454+  s4456 :: SBool = s4448 < s4304+  s4457 :: SBool = s4448 < s4231+  s4458 :: SBool = s4456 | s4457+  s4459 :: SWord8 = s4448 >>> 1+  s4460 :: SWord8 = s19 | s4459+  s4461 :: SWord8 = s21 & s4459+  s4462 :: SWord8 = if s4458 then s4460 else s4461+  s4463 :: SWord1 = choose [0:0] s4462+  s4464 :: SBool = s14 /= s4463+  s4465 :: SWord8 = s4452 >>> 1+  s4466 :: SWord8 = s19 | s4465+  s4467 :: SWord8 = s21 & s4465+  s4468 :: SWord8 = if s4254 then s4466 else s4467+  s4469 :: SWord8 = if s17 then s4468 else s4451+  s4470 :: SWord8 = s4469 >>> 1+  s4471 :: SWord8 = s19 | s4470+  s4472 :: SWord8 = s21 & s4470+  s4473 :: SWord8 = if s4464 then s4471 else s4472+  s4474 :: SWord8 = if s17 then s4473 else s4468+  s4475 :: SWord1 = choose [0:0] s4474+  s4476 :: SBool = s14 /= s4475+  s4477 :: SBool = s_2 == s4476+  s4478 :: SWord8 = s4462 >>> 1+  s4479 :: SWord8 = s19 | s4478+  s4480 :: SWord8 = s21 & s4478+  s4481 :: SWord8 = if s4454 then s4479 else s4480+  s4482 :: SWord1 = choose [0:0] s4481+  s4483 :: SBool = s14 /= s4482+  s4484 :: SWord1 = choose [0:0] s4469+  s4485 :: SBool = s14 /= s4484+  s4486 :: SWord8 = s4474 >>> 1+  s4487 :: SWord8 = s19 | s4486+  s4488 :: SWord8 = s21 & s4486+  s4489 :: SWord8 = if s4485 then s4487 else s4488+  s4490 :: SWord8 = if s17 then s4489 else s4473+  s4491 :: SWord8 = s4490 >>> 1+  s4492 :: SWord8 = s19 | s4491+  s4493 :: SWord8 = s21 & s4491+  s4494 :: SWord8 = if s4483 then s4492 else s4493+  s4495 :: SWord8 = if s17 then s4494 else s4489+  s4496 :: SWord1 = choose [0:0] s4495+  s4497 :: SBool = s14 /= s4496+  s4498 :: SBool = s_2 == s4497+  s4499 :: SWord8 = s4481 >>> 1+  s4500 :: SWord8 = s19 | s4499+  s4501 :: SWord8 = s21 & s4499+  s4502 :: SWord8 = if s4476 then s4500 else s4501+  s4503 :: SWord8 = s4502 >>> 1+  s4504 :: SWord8 = s19 | s4503+  s4505 :: SWord8 = s21 & s4503+  s4506 :: SWord8 = if s4497 then s4504 else s4505+  s4507 :: SWord1 = choose [0:0] s4490+  s4508 :: SBool = s14 /= s4507+  s4509 :: SWord8 = s4495 >>> 1+  s4510 :: SWord8 = s19 | s4509+  s4511 :: SWord8 = s21 & s4509+  s4512 :: SWord8 = if s4508 then s4510 else s4511+  s4513 :: SWord8 = if s24 then s4451 else s4304+  s4514 :: SWord8 = if s165 then s4468 else s4513+  s4515 :: SWord8 = if s24 then s4473 else s4514+  s4516 :: SWord8 = if s165 then s4489 else s4515+  s4517 :: SWord8 = if s24 then s4494 else s4516+  s4518 :: SWord8 = if s165 then s4512 else s4517+  s4519 :: SWord8 = s4502 + s4518+  s4520 :: SBool = s4519 < s4518+  s4521 :: SBool = s4519 < s4502+  s4522 :: SBool = s4520 | s4521+  s4523 :: SWord8 = s4519 >>> 1+  s4524 :: SWord8 = s19 | s4523+  s4525 :: SWord8 = s21 & s4523+  s4526 :: SWord8 = if s4522 then s4524 else s4525+  s4527 :: SWord8 = if s4498 then s4506 else s4526+  s4528 :: SWord8 = s4481 + s4516+  s4529 :: SWord1 = choose [0:0] s4528+  s4530 :: SBool = s14 /= s4529+  s4531 :: SWord8 = if s4530 then s4492 else s4493+  s4532 :: SWord8 = if s17 then s4531 else s4489+  s4533 :: SWord1 = choose [0:0] s4532+  s4534 :: SBool = s14 /= s4533+  s4535 :: SBool = s_2 == s4534+  s4536 :: SBool = s4528 < s4516+  s4537 :: SBool = s4528 < s4481+  s4538 :: SBool = s4536 | s4537+  s4539 :: SWord8 = s4528 >>> 1+  s4540 :: SWord8 = s19 | s4539+  s4541 :: SWord8 = s21 & s4539+  s4542 :: SWord8 = if s4538 then s4540 else s4541+  s4543 :: SWord8 = s4542 >>> 1+  s4544 :: SWord8 = s19 | s4543+  s4545 :: SWord8 = s21 & s4543+  s4546 :: SWord8 = if s4534 then s4544 else s4545+  s4547 :: SWord8 = s4532 >>> 1+  s4548 :: SWord8 = s19 | s4547+  s4549 :: SWord8 = s21 & s4547+  s4550 :: SWord8 = if s4508 then s4548 else s4549+  s4551 :: SWord8 = if s24 then s4531 else s4516+  s4552 :: SWord8 = if s165 then s4550 else s4551+  s4553 :: SWord8 = s4542 + s4552+  s4554 :: SBool = s4553 < s4552+  s4555 :: SBool = s4553 < s4542+  s4556 :: SBool = s4554 | s4555+  s4557 :: SWord8 = s4553 >>> 1+  s4558 :: SWord8 = s19 | s4557+  s4559 :: SWord8 = s21 & s4557+  s4560 :: SWord8 = if s4556 then s4558 else s4559+  s4561 :: SWord8 = if s4535 then s4546 else s4560+  s4562 :: SWord8 = if s4477 then s4527 else s4561+  s4563 :: SWord8 = s4462 + s4514+  s4564 :: SWord1 = choose [0:0] s4563+  s4565 :: SBool = s14 /= s4564+  s4566 :: SWord8 = if s4565 then s4471 else s4472+  s4567 :: SWord8 = if s17 then s4566 else s4468+  s4568 :: SWord1 = choose [0:0] s4567+  s4569 :: SBool = s14 /= s4568+  s4570 :: SBool = s_2 == s4569+  s4571 :: SBool = s4563 < s4514+  s4572 :: SBool = s4563 < s4462+  s4573 :: SBool = s4571 | s4572+  s4574 :: SWord8 = s4563 >>> 1+  s4575 :: SWord8 = s19 | s4574+  s4576 :: SWord8 = s21 & s4574+  s4577 :: SWord8 = if s4573 then s4575 else s4576+  s4578 :: SWord1 = choose [0:0] s4577+  s4579 :: SBool = s14 /= s4578+  s4580 :: SWord8 = s4567 >>> 1+  s4581 :: SWord8 = s19 | s4580+  s4582 :: SWord8 = s21 & s4580+  s4583 :: SWord8 = if s4485 then s4581 else s4582+  s4584 :: SWord8 = if s17 then s4583 else s4566+  s4585 :: SWord8 = s4584 >>> 1+  s4586 :: SWord8 = s19 | s4585+  s4587 :: SWord8 = s21 & s4585+  s4588 :: SWord8 = if s4579 then s4586 else s4587+  s4589 :: SWord8 = if s17 then s4588 else s4583+  s4590 :: SWord1 = choose [0:0] s4589+  s4591 :: SBool = s14 /= s4590+  s4592 :: SBool = s_2 == s4591+  s4593 :: SWord8 = s4577 >>> 1+  s4594 :: SWord8 = s19 | s4593+  s4595 :: SWord8 = s21 & s4593+  s4596 :: SWord8 = if s4569 then s4594 else s4595+  s4597 :: SWord8 = s4596 >>> 1+  s4598 :: SWord8 = s19 | s4597+  s4599 :: SWord8 = s21 & s4597+  s4600 :: SWord8 = if s4591 then s4598 else s4599+  s4601 :: SWord1 = choose [0:0] s4584+  s4602 :: SBool = s14 /= s4601+  s4603 :: SWord8 = s4589 >>> 1+  s4604 :: SWord8 = s19 | s4603+  s4605 :: SWord8 = s21 & s4603+  s4606 :: SWord8 = if s4602 then s4604 else s4605+  s4607 :: SWord8 = if s24 then s4566 else s4514+  s4608 :: SWord8 = if s165 then s4583 else s4607+  s4609 :: SWord8 = if s24 then s4588 else s4608+  s4610 :: SWord8 = if s165 then s4606 else s4609+  s4611 :: SWord8 = s4596 + s4610+  s4612 :: SBool = s4611 < s4610+  s4613 :: SBool = s4611 < s4596+  s4614 :: SBool = s4612 | s4613+  s4615 :: SWord8 = s4611 >>> 1+  s4616 :: SWord8 = s19 | s4615+  s4617 :: SWord8 = s21 & s4615+  s4618 :: SWord8 = if s4614 then s4616 else s4617+  s4619 :: SWord8 = if s4592 then s4600 else s4618+  s4620 :: SWord8 = s4577 + s4608+  s4621 :: SWord1 = choose [0:0] s4620+  s4622 :: SBool = s14 /= s4621+  s4623 :: SWord8 = if s4622 then s4586 else s4587+  s4624 :: SWord8 = if s17 then s4623 else s4583+  s4625 :: SWord1 = choose [0:0] s4624+  s4626 :: SBool = s14 /= s4625+  s4627 :: SBool = s_2 == s4626+  s4628 :: SBool = s4620 < s4608+  s4629 :: SBool = s4620 < s4577+  s4630 :: SBool = s4628 | s4629+  s4631 :: SWord8 = s4620 >>> 1+  s4632 :: SWord8 = s19 | s4631+  s4633 :: SWord8 = s21 & s4631+  s4634 :: SWord8 = if s4630 then s4632 else s4633+  s4635 :: SWord8 = s4634 >>> 1+  s4636 :: SWord8 = s19 | s4635+  s4637 :: SWord8 = s21 & s4635+  s4638 :: SWord8 = if s4626 then s4636 else s4637+  s4639 :: SWord8 = s4624 >>> 1+  s4640 :: SWord8 = s19 | s4639+  s4641 :: SWord8 = s21 & s4639+  s4642 :: SWord8 = if s4602 then s4640 else s4641+  s4643 :: SWord8 = if s24 then s4623 else s4608+  s4644 :: SWord8 = if s165 then s4642 else s4643+  s4645 :: SWord8 = s4634 + s4644+  s4646 :: SBool = s4645 < s4644+  s4647 :: SBool = s4645 < s4634+  s4648 :: SBool = s4646 | s4647+  s4649 :: SWord8 = s4645 >>> 1+  s4650 :: SWord8 = s19 | s4649+  s4651 :: SWord8 = s21 & s4649+  s4652 :: SWord8 = if s4648 then s4650 else s4651+  s4653 :: SWord8 = if s4627 then s4638 else s4652+  s4654 :: SWord8 = if s4570 then s4619 else s4653+  s4655 :: SWord8 = if s4455 then s4562 else s4654+  s4656 :: SWord8 = if s4224 then s4447 else s4655+  s4657 :: SWord8 = if s3758 then s4216 else s4656+  s4658 :: SWord8 = s3741 + s3860+  s4659 :: SWord1 = choose [0:0] s4658+  s4660 :: SBool = s14 /= s4659+  s4661 :: SWord8 = if s4660 then s3752 else s3753+  s4662 :: SWord8 = if s17 then s4661 else s3749+  s4663 :: SWord1 = choose [0:0] s4662+  s4664 :: SBool = s14 /= s4663+  s4665 :: SBool = s_2 == s4664+  s4666 :: SBool = s4658 < s3860+  s4667 :: SBool = s4658 < s3741+  s4668 :: SBool = s4666 | s4667+  s4669 :: SWord8 = s4658 >>> 1+  s4670 :: SWord8 = s19 | s4669+  s4671 :: SWord8 = s21 & s4669+  s4672 :: SWord8 = if s4668 then s4670 else s4671+  s4673 :: SWord1 = choose [0:0] s4672+  s4674 :: SBool = s14 /= s4673+  s4675 :: SWord8 = s4662 >>> 1+  s4676 :: SWord8 = s19 | s4675+  s4677 :: SWord8 = s21 & s4675+  s4678 :: SWord8 = if s3766 then s4676 else s4677+  s4679 :: SWord8 = if s17 then s4678 else s4661+  s4680 :: SWord8 = s4679 >>> 1+  s4681 :: SWord8 = s19 | s4680+  s4682 :: SWord8 = s21 & s4680+  s4683 :: SWord8 = if s4674 then s4681 else s4682+  s4684 :: SWord8 = if s17 then s4683 else s4678+  s4685 :: SWord1 = choose [0:0] s4684+  s4686 :: SBool = s14 /= s4685+  s4687 :: SBool = s_2 == s4686+  s4688 :: SWord8 = s4672 >>> 1+  s4689 :: SWord8 = s19 | s4688+  s4690 :: SWord8 = s21 & s4688+  s4691 :: SWord8 = if s4664 then s4689 else s4690+  s4692 :: SWord1 = choose [0:0] s4691+  s4693 :: SBool = s14 /= s4692+  s4694 :: SWord1 = choose [0:0] s4679+  s4695 :: SBool = s14 /= s4694+  s4696 :: SWord8 = s4684 >>> 1+  s4697 :: SWord8 = s19 | s4696+  s4698 :: SWord8 = s21 & s4696+  s4699 :: SWord8 = if s4695 then s4697 else s4698+  s4700 :: SWord8 = if s17 then s4699 else s4683+  s4701 :: SWord8 = s4700 >>> 1+  s4702 :: SWord8 = s19 | s4701+  s4703 :: SWord8 = s21 & s4701+  s4704 :: SWord8 = if s4693 then s4702 else s4703+  s4705 :: SWord8 = if s17 then s4704 else s4699+  s4706 :: SWord1 = choose [0:0] s4705+  s4707 :: SBool = s14 /= s4706+  s4708 :: SBool = s_2 == s4707+  s4709 :: SWord8 = s4691 >>> 1+  s4710 :: SWord8 = s19 | s4709+  s4711 :: SWord8 = s21 & s4709+  s4712 :: SWord8 = if s4686 then s4710 else s4711+  s4713 :: SWord1 = choose [0:0] s4712+  s4714 :: SBool = s14 /= s4713+  s4715 :: SWord1 = choose [0:0] s4700+  s4716 :: SBool = s14 /= s4715+  s4717 :: SWord8 = s4705 >>> 1+  s4718 :: SWord8 = s19 | s4717+  s4719 :: SWord8 = s21 & s4717+  s4720 :: SWord8 = if s4716 then s4718 else s4719+  s4721 :: SWord8 = if s17 then s4720 else s4704+  s4722 :: SWord8 = s4721 >>> 1+  s4723 :: SWord8 = s19 | s4722+  s4724 :: SWord8 = s21 & s4722+  s4725 :: SWord8 = if s4714 then s4723 else s4724+  s4726 :: SWord8 = if s17 then s4725 else s4720+  s4727 :: SWord1 = choose [0:0] s4726+  s4728 :: SBool = s14 /= s4727+  s4729 :: SBool = s_2 == s4728+  s4730 :: SWord8 = s4712 >>> 1+  s4731 :: SWord8 = s19 | s4730+  s4732 :: SWord8 = s21 & s4730+  s4733 :: SWord8 = if s4707 then s4731 else s4732+  s4734 :: SWord1 = choose [0:0] s4733+  s4735 :: SBool = s14 /= s4734+  s4736 :: SWord1 = choose [0:0] s4721+  s4737 :: SBool = s14 /= s4736+  s4738 :: SWord8 = s4726 >>> 1+  s4739 :: SWord8 = s19 | s4738+  s4740 :: SWord8 = s21 & s4738+  s4741 :: SWord8 = if s4737 then s4739 else s4740+  s4742 :: SWord8 = if s17 then s4741 else s4725+  s4743 :: SWord8 = s4742 >>> 1+  s4744 :: SWord8 = s19 | s4743+  s4745 :: SWord8 = s21 & s4743+  s4746 :: SWord8 = if s4735 then s4744 else s4745+  s4747 :: SWord8 = if s17 then s4746 else s4741+  s4748 :: SWord1 = choose [0:0] s4747+  s4749 :: SBool = s14 /= s4748+  s4750 :: SBool = s_2 == s4749+  s4751 :: SWord8 = s4733 >>> 1+  s4752 :: SWord8 = s19 | s4751+  s4753 :: SWord8 = s21 & s4751+  s4754 :: SWord8 = if s4728 then s4752 else s4753+  s4755 :: SWord8 = s4754 >>> 1+  s4756 :: SWord8 = s19 | s4755+  s4757 :: SWord8 = s21 & s4755+  s4758 :: SWord8 = if s4749 then s4756 else s4757+  s4759 :: SWord1 = choose [0:0] s4742+  s4760 :: SBool = s14 /= s4759+  s4761 :: SWord8 = s4747 >>> 1+  s4762 :: SWord8 = s19 | s4761+  s4763 :: SWord8 = s21 & s4761+  s4764 :: SWord8 = if s4760 then s4762 else s4763+  s4765 :: SWord8 = if s24 then s4661 else s3860+  s4766 :: SWord8 = if s165 then s4678 else s4765+  s4767 :: SWord8 = if s24 then s4683 else s4766+  s4768 :: SWord8 = if s165 then s4699 else s4767+  s4769 :: SWord8 = if s24 then s4704 else s4768+  s4770 :: SWord8 = if s165 then s4720 else s4769+  s4771 :: SWord8 = if s24 then s4725 else s4770+  s4772 :: SWord8 = if s165 then s4741 else s4771+  s4773 :: SWord8 = if s24 then s4746 else s4772+  s4774 :: SWord8 = if s165 then s4764 else s4773+  s4775 :: SWord8 = s4754 + s4774+  s4776 :: SBool = s4775 < s4774+  s4777 :: SBool = s4775 < s4754+  s4778 :: SBool = s4776 | s4777+  s4779 :: SWord8 = s4775 >>> 1+  s4780 :: SWord8 = s19 | s4779+  s4781 :: SWord8 = s21 & s4779+  s4782 :: SWord8 = if s4778 then s4780 else s4781+  s4783 :: SWord8 = if s4750 then s4758 else s4782+  s4784 :: SWord8 = s4733 + s4772+  s4785 :: SWord1 = choose [0:0] s4784+  s4786 :: SBool = s14 /= s4785+  s4787 :: SWord8 = if s4786 then s4744 else s4745+  s4788 :: SWord8 = if s17 then s4787 else s4741+  s4789 :: SWord1 = choose [0:0] s4788+  s4790 :: SBool = s14 /= s4789+  s4791 :: SBool = s_2 == s4790+  s4792 :: SBool = s4784 < s4772+  s4793 :: SBool = s4784 < s4733+  s4794 :: SBool = s4792 | s4793+  s4795 :: SWord8 = s4784 >>> 1+  s4796 :: SWord8 = s19 | s4795+  s4797 :: SWord8 = s21 & s4795+  s4798 :: SWord8 = if s4794 then s4796 else s4797+  s4799 :: SWord8 = s4798 >>> 1+  s4800 :: SWord8 = s19 | s4799+  s4801 :: SWord8 = s21 & s4799+  s4802 :: SWord8 = if s4790 then s4800 else s4801+  s4803 :: SWord8 = s4788 >>> 1+  s4804 :: SWord8 = s19 | s4803+  s4805 :: SWord8 = s21 & s4803+  s4806 :: SWord8 = if s4760 then s4804 else s4805+  s4807 :: SWord8 = if s24 then s4787 else s4772+  s4808 :: SWord8 = if s165 then s4806 else s4807+  s4809 :: SWord8 = s4798 + s4808+  s4810 :: SBool = s4809 < s4808+  s4811 :: SBool = s4809 < s4798+  s4812 :: SBool = s4810 | s4811+  s4813 :: SWord8 = s4809 >>> 1+  s4814 :: SWord8 = s19 | s4813+  s4815 :: SWord8 = s21 & s4813+  s4816 :: SWord8 = if s4812 then s4814 else s4815+  s4817 :: SWord8 = if s4791 then s4802 else s4816+  s4818 :: SWord8 = if s4729 then s4783 else s4817+  s4819 :: SWord8 = s4712 + s4770+  s4820 :: SWord1 = choose [0:0] s4819+  s4821 :: SBool = s14 /= s4820+  s4822 :: SWord8 = if s4821 then s4723 else s4724+  s4823 :: SWord8 = if s17 then s4822 else s4720+  s4824 :: SWord1 = choose [0:0] s4823+  s4825 :: SBool = s14 /= s4824+  s4826 :: SBool = s_2 == s4825+  s4827 :: SBool = s4819 < s4770+  s4828 :: SBool = s4819 < s4712+  s4829 :: SBool = s4827 | s4828+  s4830 :: SWord8 = s4819 >>> 1+  s4831 :: SWord8 = s19 | s4830+  s4832 :: SWord8 = s21 & s4830+  s4833 :: SWord8 = if s4829 then s4831 else s4832+  s4834 :: SWord1 = choose [0:0] s4833+  s4835 :: SBool = s14 /= s4834+  s4836 :: SWord8 = s4823 >>> 1+  s4837 :: SWord8 = s19 | s4836+  s4838 :: SWord8 = s21 & s4836+  s4839 :: SWord8 = if s4737 then s4837 else s4838+  s4840 :: SWord8 = if s17 then s4839 else s4822+  s4841 :: SWord8 = s4840 >>> 1+  s4842 :: SWord8 = s19 | s4841+  s4843 :: SWord8 = s21 & s4841+  s4844 :: SWord8 = if s4835 then s4842 else s4843+  s4845 :: SWord8 = if s17 then s4844 else s4839+  s4846 :: SWord1 = choose [0:0] s4845+  s4847 :: SBool = s14 /= s4846+  s4848 :: SBool = s_2 == s4847+  s4849 :: SWord8 = s4833 >>> 1+  s4850 :: SWord8 = s19 | s4849+  s4851 :: SWord8 = s21 & s4849+  s4852 :: SWord8 = if s4825 then s4850 else s4851+  s4853 :: SWord8 = s4852 >>> 1+  s4854 :: SWord8 = s19 | s4853+  s4855 :: SWord8 = s21 & s4853+  s4856 :: SWord8 = if s4847 then s4854 else s4855+  s4857 :: SWord1 = choose [0:0] s4840+  s4858 :: SBool = s14 /= s4857+  s4859 :: SWord8 = s4845 >>> 1+  s4860 :: SWord8 = s19 | s4859+  s4861 :: SWord8 = s21 & s4859+  s4862 :: SWord8 = if s4858 then s4860 else s4861+  s4863 :: SWord8 = if s24 then s4822 else s4770+  s4864 :: SWord8 = if s165 then s4839 else s4863+  s4865 :: SWord8 = if s24 then s4844 else s4864+  s4866 :: SWord8 = if s165 then s4862 else s4865+  s4867 :: SWord8 = s4852 + s4866+  s4868 :: SBool = s4867 < s4866+  s4869 :: SBool = s4867 < s4852+  s4870 :: SBool = s4868 | s4869+  s4871 :: SWord8 = s4867 >>> 1+  s4872 :: SWord8 = s19 | s4871+  s4873 :: SWord8 = s21 & s4871+  s4874 :: SWord8 = if s4870 then s4872 else s4873+  s4875 :: SWord8 = if s4848 then s4856 else s4874+  s4876 :: SWord8 = s4833 + s4864+  s4877 :: SWord1 = choose [0:0] s4876+  s4878 :: SBool = s14 /= s4877+  s4879 :: SWord8 = if s4878 then s4842 else s4843+  s4880 :: SWord8 = if s17 then s4879 else s4839+  s4881 :: SWord1 = choose [0:0] s4880+  s4882 :: SBool = s14 /= s4881+  s4883 :: SBool = s_2 == s4882+  s4884 :: SBool = s4876 < s4864+  s4885 :: SBool = s4876 < s4833+  s4886 :: SBool = s4884 | s4885+  s4887 :: SWord8 = s4876 >>> 1+  s4888 :: SWord8 = s19 | s4887+  s4889 :: SWord8 = s21 & s4887+  s4890 :: SWord8 = if s4886 then s4888 else s4889+  s4891 :: SWord8 = s4890 >>> 1+  s4892 :: SWord8 = s19 | s4891+  s4893 :: SWord8 = s21 & s4891+  s4894 :: SWord8 = if s4882 then s4892 else s4893+  s4895 :: SWord8 = s4880 >>> 1+  s4896 :: SWord8 = s19 | s4895+  s4897 :: SWord8 = s21 & s4895+  s4898 :: SWord8 = if s4858 then s4896 else s4897+  s4899 :: SWord8 = if s24 then s4879 else s4864+  s4900 :: SWord8 = if s165 then s4898 else s4899+  s4901 :: SWord8 = s4890 + s4900+  s4902 :: SBool = s4901 < s4900+  s4903 :: SBool = s4901 < s4890+  s4904 :: SBool = s4902 | s4903+  s4905 :: SWord8 = s4901 >>> 1+  s4906 :: SWord8 = s19 | s4905+  s4907 :: SWord8 = s21 & s4905+  s4908 :: SWord8 = if s4904 then s4906 else s4907+  s4909 :: SWord8 = if s4883 then s4894 else s4908+  s4910 :: SWord8 = if s4826 then s4875 else s4909+  s4911 :: SWord8 = if s4708 then s4818 else s4910+  s4912 :: SWord8 = s4691 + s4768+  s4913 :: SWord1 = choose [0:0] s4912+  s4914 :: SBool = s14 /= s4913+  s4915 :: SWord8 = if s4914 then s4702 else s4703+  s4916 :: SWord8 = if s17 then s4915 else s4699+  s4917 :: SWord1 = choose [0:0] s4916+  s4918 :: SBool = s14 /= s4917+  s4919 :: SBool = s_2 == s4918+  s4920 :: SBool = s4912 < s4768+  s4921 :: SBool = s4912 < s4691+  s4922 :: SBool = s4920 | s4921+  s4923 :: SWord8 = s4912 >>> 1+  s4924 :: SWord8 = s19 | s4923+  s4925 :: SWord8 = s21 & s4923+  s4926 :: SWord8 = if s4922 then s4924 else s4925+  s4927 :: SWord1 = choose [0:0] s4926+  s4928 :: SBool = s14 /= s4927+  s4929 :: SWord8 = s4916 >>> 1+  s4930 :: SWord8 = s19 | s4929+  s4931 :: SWord8 = s21 & s4929+  s4932 :: SWord8 = if s4716 then s4930 else s4931+  s4933 :: SWord8 = if s17 then s4932 else s4915+  s4934 :: SWord8 = s4933 >>> 1+  s4935 :: SWord8 = s19 | s4934+  s4936 :: SWord8 = s21 & s4934+  s4937 :: SWord8 = if s4928 then s4935 else s4936+  s4938 :: SWord8 = if s17 then s4937 else s4932+  s4939 :: SWord1 = choose [0:0] s4938+  s4940 :: SBool = s14 /= s4939+  s4941 :: SBool = s_2 == s4940+  s4942 :: SWord8 = s4926 >>> 1+  s4943 :: SWord8 = s19 | s4942+  s4944 :: SWord8 = s21 & s4942+  s4945 :: SWord8 = if s4918 then s4943 else s4944+  s4946 :: SWord1 = choose [0:0] s4945+  s4947 :: SBool = s14 /= s4946+  s4948 :: SWord1 = choose [0:0] s4933+  s4949 :: SBool = s14 /= s4948+  s4950 :: SWord8 = s4938 >>> 1+  s4951 :: SWord8 = s19 | s4950+  s4952 :: SWord8 = s21 & s4950+  s4953 :: SWord8 = if s4949 then s4951 else s4952+  s4954 :: SWord8 = if s17 then s4953 else s4937+  s4955 :: SWord8 = s4954 >>> 1+  s4956 :: SWord8 = s19 | s4955+  s4957 :: SWord8 = s21 & s4955+  s4958 :: SWord8 = if s4947 then s4956 else s4957+  s4959 :: SWord8 = if s17 then s4958 else s4953+  s4960 :: SWord1 = choose [0:0] s4959+  s4961 :: SBool = s14 /= s4960+  s4962 :: SBool = s_2 == s4961+  s4963 :: SWord8 = s4945 >>> 1+  s4964 :: SWord8 = s19 | s4963+  s4965 :: SWord8 = s21 & s4963+  s4966 :: SWord8 = if s4940 then s4964 else s4965+  s4967 :: SWord8 = s4966 >>> 1+  s4968 :: SWord8 = s19 | s4967+  s4969 :: SWord8 = s21 & s4967+  s4970 :: SWord8 = if s4961 then s4968 else s4969+  s4971 :: SWord1 = choose [0:0] s4954+  s4972 :: SBool = s14 /= s4971+  s4973 :: SWord8 = s4959 >>> 1+  s4974 :: SWord8 = s19 | s4973+  s4975 :: SWord8 = s21 & s4973+  s4976 :: SWord8 = if s4972 then s4974 else s4975+  s4977 :: SWord8 = if s24 then s4915 else s4768+  s4978 :: SWord8 = if s165 then s4932 else s4977+  s4979 :: SWord8 = if s24 then s4937 else s4978+  s4980 :: SWord8 = if s165 then s4953 else s4979+  s4981 :: SWord8 = if s24 then s4958 else s4980+  s4982 :: SWord8 = if s165 then s4976 else s4981+  s4983 :: SWord8 = s4966 + s4982+  s4984 :: SBool = s4983 < s4982+  s4985 :: SBool = s4983 < s4966+  s4986 :: SBool = s4984 | s4985+  s4987 :: SWord8 = s4983 >>> 1+  s4988 :: SWord8 = s19 | s4987+  s4989 :: SWord8 = s21 & s4987+  s4990 :: SWord8 = if s4986 then s4988 else s4989+  s4991 :: SWord8 = if s4962 then s4970 else s4990+  s4992 :: SWord8 = s4945 + s4980+  s4993 :: SWord1 = choose [0:0] s4992+  s4994 :: SBool = s14 /= s4993+  s4995 :: SWord8 = if s4994 then s4956 else s4957+  s4996 :: SWord8 = if s17 then s4995 else s4953+  s4997 :: SWord1 = choose [0:0] s4996+  s4998 :: SBool = s14 /= s4997+  s4999 :: SBool = s_2 == s4998+  s5000 :: SBool = s4992 < s4980+  s5001 :: SBool = s4992 < s4945+  s5002 :: SBool = s5000 | s5001+  s5003 :: SWord8 = s4992 >>> 1+  s5004 :: SWord8 = s19 | s5003+  s5005 :: SWord8 = s21 & s5003+  s5006 :: SWord8 = if s5002 then s5004 else s5005+  s5007 :: SWord8 = s5006 >>> 1+  s5008 :: SWord8 = s19 | s5007+  s5009 :: SWord8 = s21 & s5007+  s5010 :: SWord8 = if s4998 then s5008 else s5009+  s5011 :: SWord8 = s4996 >>> 1+  s5012 :: SWord8 = s19 | s5011+  s5013 :: SWord8 = s21 & s5011+  s5014 :: SWord8 = if s4972 then s5012 else s5013+  s5015 :: SWord8 = if s24 then s4995 else s4980+  s5016 :: SWord8 = if s165 then s5014 else s5015+  s5017 :: SWord8 = s5006 + s5016+  s5018 :: SBool = s5017 < s5016+  s5019 :: SBool = s5017 < s5006+  s5020 :: SBool = s5018 | s5019+  s5021 :: SWord8 = s5017 >>> 1+  s5022 :: SWord8 = s19 | s5021+  s5023 :: SWord8 = s21 & s5021+  s5024 :: SWord8 = if s5020 then s5022 else s5023+  s5025 :: SWord8 = if s4999 then s5010 else s5024+  s5026 :: SWord8 = if s4941 then s4991 else s5025+  s5027 :: SWord8 = s4926 + s4978+  s5028 :: SWord1 = choose [0:0] s5027+  s5029 :: SBool = s14 /= s5028+  s5030 :: SWord8 = if s5029 then s4935 else s4936+  s5031 :: SWord8 = if s17 then s5030 else s4932+  s5032 :: SWord1 = choose [0:0] s5031+  s5033 :: SBool = s14 /= s5032+  s5034 :: SBool = s_2 == s5033+  s5035 :: SBool = s5027 < s4978+  s5036 :: SBool = s5027 < s4926+  s5037 :: SBool = s5035 | s5036+  s5038 :: SWord8 = s5027 >>> 1+  s5039 :: SWord8 = s19 | s5038+  s5040 :: SWord8 = s21 & s5038+  s5041 :: SWord8 = if s5037 then s5039 else s5040+  s5042 :: SWord1 = choose [0:0] s5041+  s5043 :: SBool = s14 /= s5042+  s5044 :: SWord8 = s5031 >>> 1+  s5045 :: SWord8 = s19 | s5044+  s5046 :: SWord8 = s21 & s5044+  s5047 :: SWord8 = if s4949 then s5045 else s5046+  s5048 :: SWord8 = if s17 then s5047 else s5030+  s5049 :: SWord8 = s5048 >>> 1+  s5050 :: SWord8 = s19 | s5049+  s5051 :: SWord8 = s21 & s5049+  s5052 :: SWord8 = if s5043 then s5050 else s5051+  s5053 :: SWord8 = if s17 then s5052 else s5047+  s5054 :: SWord1 = choose [0:0] s5053+  s5055 :: SBool = s14 /= s5054+  s5056 :: SBool = s_2 == s5055+  s5057 :: SWord8 = s5041 >>> 1+  s5058 :: SWord8 = s19 | s5057+  s5059 :: SWord8 = s21 & s5057+  s5060 :: SWord8 = if s5033 then s5058 else s5059+  s5061 :: SWord8 = s5060 >>> 1+  s5062 :: SWord8 = s19 | s5061+  s5063 :: SWord8 = s21 & s5061+  s5064 :: SWord8 = if s5055 then s5062 else s5063+  s5065 :: SWord1 = choose [0:0] s5048+  s5066 :: SBool = s14 /= s5065+  s5067 :: SWord8 = s5053 >>> 1+  s5068 :: SWord8 = s19 | s5067+  s5069 :: SWord8 = s21 & s5067+  s5070 :: SWord8 = if s5066 then s5068 else s5069+  s5071 :: SWord8 = if s24 then s5030 else s4978+  s5072 :: SWord8 = if s165 then s5047 else s5071+  s5073 :: SWord8 = if s24 then s5052 else s5072+  s5074 :: SWord8 = if s165 then s5070 else s5073+  s5075 :: SWord8 = s5060 + s5074+  s5076 :: SBool = s5075 < s5074+  s5077 :: SBool = s5075 < s5060+  s5078 :: SBool = s5076 | s5077+  s5079 :: SWord8 = s5075 >>> 1+  s5080 :: SWord8 = s19 | s5079+  s5081 :: SWord8 = s21 & s5079+  s5082 :: SWord8 = if s5078 then s5080 else s5081+  s5083 :: SWord8 = if s5056 then s5064 else s5082+  s5084 :: SWord8 = s5041 + s5072+  s5085 :: SWord1 = choose [0:0] s5084+  s5086 :: SBool = s14 /= s5085+  s5087 :: SWord8 = if s5086 then s5050 else s5051+  s5088 :: SWord8 = if s17 then s5087 else s5047+  s5089 :: SWord1 = choose [0:0] s5088+  s5090 :: SBool = s14 /= s5089+  s5091 :: SBool = s_2 == s5090+  s5092 :: SBool = s5084 < s5072+  s5093 :: SBool = s5084 < s5041+  s5094 :: SBool = s5092 | s5093+  s5095 :: SWord8 = s5084 >>> 1+  s5096 :: SWord8 = s19 | s5095+  s5097 :: SWord8 = s21 & s5095+  s5098 :: SWord8 = if s5094 then s5096 else s5097+  s5099 :: SWord8 = s5098 >>> 1+  s5100 :: SWord8 = s19 | s5099+  s5101 :: SWord8 = s21 & s5099+  s5102 :: SWord8 = if s5090 then s5100 else s5101+  s5103 :: SWord8 = s5088 >>> 1+  s5104 :: SWord8 = s19 | s5103+  s5105 :: SWord8 = s21 & s5103+  s5106 :: SWord8 = if s5066 then s5104 else s5105+  s5107 :: SWord8 = if s24 then s5087 else s5072+  s5108 :: SWord8 = if s165 then s5106 else s5107+  s5109 :: SWord8 = s5098 + s5108+  s5110 :: SBool = s5109 < s5108+  s5111 :: SBool = s5109 < s5098+  s5112 :: SBool = s5110 | s5111+  s5113 :: SWord8 = s5109 >>> 1+  s5114 :: SWord8 = s19 | s5113+  s5115 :: SWord8 = s21 & s5113+  s5116 :: SWord8 = if s5112 then s5114 else s5115+  s5117 :: SWord8 = if s5091 then s5102 else s5116+  s5118 :: SWord8 = if s5034 then s5083 else s5117+  s5119 :: SWord8 = if s4919 then s5026 else s5118+  s5120 :: SWord8 = if s4687 then s4911 else s5119+  s5121 :: SWord8 = s4672 + s4766+  s5122 :: SWord1 = choose [0:0] s5121+  s5123 :: SBool = s14 /= s5122+  s5124 :: SWord8 = if s5123 then s4681 else s4682+  s5125 :: SWord8 = if s17 then s5124 else s4678+  s5126 :: SWord1 = choose [0:0] s5125+  s5127 :: SBool = s14 /= s5126+  s5128 :: SBool = s_2 == s5127+  s5129 :: SBool = s5121 < s4766+  s5130 :: SBool = s5121 < s4672+  s5131 :: SBool = s5129 | s5130+  s5132 :: SWord8 = s5121 >>> 1+  s5133 :: SWord8 = s19 | s5132+  s5134 :: SWord8 = s21 & s5132+  s5135 :: SWord8 = if s5131 then s5133 else s5134+  s5136 :: SWord1 = choose [0:0] s5135+  s5137 :: SBool = s14 /= s5136+  s5138 :: SWord8 = s5125 >>> 1+  s5139 :: SWord8 = s19 | s5138+  s5140 :: SWord8 = s21 & s5138+  s5141 :: SWord8 = if s4695 then s5139 else s5140+  s5142 :: SWord8 = if s17 then s5141 else s5124+  s5143 :: SWord8 = s5142 >>> 1+  s5144 :: SWord8 = s19 | s5143+  s5145 :: SWord8 = s21 & s5143+  s5146 :: SWord8 = if s5137 then s5144 else s5145+  s5147 :: SWord8 = if s17 then s5146 else s5141+  s5148 :: SWord1 = choose [0:0] s5147+  s5149 :: SBool = s14 /= s5148+  s5150 :: SBool = s_2 == s5149+  s5151 :: SWord8 = s5135 >>> 1+  s5152 :: SWord8 = s19 | s5151+  s5153 :: SWord8 = s21 & s5151+  s5154 :: SWord8 = if s5127 then s5152 else s5153+  s5155 :: SWord1 = choose [0:0] s5154+  s5156 :: SBool = s14 /= s5155+  s5157 :: SWord1 = choose [0:0] s5142+  s5158 :: SBool = s14 /= s5157+  s5159 :: SWord8 = s5147 >>> 1+  s5160 :: SWord8 = s19 | s5159+  s5161 :: SWord8 = s21 & s5159+  s5162 :: SWord8 = if s5158 then s5160 else s5161+  s5163 :: SWord8 = if s17 then s5162 else s5146+  s5164 :: SWord8 = s5163 >>> 1+  s5165 :: SWord8 = s19 | s5164+  s5166 :: SWord8 = s21 & s5164+  s5167 :: SWord8 = if s5156 then s5165 else s5166+  s5168 :: SWord8 = if s17 then s5167 else s5162+  s5169 :: SWord1 = choose [0:0] s5168+  s5170 :: SBool = s14 /= s5169+  s5171 :: SBool = s_2 == s5170+  s5172 :: SWord8 = s5154 >>> 1+  s5173 :: SWord8 = s19 | s5172+  s5174 :: SWord8 = s21 & s5172+  s5175 :: SWord8 = if s5149 then s5173 else s5174+  s5176 :: SWord1 = choose [0:0] s5175+  s5177 :: SBool = s14 /= s5176+  s5178 :: SWord1 = choose [0:0] s5163+  s5179 :: SBool = s14 /= s5178+  s5180 :: SWord8 = s5168 >>> 1+  s5181 :: SWord8 = s19 | s5180+  s5182 :: SWord8 = s21 & s5180+  s5183 :: SWord8 = if s5179 then s5181 else s5182+  s5184 :: SWord8 = if s17 then s5183 else s5167+  s5185 :: SWord8 = s5184 >>> 1+  s5186 :: SWord8 = s19 | s5185+  s5187 :: SWord8 = s21 & s5185+  s5188 :: SWord8 = if s5177 then s5186 else s5187+  s5189 :: SWord8 = if s17 then s5188 else s5183+  s5190 :: SWord1 = choose [0:0] s5189+  s5191 :: SBool = s14 /= s5190+  s5192 :: SBool = s_2 == s5191+  s5193 :: SWord8 = s5175 >>> 1+  s5194 :: SWord8 = s19 | s5193+  s5195 :: SWord8 = s21 & s5193+  s5196 :: SWord8 = if s5170 then s5194 else s5195+  s5197 :: SWord8 = s5196 >>> 1+  s5198 :: SWord8 = s19 | s5197+  s5199 :: SWord8 = s21 & s5197+  s5200 :: SWord8 = if s5191 then s5198 else s5199+  s5201 :: SWord1 = choose [0:0] s5184+  s5202 :: SBool = s14 /= s5201+  s5203 :: SWord8 = s5189 >>> 1+  s5204 :: SWord8 = s19 | s5203+  s5205 :: SWord8 = s21 & s5203+  s5206 :: SWord8 = if s5202 then s5204 else s5205+  s5207 :: SWord8 = if s24 then s5124 else s4766+  s5208 :: SWord8 = if s165 then s5141 else s5207+  s5209 :: SWord8 = if s24 then s5146 else s5208+  s5210 :: SWord8 = if s165 then s5162 else s5209+  s5211 :: SWord8 = if s24 then s5167 else s5210+  s5212 :: SWord8 = if s165 then s5183 else s5211+  s5213 :: SWord8 = if s24 then s5188 else s5212+  s5214 :: SWord8 = if s165 then s5206 else s5213+  s5215 :: SWord8 = s5196 + s5214+  s5216 :: SBool = s5215 < s5214+  s5217 :: SBool = s5215 < s5196+  s5218 :: SBool = s5216 | s5217+  s5219 :: SWord8 = s5215 >>> 1+  s5220 :: SWord8 = s19 | s5219+  s5221 :: SWord8 = s21 & s5219+  s5222 :: SWord8 = if s5218 then s5220 else s5221+  s5223 :: SWord8 = if s5192 then s5200 else s5222+  s5224 :: SWord8 = s5175 + s5212+  s5225 :: SWord1 = choose [0:0] s5224+  s5226 :: SBool = s14 /= s5225+  s5227 :: SWord8 = if s5226 then s5186 else s5187+  s5228 :: SWord8 = if s17 then s5227 else s5183+  s5229 :: SWord1 = choose [0:0] s5228+  s5230 :: SBool = s14 /= s5229+  s5231 :: SBool = s_2 == s5230+  s5232 :: SBool = s5224 < s5212+  s5233 :: SBool = s5224 < s5175+  s5234 :: SBool = s5232 | s5233+  s5235 :: SWord8 = s5224 >>> 1+  s5236 :: SWord8 = s19 | s5235+  s5237 :: SWord8 = s21 & s5235+  s5238 :: SWord8 = if s5234 then s5236 else s5237+  s5239 :: SWord8 = s5238 >>> 1+  s5240 :: SWord8 = s19 | s5239+  s5241 :: SWord8 = s21 & s5239+  s5242 :: SWord8 = if s5230 then s5240 else s5241+  s5243 :: SWord8 = s5228 >>> 1+  s5244 :: SWord8 = s19 | s5243+  s5245 :: SWord8 = s21 & s5243+  s5246 :: SWord8 = if s5202 then s5244 else s5245+  s5247 :: SWord8 = if s24 then s5227 else s5212+  s5248 :: SWord8 = if s165 then s5246 else s5247+  s5249 :: SWord8 = s5238 + s5248+  s5250 :: SBool = s5249 < s5248+  s5251 :: SBool = s5249 < s5238+  s5252 :: SBool = s5250 | s5251+  s5253 :: SWord8 = s5249 >>> 1+  s5254 :: SWord8 = s19 | s5253+  s5255 :: SWord8 = s21 & s5253+  s5256 :: SWord8 = if s5252 then s5254 else s5255+  s5257 :: SWord8 = if s5231 then s5242 else s5256+  s5258 :: SWord8 = if s5171 then s5223 else s5257+  s5259 :: SWord8 = s5154 + s5210+  s5260 :: SWord1 = choose [0:0] s5259+  s5261 :: SBool = s14 /= s5260+  s5262 :: SWord8 = if s5261 then s5165 else s5166+  s5263 :: SWord8 = if s17 then s5262 else s5162+  s5264 :: SWord1 = choose [0:0] s5263+  s5265 :: SBool = s14 /= s5264+  s5266 :: SBool = s_2 == s5265+  s5267 :: SBool = s5259 < s5210+  s5268 :: SBool = s5259 < s5154+  s5269 :: SBool = s5267 | s5268+  s5270 :: SWord8 = s5259 >>> 1+  s5271 :: SWord8 = s19 | s5270+  s5272 :: SWord8 = s21 & s5270+  s5273 :: SWord8 = if s5269 then s5271 else s5272+  s5274 :: SWord1 = choose [0:0] s5273+  s5275 :: SBool = s14 /= s5274+  s5276 :: SWord8 = s5263 >>> 1+  s5277 :: SWord8 = s19 | s5276+  s5278 :: SWord8 = s21 & s5276+  s5279 :: SWord8 = if s5179 then s5277 else s5278+  s5280 :: SWord8 = if s17 then s5279 else s5262+  s5281 :: SWord8 = s5280 >>> 1+  s5282 :: SWord8 = s19 | s5281+  s5283 :: SWord8 = s21 & s5281+  s5284 :: SWord8 = if s5275 then s5282 else s5283+  s5285 :: SWord8 = if s17 then s5284 else s5279+  s5286 :: SWord1 = choose [0:0] s5285+  s5287 :: SBool = s14 /= s5286+  s5288 :: SBool = s_2 == s5287+  s5289 :: SWord8 = s5273 >>> 1+  s5290 :: SWord8 = s19 | s5289+  s5291 :: SWord8 = s21 & s5289+  s5292 :: SWord8 = if s5265 then s5290 else s5291+  s5293 :: SWord8 = s5292 >>> 1+  s5294 :: SWord8 = s19 | s5293+  s5295 :: SWord8 = s21 & s5293+  s5296 :: SWord8 = if s5287 then s5294 else s5295+  s5297 :: SWord1 = choose [0:0] s5280+  s5298 :: SBool = s14 /= s5297+  s5299 :: SWord8 = s5285 >>> 1+  s5300 :: SWord8 = s19 | s5299+  s5301 :: SWord8 = s21 & s5299+  s5302 :: SWord8 = if s5298 then s5300 else s5301+  s5303 :: SWord8 = if s24 then s5262 else s5210+  s5304 :: SWord8 = if s165 then s5279 else s5303+  s5305 :: SWord8 = if s24 then s5284 else s5304+  s5306 :: SWord8 = if s165 then s5302 else s5305+  s5307 :: SWord8 = s5292 + s5306+  s5308 :: SBool = s5307 < s5306+  s5309 :: SBool = s5307 < s5292+  s5310 :: SBool = s5308 | s5309+  s5311 :: SWord8 = s5307 >>> 1+  s5312 :: SWord8 = s19 | s5311+  s5313 :: SWord8 = s21 & s5311+  s5314 :: SWord8 = if s5310 then s5312 else s5313+  s5315 :: SWord8 = if s5288 then s5296 else s5314+  s5316 :: SWord8 = s5273 + s5304+  s5317 :: SWord1 = choose [0:0] s5316+  s5318 :: SBool = s14 /= s5317+  s5319 :: SWord8 = if s5318 then s5282 else s5283+  s5320 :: SWord8 = if s17 then s5319 else s5279+  s5321 :: SWord1 = choose [0:0] s5320+  s5322 :: SBool = s14 /= s5321+  s5323 :: SBool = s_2 == s5322+  s5324 :: SBool = s5316 < s5304+  s5325 :: SBool = s5316 < s5273+  s5326 :: SBool = s5324 | s5325+  s5327 :: SWord8 = s5316 >>> 1+  s5328 :: SWord8 = s19 | s5327+  s5329 :: SWord8 = s21 & s5327+  s5330 :: SWord8 = if s5326 then s5328 else s5329+  s5331 :: SWord8 = s5330 >>> 1+  s5332 :: SWord8 = s19 | s5331+  s5333 :: SWord8 = s21 & s5331+  s5334 :: SWord8 = if s5322 then s5332 else s5333+  s5335 :: SWord8 = s5320 >>> 1+  s5336 :: SWord8 = s19 | s5335+  s5337 :: SWord8 = s21 & s5335+  s5338 :: SWord8 = if s5298 then s5336 else s5337+  s5339 :: SWord8 = if s24 then s5319 else s5304+  s5340 :: SWord8 = if s165 then s5338 else s5339+  s5341 :: SWord8 = s5330 + s5340+  s5342 :: SBool = s5341 < s5340+  s5343 :: SBool = s5341 < s5330+  s5344 :: SBool = s5342 | s5343+  s5345 :: SWord8 = s5341 >>> 1+  s5346 :: SWord8 = s19 | s5345+  s5347 :: SWord8 = s21 & s5345+  s5348 :: SWord8 = if s5344 then s5346 else s5347+  s5349 :: SWord8 = if s5323 then s5334 else s5348+  s5350 :: SWord8 = if s5266 then s5315 else s5349+  s5351 :: SWord8 = if s5150 then s5258 else s5350+  s5352 :: SWord8 = s5135 + s5208+  s5353 :: SWord1 = choose [0:0] s5352+  s5354 :: SBool = s14 /= s5353+  s5355 :: SWord8 = if s5354 then s5144 else s5145+  s5356 :: SWord8 = if s17 then s5355 else s5141+  s5357 :: SWord1 = choose [0:0] s5356+  s5358 :: SBool = s14 /= s5357+  s5359 :: SBool = s_2 == s5358+  s5360 :: SBool = s5352 < s5208+  s5361 :: SBool = s5352 < s5135+  s5362 :: SBool = s5360 | s5361+  s5363 :: SWord8 = s5352 >>> 1+  s5364 :: SWord8 = s19 | s5363+  s5365 :: SWord8 = s21 & s5363+  s5366 :: SWord8 = if s5362 then s5364 else s5365+  s5367 :: SWord1 = choose [0:0] s5366+  s5368 :: SBool = s14 /= s5367+  s5369 :: SWord8 = s5356 >>> 1+  s5370 :: SWord8 = s19 | s5369+  s5371 :: SWord8 = s21 & s5369+  s5372 :: SWord8 = if s5158 then s5370 else s5371+  s5373 :: SWord8 = if s17 then s5372 else s5355+  s5374 :: SWord8 = s5373 >>> 1+  s5375 :: SWord8 = s19 | s5374+  s5376 :: SWord8 = s21 & s5374+  s5377 :: SWord8 = if s5368 then s5375 else s5376+  s5378 :: SWord8 = if s17 then s5377 else s5372+  s5379 :: SWord1 = choose [0:0] s5378+  s5380 :: SBool = s14 /= s5379+  s5381 :: SBool = s_2 == s5380+  s5382 :: SWord8 = s5366 >>> 1+  s5383 :: SWord8 = s19 | s5382+  s5384 :: SWord8 = s21 & s5382+  s5385 :: SWord8 = if s5358 then s5383 else s5384+  s5386 :: SWord1 = choose [0:0] s5385+  s5387 :: SBool = s14 /= s5386+  s5388 :: SWord1 = choose [0:0] s5373+  s5389 :: SBool = s14 /= s5388+  s5390 :: SWord8 = s5378 >>> 1+  s5391 :: SWord8 = s19 | s5390+  s5392 :: SWord8 = s21 & s5390+  s5393 :: SWord8 = if s5389 then s5391 else s5392+  s5394 :: SWord8 = if s17 then s5393 else s5377+  s5395 :: SWord8 = s5394 >>> 1+  s5396 :: SWord8 = s19 | s5395+  s5397 :: SWord8 = s21 & s5395+  s5398 :: SWord8 = if s5387 then s5396 else s5397+  s5399 :: SWord8 = if s17 then s5398 else s5393+  s5400 :: SWord1 = choose [0:0] s5399+  s5401 :: SBool = s14 /= s5400+  s5402 :: SBool = s_2 == s5401+  s5403 :: SWord8 = s5385 >>> 1+  s5404 :: SWord8 = s19 | s5403+  s5405 :: SWord8 = s21 & s5403+  s5406 :: SWord8 = if s5380 then s5404 else s5405+  s5407 :: SWord8 = s5406 >>> 1+  s5408 :: SWord8 = s19 | s5407+  s5409 :: SWord8 = s21 & s5407+  s5410 :: SWord8 = if s5401 then s5408 else s5409+  s5411 :: SWord1 = choose [0:0] s5394+  s5412 :: SBool = s14 /= s5411+  s5413 :: SWord8 = s5399 >>> 1+  s5414 :: SWord8 = s19 | s5413+  s5415 :: SWord8 = s21 & s5413+  s5416 :: SWord8 = if s5412 then s5414 else s5415+  s5417 :: SWord8 = if s24 then s5355 else s5208+  s5418 :: SWord8 = if s165 then s5372 else s5417+  s5419 :: SWord8 = if s24 then s5377 else s5418+  s5420 :: SWord8 = if s165 then s5393 else s5419+  s5421 :: SWord8 = if s24 then s5398 else s5420+  s5422 :: SWord8 = if s165 then s5416 else s5421+  s5423 :: SWord8 = s5406 + s5422+  s5424 :: SBool = s5423 < s5422+  s5425 :: SBool = s5423 < s5406+  s5426 :: SBool = s5424 | s5425+  s5427 :: SWord8 = s5423 >>> 1+  s5428 :: SWord8 = s19 | s5427+  s5429 :: SWord8 = s21 & s5427+  s5430 :: SWord8 = if s5426 then s5428 else s5429+  s5431 :: SWord8 = if s5402 then s5410 else s5430+  s5432 :: SWord8 = s5385 + s5420+  s5433 :: SWord1 = choose [0:0] s5432+  s5434 :: SBool = s14 /= s5433+  s5435 :: SWord8 = if s5434 then s5396 else s5397+  s5436 :: SWord8 = if s17 then s5435 else s5393+  s5437 :: SWord1 = choose [0:0] s5436+  s5438 :: SBool = s14 /= s5437+  s5439 :: SBool = s_2 == s5438+  s5440 :: SBool = s5432 < s5420+  s5441 :: SBool = s5432 < s5385+  s5442 :: SBool = s5440 | s5441+  s5443 :: SWord8 = s5432 >>> 1+  s5444 :: SWord8 = s19 | s5443+  s5445 :: SWord8 = s21 & s5443+  s5446 :: SWord8 = if s5442 then s5444 else s5445+  s5447 :: SWord8 = s5446 >>> 1+  s5448 :: SWord8 = s19 | s5447+  s5449 :: SWord8 = s21 & s5447+  s5450 :: SWord8 = if s5438 then s5448 else s5449+  s5451 :: SWord8 = s5436 >>> 1+  s5452 :: SWord8 = s19 | s5451+  s5453 :: SWord8 = s21 & s5451+  s5454 :: SWord8 = if s5412 then s5452 else s5453+  s5455 :: SWord8 = if s24 then s5435 else s5420+  s5456 :: SWord8 = if s165 then s5454 else s5455+  s5457 :: SWord8 = s5446 + s5456+  s5458 :: SBool = s5457 < s5456+  s5459 :: SBool = s5457 < s5446+  s5460 :: SBool = s5458 | s5459+  s5461 :: SWord8 = s5457 >>> 1+  s5462 :: SWord8 = s19 | s5461+  s5463 :: SWord8 = s21 & s5461+  s5464 :: SWord8 = if s5460 then s5462 else s5463+  s5465 :: SWord8 = if s5439 then s5450 else s5464+  s5466 :: SWord8 = if s5381 then s5431 else s5465+  s5467 :: SWord8 = s5366 + s5418+  s5468 :: SWord1 = choose [0:0] s5467+  s5469 :: SBool = s14 /= s5468+  s5470 :: SWord8 = if s5469 then s5375 else s5376+  s5471 :: SWord8 = if s17 then s5470 else s5372+  s5472 :: SWord1 = choose [0:0] s5471+  s5473 :: SBool = s14 /= s5472+  s5474 :: SBool = s_2 == s5473+  s5475 :: SBool = s5467 < s5418+  s5476 :: SBool = s5467 < s5366+  s5477 :: SBool = s5475 | s5476+  s5478 :: SWord8 = s5467 >>> 1+  s5479 :: SWord8 = s19 | s5478+  s5480 :: SWord8 = s21 & s5478+  s5481 :: SWord8 = if s5477 then s5479 else s5480+  s5482 :: SWord1 = choose [0:0] s5481+  s5483 :: SBool = s14 /= s5482+  s5484 :: SWord8 = s5471 >>> 1+  s5485 :: SWord8 = s19 | s5484+  s5486 :: SWord8 = s21 & s5484+  s5487 :: SWord8 = if s5389 then s5485 else s5486+  s5488 :: SWord8 = if s17 then s5487 else s5470+  s5489 :: SWord8 = s5488 >>> 1+  s5490 :: SWord8 = s19 | s5489+  s5491 :: SWord8 = s21 & s5489+  s5492 :: SWord8 = if s5483 then s5490 else s5491+  s5493 :: SWord8 = if s17 then s5492 else s5487+  s5494 :: SWord1 = choose [0:0] s5493+  s5495 :: SBool = s14 /= s5494+  s5496 :: SBool = s_2 == s5495+  s5497 :: SWord8 = s5481 >>> 1+  s5498 :: SWord8 = s19 | s5497+  s5499 :: SWord8 = s21 & s5497+  s5500 :: SWord8 = if s5473 then s5498 else s5499+  s5501 :: SWord8 = s5500 >>> 1+  s5502 :: SWord8 = s19 | s5501+  s5503 :: SWord8 = s21 & s5501+  s5504 :: SWord8 = if s5495 then s5502 else s5503+  s5505 :: SWord1 = choose [0:0] s5488+  s5506 :: SBool = s14 /= s5505+  s5507 :: SWord8 = s5493 >>> 1+  s5508 :: SWord8 = s19 | s5507+  s5509 :: SWord8 = s21 & s5507+  s5510 :: SWord8 = if s5506 then s5508 else s5509+  s5511 :: SWord8 = if s24 then s5470 else s5418+  s5512 :: SWord8 = if s165 then s5487 else s5511+  s5513 :: SWord8 = if s24 then s5492 else s5512+  s5514 :: SWord8 = if s165 then s5510 else s5513+  s5515 :: SWord8 = s5500 + s5514+  s5516 :: SBool = s5515 < s5514+  s5517 :: SBool = s5515 < s5500+  s5518 :: SBool = s5516 | s5517+  s5519 :: SWord8 = s5515 >>> 1+  s5520 :: SWord8 = s19 | s5519+  s5521 :: SWord8 = s21 & s5519+  s5522 :: SWord8 = if s5518 then s5520 else s5521+  s5523 :: SWord8 = if s5496 then s5504 else s5522+  s5524 :: SWord8 = s5481 + s5512+  s5525 :: SWord1 = choose [0:0] s5524+  s5526 :: SBool = s14 /= s5525+  s5527 :: SWord8 = if s5526 then s5490 else s5491+  s5528 :: SWord8 = if s17 then s5527 else s5487+  s5529 :: SWord1 = choose [0:0] s5528+  s5530 :: SBool = s14 /= s5529+  s5531 :: SBool = s_2 == s5530+  s5532 :: SBool = s5524 < s5512+  s5533 :: SBool = s5524 < s5481+  s5534 :: SBool = s5532 | s5533+  s5535 :: SWord8 = s5524 >>> 1+  s5536 :: SWord8 = s19 | s5535+  s5537 :: SWord8 = s21 & s5535+  s5538 :: SWord8 = if s5534 then s5536 else s5537+  s5539 :: SWord8 = s5538 >>> 1+  s5540 :: SWord8 = s19 | s5539+  s5541 :: SWord8 = s21 & s5539+  s5542 :: SWord8 = if s5530 then s5540 else s5541+  s5543 :: SWord8 = s5528 >>> 1+  s5544 :: SWord8 = s19 | s5543+  s5545 :: SWord8 = s21 & s5543+  s5546 :: SWord8 = if s5506 then s5544 else s5545+  s5547 :: SWord8 = if s24 then s5527 else s5512+  s5548 :: SWord8 = if s165 then s5546 else s5547+  s5549 :: SWord8 = s5538 + s5548+  s5550 :: SBool = s5549 < s5548+  s5551 :: SBool = s5549 < s5538+  s5552 :: SBool = s5550 | s5551+  s5553 :: SWord8 = s5549 >>> 1+  s5554 :: SWord8 = s19 | s5553+  s5555 :: SWord8 = s21 & s5553+  s5556 :: SWord8 = if s5552 then s5554 else s5555+  s5557 :: SWord8 = if s5531 then s5542 else s5556+  s5558 :: SWord8 = if s5474 then s5523 else s5557+  s5559 :: SWord8 = if s5359 then s5466 else s5558+  s5560 :: SWord8 = if s5128 then s5351 else s5559+  s5561 :: SWord8 = if s4665 then s5120 else s5560+  s5562 :: SWord8 = if s3737 then s4657 else s5561+  s5563 :: SWord8 = s3722 + s3858+  s5564 :: SWord1 = choose [0:0] s5563+  s5565 :: SBool = s14 /= s5564+  s5566 :: SWord8 = if s5565 then s3731 else s3732+  s5567 :: SWord8 = if s17 then s5566 else s3728+  s5568 :: SWord1 = choose [0:0] s5567+  s5569 :: SBool = s14 /= s5568+  s5570 :: SBool = s_2 == s5569+  s5571 :: SBool = s5563 < s3858+  s5572 :: SBool = s5563 < s3722+  s5573 :: SBool = s5571 | s5572+  s5574 :: SWord8 = s5563 >>> 1+  s5575 :: SWord8 = s19 | s5574+  s5576 :: SWord8 = s21 & s5574+  s5577 :: SWord8 = if s5573 then s5575 else s5576+  s5578 :: SWord1 = choose [0:0] s5577+  s5579 :: SBool = s14 /= s5578+  s5580 :: SWord8 = s5567 >>> 1+  s5581 :: SWord8 = s19 | s5580+  s5582 :: SWord8 = s21 & s5580+  s5583 :: SWord8 = if s3745 then s5581 else s5582+  s5584 :: SWord8 = if s17 then s5583 else s5566+  s5585 :: SWord8 = s5584 >>> 1+  s5586 :: SWord8 = s19 | s5585+  s5587 :: SWord8 = s21 & s5585+  s5588 :: SWord8 = if s5579 then s5586 else s5587+  s5589 :: SWord8 = if s17 then s5588 else s5583+  s5590 :: SWord1 = choose [0:0] s5589+  s5591 :: SBool = s14 /= s5590+  s5592 :: SBool = s_2 == s5591+  s5593 :: SWord8 = s5577 >>> 1+  s5594 :: SWord8 = s19 | s5593+  s5595 :: SWord8 = s21 & s5593+  s5596 :: SWord8 = if s5569 then s5594 else s5595+  s5597 :: SWord1 = choose [0:0] s5596+  s5598 :: SBool = s14 /= s5597+  s5599 :: SWord1 = choose [0:0] s5584+  s5600 :: SBool = s14 /= s5599+  s5601 :: SWord8 = s5589 >>> 1+  s5602 :: SWord8 = s19 | s5601+  s5603 :: SWord8 = s21 & s5601+  s5604 :: SWord8 = if s5600 then s5602 else s5603+  s5605 :: SWord8 = if s17 then s5604 else s5588+  s5606 :: SWord8 = s5605 >>> 1+  s5607 :: SWord8 = s19 | s5606+  s5608 :: SWord8 = s21 & s5606+  s5609 :: SWord8 = if s5598 then s5607 else s5608+  s5610 :: SWord8 = if s17 then s5609 else s5604+  s5611 :: SWord1 = choose [0:0] s5610+  s5612 :: SBool = s14 /= s5611+  s5613 :: SBool = s_2 == s5612+  s5614 :: SWord8 = s5596 >>> 1+  s5615 :: SWord8 = s19 | s5614+  s5616 :: SWord8 = s21 & s5614+  s5617 :: SWord8 = if s5591 then s5615 else s5616+  s5618 :: SWord1 = choose [0:0] s5617+  s5619 :: SBool = s14 /= s5618+  s5620 :: SWord1 = choose [0:0] s5605+  s5621 :: SBool = s14 /= s5620+  s5622 :: SWord8 = s5610 >>> 1+  s5623 :: SWord8 = s19 | s5622+  s5624 :: SWord8 = s21 & s5622+  s5625 :: SWord8 = if s5621 then s5623 else s5624+  s5626 :: SWord8 = if s17 then s5625 else s5609+  s5627 :: SWord8 = s5626 >>> 1+  s5628 :: SWord8 = s19 | s5627+  s5629 :: SWord8 = s21 & s5627+  s5630 :: SWord8 = if s5619 then s5628 else s5629+  s5631 :: SWord8 = if s17 then s5630 else s5625+  s5632 :: SWord1 = choose [0:0] s5631+  s5633 :: SBool = s14 /= s5632+  s5634 :: SBool = s_2 == s5633+  s5635 :: SWord8 = s5617 >>> 1+  s5636 :: SWord8 = s19 | s5635+  s5637 :: SWord8 = s21 & s5635+  s5638 :: SWord8 = if s5612 then s5636 else s5637+  s5639 :: SWord1 = choose [0:0] s5638+  s5640 :: SBool = s14 /= s5639+  s5641 :: SWord1 = choose [0:0] s5626+  s5642 :: SBool = s14 /= s5641+  s5643 :: SWord8 = s5631 >>> 1+  s5644 :: SWord8 = s19 | s5643+  s5645 :: SWord8 = s21 & s5643+  s5646 :: SWord8 = if s5642 then s5644 else s5645+  s5647 :: SWord8 = if s17 then s5646 else s5630+  s5648 :: SWord8 = s5647 >>> 1+  s5649 :: SWord8 = s19 | s5648+  s5650 :: SWord8 = s21 & s5648+  s5651 :: SWord8 = if s5640 then s5649 else s5650+  s5652 :: SWord8 = if s17 then s5651 else s5646+  s5653 :: SWord1 = choose [0:0] s5652+  s5654 :: SBool = s14 /= s5653+  s5655 :: SBool = s_2 == s5654+  s5656 :: SWord8 = s5638 >>> 1+  s5657 :: SWord8 = s19 | s5656+  s5658 :: SWord8 = s21 & s5656+  s5659 :: SWord8 = if s5633 then s5657 else s5658+  s5660 :: SWord1 = choose [0:0] s5659+  s5661 :: SBool = s14 /= s5660+  s5662 :: SWord1 = choose [0:0] s5647+  s5663 :: SBool = s14 /= s5662+  s5664 :: SWord8 = s5652 >>> 1+  s5665 :: SWord8 = s19 | s5664+  s5666 :: SWord8 = s21 & s5664+  s5667 :: SWord8 = if s5663 then s5665 else s5666+  s5668 :: SWord8 = if s17 then s5667 else s5651+  s5669 :: SWord8 = s5668 >>> 1+  s5670 :: SWord8 = s19 | s5669+  s5671 :: SWord8 = s21 & s5669+  s5672 :: SWord8 = if s5661 then s5670 else s5671+  s5673 :: SWord8 = if s17 then s5672 else s5667+  s5674 :: SWord1 = choose [0:0] s5673+  s5675 :: SBool = s14 /= s5674+  s5676 :: SBool = s_2 == s5675+  s5677 :: SWord8 = s5659 >>> 1+  s5678 :: SWord8 = s19 | s5677+  s5679 :: SWord8 = s21 & s5677+  s5680 :: SWord8 = if s5654 then s5678 else s5679+  s5681 :: SWord8 = s5680 >>> 1+  s5682 :: SWord8 = s19 | s5681+  s5683 :: SWord8 = s21 & s5681+  s5684 :: SWord8 = if s5675 then s5682 else s5683+  s5685 :: SWord1 = choose [0:0] s5668+  s5686 :: SBool = s14 /= s5685+  s5687 :: SWord8 = s5673 >>> 1+  s5688 :: SWord8 = s19 | s5687+  s5689 :: SWord8 = s21 & s5687+  s5690 :: SWord8 = if s5686 then s5688 else s5689+  s5691 :: SWord8 = if s24 then s5566 else s3858+  s5692 :: SWord8 = if s165 then s5583 else s5691+  s5693 :: SWord8 = if s24 then s5588 else s5692+  s5694 :: SWord8 = if s165 then s5604 else s5693+  s5695 :: SWord8 = if s24 then s5609 else s5694+  s5696 :: SWord8 = if s165 then s5625 else s5695+  s5697 :: SWord8 = if s24 then s5630 else s5696+  s5698 :: SWord8 = if s165 then s5646 else s5697+  s5699 :: SWord8 = if s24 then s5651 else s5698+  s5700 :: SWord8 = if s165 then s5667 else s5699+  s5701 :: SWord8 = if s24 then s5672 else s5700+  s5702 :: SWord8 = if s165 then s5690 else s5701+  s5703 :: SWord8 = s5680 + s5702+  s5704 :: SBool = s5703 < s5702+  s5705 :: SBool = s5703 < s5680+  s5706 :: SBool = s5704 | s5705+  s5707 :: SWord8 = s5703 >>> 1+  s5708 :: SWord8 = s19 | s5707+  s5709 :: SWord8 = s21 & s5707+  s5710 :: SWord8 = if s5706 then s5708 else s5709+  s5711 :: SWord8 = if s5676 then s5684 else s5710+  s5712 :: SWord8 = s5659 + s5700+  s5713 :: SWord1 = choose [0:0] s5712+  s5714 :: SBool = s14 /= s5713+  s5715 :: SWord8 = if s5714 then s5670 else s5671+  s5716 :: SWord8 = if s17 then s5715 else s5667+  s5717 :: SWord1 = choose [0:0] s5716+  s5718 :: SBool = s14 /= s5717+  s5719 :: SBool = s_2 == s5718+  s5720 :: SBool = s5712 < s5700+  s5721 :: SBool = s5712 < s5659+  s5722 :: SBool = s5720 | s5721+  s5723 :: SWord8 = s5712 >>> 1+  s5724 :: SWord8 = s19 | s5723+  s5725 :: SWord8 = s21 & s5723+  s5726 :: SWord8 = if s5722 then s5724 else s5725+  s5727 :: SWord8 = s5726 >>> 1+  s5728 :: SWord8 = s19 | s5727+  s5729 :: SWord8 = s21 & s5727+  s5730 :: SWord8 = if s5718 then s5728 else s5729+  s5731 :: SWord8 = s5716 >>> 1+  s5732 :: SWord8 = s19 | s5731+  s5733 :: SWord8 = s21 & s5731+  s5734 :: SWord8 = if s5686 then s5732 else s5733+  s5735 :: SWord8 = if s24 then s5715 else s5700+  s5736 :: SWord8 = if s165 then s5734 else s5735+  s5737 :: SWord8 = s5726 + s5736+  s5738 :: SBool = s5737 < s5736+  s5739 :: SBool = s5737 < s5726+  s5740 :: SBool = s5738 | s5739+  s5741 :: SWord8 = s5737 >>> 1+  s5742 :: SWord8 = s19 | s5741+  s5743 :: SWord8 = s21 & s5741+  s5744 :: SWord8 = if s5740 then s5742 else s5743+  s5745 :: SWord8 = if s5719 then s5730 else s5744+  s5746 :: SWord8 = if s5655 then s5711 else s5745+  s5747 :: SWord8 = s5638 + s5698+  s5748 :: SWord1 = choose [0:0] s5747+  s5749 :: SBool = s14 /= s5748+  s5750 :: SWord8 = if s5749 then s5649 else s5650+  s5751 :: SWord8 = if s17 then s5750 else s5646+  s5752 :: SWord1 = choose [0:0] s5751+  s5753 :: SBool = s14 /= s5752+  s5754 :: SBool = s_2 == s5753+  s5755 :: SBool = s5747 < s5698+  s5756 :: SBool = s5747 < s5638+  s5757 :: SBool = s5755 | s5756+  s5758 :: SWord8 = s5747 >>> 1+  s5759 :: SWord8 = s19 | s5758+  s5760 :: SWord8 = s21 & s5758+  s5761 :: SWord8 = if s5757 then s5759 else s5760+  s5762 :: SWord1 = choose [0:0] s5761+  s5763 :: SBool = s14 /= s5762+  s5764 :: SWord8 = s5751 >>> 1+  s5765 :: SWord8 = s19 | s5764+  s5766 :: SWord8 = s21 & s5764+  s5767 :: SWord8 = if s5663 then s5765 else s5766+  s5768 :: SWord8 = if s17 then s5767 else s5750+  s5769 :: SWord8 = s5768 >>> 1+  s5770 :: SWord8 = s19 | s5769+  s5771 :: SWord8 = s21 & s5769+  s5772 :: SWord8 = if s5763 then s5770 else s5771+  s5773 :: SWord8 = if s17 then s5772 else s5767+  s5774 :: SWord1 = choose [0:0] s5773+  s5775 :: SBool = s14 /= s5774+  s5776 :: SBool = s_2 == s5775+  s5777 :: SWord8 = s5761 >>> 1+  s5778 :: SWord8 = s19 | s5777+  s5779 :: SWord8 = s21 & s5777+  s5780 :: SWord8 = if s5753 then s5778 else s5779+  s5781 :: SWord8 = s5780 >>> 1+  s5782 :: SWord8 = s19 | s5781+  s5783 :: SWord8 = s21 & s5781+  s5784 :: SWord8 = if s5775 then s5782 else s5783+  s5785 :: SWord1 = choose [0:0] s5768+  s5786 :: SBool = s14 /= s5785+  s5787 :: SWord8 = s5773 >>> 1+  s5788 :: SWord8 = s19 | s5787+  s5789 :: SWord8 = s21 & s5787+  s5790 :: SWord8 = if s5786 then s5788 else s5789+  s5791 :: SWord8 = if s24 then s5750 else s5698+  s5792 :: SWord8 = if s165 then s5767 else s5791+  s5793 :: SWord8 = if s24 then s5772 else s5792+  s5794 :: SWord8 = if s165 then s5790 else s5793+  s5795 :: SWord8 = s5780 + s5794+  s5796 :: SBool = s5795 < s5794+  s5797 :: SBool = s5795 < s5780+  s5798 :: SBool = s5796 | s5797+  s5799 :: SWord8 = s5795 >>> 1+  s5800 :: SWord8 = s19 | s5799+  s5801 :: SWord8 = s21 & s5799+  s5802 :: SWord8 = if s5798 then s5800 else s5801+  s5803 :: SWord8 = if s5776 then s5784 else s5802+  s5804 :: SWord8 = s5761 + s5792+  s5805 :: SWord1 = choose [0:0] s5804+  s5806 :: SBool = s14 /= s5805+  s5807 :: SWord8 = if s5806 then s5770 else s5771+  s5808 :: SWord8 = if s17 then s5807 else s5767+  s5809 :: SWord1 = choose [0:0] s5808+  s5810 :: SBool = s14 /= s5809+  s5811 :: SBool = s_2 == s5810+  s5812 :: SBool = s5804 < s5792+  s5813 :: SBool = s5804 < s5761+  s5814 :: SBool = s5812 | s5813+  s5815 :: SWord8 = s5804 >>> 1+  s5816 :: SWord8 = s19 | s5815+  s5817 :: SWord8 = s21 & s5815+  s5818 :: SWord8 = if s5814 then s5816 else s5817+  s5819 :: SWord8 = s5818 >>> 1+  s5820 :: SWord8 = s19 | s5819+  s5821 :: SWord8 = s21 & s5819+  s5822 :: SWord8 = if s5810 then s5820 else s5821+  s5823 :: SWord8 = s5808 >>> 1+  s5824 :: SWord8 = s19 | s5823+  s5825 :: SWord8 = s21 & s5823+  s5826 :: SWord8 = if s5786 then s5824 else s5825+  s5827 :: SWord8 = if s24 then s5807 else s5792+  s5828 :: SWord8 = if s165 then s5826 else s5827+  s5829 :: SWord8 = s5818 + s5828+  s5830 :: SBool = s5829 < s5828+  s5831 :: SBool = s5829 < s5818+  s5832 :: SBool = s5830 | s5831+  s5833 :: SWord8 = s5829 >>> 1+  s5834 :: SWord8 = s19 | s5833+  s5835 :: SWord8 = s21 & s5833+  s5836 :: SWord8 = if s5832 then s5834 else s5835+  s5837 :: SWord8 = if s5811 then s5822 else s5836+  s5838 :: SWord8 = if s5754 then s5803 else s5837+  s5839 :: SWord8 = if s5634 then s5746 else s5838+  s5840 :: SWord8 = s5617 + s5696+  s5841 :: SWord1 = choose [0:0] s5840+  s5842 :: SBool = s14 /= s5841+  s5843 :: SWord8 = if s5842 then s5628 else s5629+  s5844 :: SWord8 = if s17 then s5843 else s5625+  s5845 :: SWord1 = choose [0:0] s5844+  s5846 :: SBool = s14 /= s5845+  s5847 :: SBool = s_2 == s5846+  s5848 :: SBool = s5840 < s5696+  s5849 :: SBool = s5840 < s5617+  s5850 :: SBool = s5848 | s5849+  s5851 :: SWord8 = s5840 >>> 1+  s5852 :: SWord8 = s19 | s5851+  s5853 :: SWord8 = s21 & s5851+  s5854 :: SWord8 = if s5850 then s5852 else s5853+  s5855 :: SWord1 = choose [0:0] s5854+  s5856 :: SBool = s14 /= s5855+  s5857 :: SWord8 = s5844 >>> 1+  s5858 :: SWord8 = s19 | s5857+  s5859 :: SWord8 = s21 & s5857+  s5860 :: SWord8 = if s5642 then s5858 else s5859+  s5861 :: SWord8 = if s17 then s5860 else s5843+  s5862 :: SWord8 = s5861 >>> 1+  s5863 :: SWord8 = s19 | s5862+  s5864 :: SWord8 = s21 & s5862+  s5865 :: SWord8 = if s5856 then s5863 else s5864+  s5866 :: SWord8 = if s17 then s5865 else s5860+  s5867 :: SWord1 = choose [0:0] s5866+  s5868 :: SBool = s14 /= s5867+  s5869 :: SBool = s_2 == s5868+  s5870 :: SWord8 = s5854 >>> 1+  s5871 :: SWord8 = s19 | s5870+  s5872 :: SWord8 = s21 & s5870+  s5873 :: SWord8 = if s5846 then s5871 else s5872+  s5874 :: SWord1 = choose [0:0] s5873+  s5875 :: SBool = s14 /= s5874+  s5876 :: SWord1 = choose [0:0] s5861+  s5877 :: SBool = s14 /= s5876+  s5878 :: SWord8 = s5866 >>> 1+  s5879 :: SWord8 = s19 | s5878+  s5880 :: SWord8 = s21 & s5878+  s5881 :: SWord8 = if s5877 then s5879 else s5880+  s5882 :: SWord8 = if s17 then s5881 else s5865+  s5883 :: SWord8 = s5882 >>> 1+  s5884 :: SWord8 = s19 | s5883+  s5885 :: SWord8 = s21 & s5883+  s5886 :: SWord8 = if s5875 then s5884 else s5885+  s5887 :: SWord8 = if s17 then s5886 else s5881+  s5888 :: SWord1 = choose [0:0] s5887+  s5889 :: SBool = s14 /= s5888+  s5890 :: SBool = s_2 == s5889+  s5891 :: SWord8 = s5873 >>> 1+  s5892 :: SWord8 = s19 | s5891+  s5893 :: SWord8 = s21 & s5891+  s5894 :: SWord8 = if s5868 then s5892 else s5893+  s5895 :: SWord8 = s5894 >>> 1+  s5896 :: SWord8 = s19 | s5895+  s5897 :: SWord8 = s21 & s5895+  s5898 :: SWord8 = if s5889 then s5896 else s5897+  s5899 :: SWord1 = choose [0:0] s5882+  s5900 :: SBool = s14 /= s5899+  s5901 :: SWord8 = s5887 >>> 1+  s5902 :: SWord8 = s19 | s5901+  s5903 :: SWord8 = s21 & s5901+  s5904 :: SWord8 = if s5900 then s5902 else s5903+  s5905 :: SWord8 = if s24 then s5843 else s5696+  s5906 :: SWord8 = if s165 then s5860 else s5905+  s5907 :: SWord8 = if s24 then s5865 else s5906+  s5908 :: SWord8 = if s165 then s5881 else s5907+  s5909 :: SWord8 = if s24 then s5886 else s5908+  s5910 :: SWord8 = if s165 then s5904 else s5909+  s5911 :: SWord8 = s5894 + s5910+  s5912 :: SBool = s5911 < s5910+  s5913 :: SBool = s5911 < s5894+  s5914 :: SBool = s5912 | s5913+  s5915 :: SWord8 = s5911 >>> 1+  s5916 :: SWord8 = s19 | s5915+  s5917 :: SWord8 = s21 & s5915+  s5918 :: SWord8 = if s5914 then s5916 else s5917+  s5919 :: SWord8 = if s5890 then s5898 else s5918+  s5920 :: SWord8 = s5873 + s5908+  s5921 :: SWord1 = choose [0:0] s5920+  s5922 :: SBool = s14 /= s5921+  s5923 :: SWord8 = if s5922 then s5884 else s5885+  s5924 :: SWord8 = if s17 then s5923 else s5881+  s5925 :: SWord1 = choose [0:0] s5924+  s5926 :: SBool = s14 /= s5925+  s5927 :: SBool = s_2 == s5926+  s5928 :: SBool = s5920 < s5908+  s5929 :: SBool = s5920 < s5873+  s5930 :: SBool = s5928 | s5929+  s5931 :: SWord8 = s5920 >>> 1+  s5932 :: SWord8 = s19 | s5931+  s5933 :: SWord8 = s21 & s5931+  s5934 :: SWord8 = if s5930 then s5932 else s5933+  s5935 :: SWord8 = s5934 >>> 1+  s5936 :: SWord8 = s19 | s5935+  s5937 :: SWord8 = s21 & s5935+  s5938 :: SWord8 = if s5926 then s5936 else s5937+  s5939 :: SWord8 = s5924 >>> 1+  s5940 :: SWord8 = s19 | s5939+  s5941 :: SWord8 = s21 & s5939+  s5942 :: SWord8 = if s5900 then s5940 else s5941+  s5943 :: SWord8 = if s24 then s5923 else s5908+  s5944 :: SWord8 = if s165 then s5942 else s5943+  s5945 :: SWord8 = s5934 + s5944+  s5946 :: SBool = s5945 < s5944+  s5947 :: SBool = s5945 < s5934+  s5948 :: SBool = s5946 | s5947+  s5949 :: SWord8 = s5945 >>> 1+  s5950 :: SWord8 = s19 | s5949+  s5951 :: SWord8 = s21 & s5949+  s5952 :: SWord8 = if s5948 then s5950 else s5951+  s5953 :: SWord8 = if s5927 then s5938 else s5952+  s5954 :: SWord8 = if s5869 then s5919 else s5953+  s5955 :: SWord8 = s5854 + s5906+  s5956 :: SWord1 = choose [0:0] s5955+  s5957 :: SBool = s14 /= s5956+  s5958 :: SWord8 = if s5957 then s5863 else s5864+  s5959 :: SWord8 = if s17 then s5958 else s5860+  s5960 :: SWord1 = choose [0:0] s5959+  s5961 :: SBool = s14 /= s5960+  s5962 :: SBool = s_2 == s5961+  s5963 :: SBool = s5955 < s5906+  s5964 :: SBool = s5955 < s5854+  s5965 :: SBool = s5963 | s5964+  s5966 :: SWord8 = s5955 >>> 1+  s5967 :: SWord8 = s19 | s5966+  s5968 :: SWord8 = s21 & s5966+  s5969 :: SWord8 = if s5965 then s5967 else s5968+  s5970 :: SWord1 = choose [0:0] s5969+  s5971 :: SBool = s14 /= s5970+  s5972 :: SWord8 = s5959 >>> 1+  s5973 :: SWord8 = s19 | s5972+  s5974 :: SWord8 = s21 & s5972+  s5975 :: SWord8 = if s5877 then s5973 else s5974+  s5976 :: SWord8 = if s17 then s5975 else s5958+  s5977 :: SWord8 = s5976 >>> 1+  s5978 :: SWord8 = s19 | s5977+  s5979 :: SWord8 = s21 & s5977+  s5980 :: SWord8 = if s5971 then s5978 else s5979+  s5981 :: SWord8 = if s17 then s5980 else s5975+  s5982 :: SWord1 = choose [0:0] s5981+  s5983 :: SBool = s14 /= s5982+  s5984 :: SBool = s_2 == s5983+  s5985 :: SWord8 = s5969 >>> 1+  s5986 :: SWord8 = s19 | s5985+  s5987 :: SWord8 = s21 & s5985+  s5988 :: SWord8 = if s5961 then s5986 else s5987+  s5989 :: SWord8 = s5988 >>> 1+  s5990 :: SWord8 = s19 | s5989+  s5991 :: SWord8 = s21 & s5989+  s5992 :: SWord8 = if s5983 then s5990 else s5991+  s5993 :: SWord1 = choose [0:0] s5976+  s5994 :: SBool = s14 /= s5993+  s5995 :: SWord8 = s5981 >>> 1+  s5996 :: SWord8 = s19 | s5995+  s5997 :: SWord8 = s21 & s5995+  s5998 :: SWord8 = if s5994 then s5996 else s5997+  s5999 :: SWord8 = if s24 then s5958 else s5906+  s6000 :: SWord8 = if s165 then s5975 else s5999+  s6001 :: SWord8 = if s24 then s5980 else s6000+  s6002 :: SWord8 = if s165 then s5998 else s6001+  s6003 :: SWord8 = s5988 + s6002+  s6004 :: SBool = s6003 < s6002+  s6005 :: SBool = s6003 < s5988+  s6006 :: SBool = s6004 | s6005+  s6007 :: SWord8 = s6003 >>> 1+  s6008 :: SWord8 = s19 | s6007+  s6009 :: SWord8 = s21 & s6007+  s6010 :: SWord8 = if s6006 then s6008 else s6009+  s6011 :: SWord8 = if s5984 then s5992 else s6010+  s6012 :: SWord8 = s5969 + s6000+  s6013 :: SWord1 = choose [0:0] s6012+  s6014 :: SBool = s14 /= s6013+  s6015 :: SWord8 = if s6014 then s5978 else s5979+  s6016 :: SWord8 = if s17 then s6015 else s5975+  s6017 :: SWord1 = choose [0:0] s6016+  s6018 :: SBool = s14 /= s6017+  s6019 :: SBool = s_2 == s6018+  s6020 :: SBool = s6012 < s6000+  s6021 :: SBool = s6012 < s5969+  s6022 :: SBool = s6020 | s6021+  s6023 :: SWord8 = s6012 >>> 1+  s6024 :: SWord8 = s19 | s6023+  s6025 :: SWord8 = s21 & s6023+  s6026 :: SWord8 = if s6022 then s6024 else s6025+  s6027 :: SWord8 = s6026 >>> 1+  s6028 :: SWord8 = s19 | s6027+  s6029 :: SWord8 = s21 & s6027+  s6030 :: SWord8 = if s6018 then s6028 else s6029+  s6031 :: SWord8 = s6016 >>> 1+  s6032 :: SWord8 = s19 | s6031+  s6033 :: SWord8 = s21 & s6031+  s6034 :: SWord8 = if s5994 then s6032 else s6033+  s6035 :: SWord8 = if s24 then s6015 else s6000+  s6036 :: SWord8 = if s165 then s6034 else s6035+  s6037 :: SWord8 = s6026 + s6036+  s6038 :: SBool = s6037 < s6036+  s6039 :: SBool = s6037 < s6026+  s6040 :: SBool = s6038 | s6039+  s6041 :: SWord8 = s6037 >>> 1+  s6042 :: SWord8 = s19 | s6041+  s6043 :: SWord8 = s21 & s6041+  s6044 :: SWord8 = if s6040 then s6042 else s6043+  s6045 :: SWord8 = if s6019 then s6030 else s6044+  s6046 :: SWord8 = if s5962 then s6011 else s6045+  s6047 :: SWord8 = if s5847 then s5954 else s6046+  s6048 :: SWord8 = if s5613 then s5839 else s6047+  s6049 :: SWord8 = s5596 + s5694+  s6050 :: SWord1 = choose [0:0] s6049+  s6051 :: SBool = s14 /= s6050+  s6052 :: SWord8 = if s6051 then s5607 else s5608+  s6053 :: SWord8 = if s17 then s6052 else s5604+  s6054 :: SWord1 = choose [0:0] s6053+  s6055 :: SBool = s14 /= s6054+  s6056 :: SBool = s_2 == s6055+  s6057 :: SBool = s6049 < s5694+  s6058 :: SBool = s6049 < s5596+  s6059 :: SBool = s6057 | s6058+  s6060 :: SWord8 = s6049 >>> 1+  s6061 :: SWord8 = s19 | s6060+  s6062 :: SWord8 = s21 & s6060+  s6063 :: SWord8 = if s6059 then s6061 else s6062+  s6064 :: SWord1 = choose [0:0] s6063+  s6065 :: SBool = s14 /= s6064+  s6066 :: SWord8 = s6053 >>> 1+  s6067 :: SWord8 = s19 | s6066+  s6068 :: SWord8 = s21 & s6066+  s6069 :: SWord8 = if s5621 then s6067 else s6068+  s6070 :: SWord8 = if s17 then s6069 else s6052+  s6071 :: SWord8 = s6070 >>> 1+  s6072 :: SWord8 = s19 | s6071+  s6073 :: SWord8 = s21 & s6071+  s6074 :: SWord8 = if s6065 then s6072 else s6073+  s6075 :: SWord8 = if s17 then s6074 else s6069+  s6076 :: SWord1 = choose [0:0] s6075+  s6077 :: SBool = s14 /= s6076+  s6078 :: SBool = s_2 == s6077+  s6079 :: SWord8 = s6063 >>> 1+  s6080 :: SWord8 = s19 | s6079+  s6081 :: SWord8 = s21 & s6079+  s6082 :: SWord8 = if s6055 then s6080 else s6081+  s6083 :: SWord1 = choose [0:0] s6082+  s6084 :: SBool = s14 /= s6083+  s6085 :: SWord1 = choose [0:0] s6070+  s6086 :: SBool = s14 /= s6085+  s6087 :: SWord8 = s6075 >>> 1+  s6088 :: SWord8 = s19 | s6087+  s6089 :: SWord8 = s21 & s6087+  s6090 :: SWord8 = if s6086 then s6088 else s6089+  s6091 :: SWord8 = if s17 then s6090 else s6074+  s6092 :: SWord8 = s6091 >>> 1+  s6093 :: SWord8 = s19 | s6092+  s6094 :: SWord8 = s21 & s6092+  s6095 :: SWord8 = if s6084 then s6093 else s6094+  s6096 :: SWord8 = if s17 then s6095 else s6090+  s6097 :: SWord1 = choose [0:0] s6096+  s6098 :: SBool = s14 /= s6097+  s6099 :: SBool = s_2 == s6098+  s6100 :: SWord8 = s6082 >>> 1+  s6101 :: SWord8 = s19 | s6100+  s6102 :: SWord8 = s21 & s6100+  s6103 :: SWord8 = if s6077 then s6101 else s6102+  s6104 :: SWord1 = choose [0:0] s6103+  s6105 :: SBool = s14 /= s6104+  s6106 :: SWord1 = choose [0:0] s6091+  s6107 :: SBool = s14 /= s6106+  s6108 :: SWord8 = s6096 >>> 1+  s6109 :: SWord8 = s19 | s6108+  s6110 :: SWord8 = s21 & s6108+  s6111 :: SWord8 = if s6107 then s6109 else s6110+  s6112 :: SWord8 = if s17 then s6111 else s6095+  s6113 :: SWord8 = s6112 >>> 1+  s6114 :: SWord8 = s19 | s6113+  s6115 :: SWord8 = s21 & s6113+  s6116 :: SWord8 = if s6105 then s6114 else s6115+  s6117 :: SWord8 = if s17 then s6116 else s6111+  s6118 :: SWord1 = choose [0:0] s6117+  s6119 :: SBool = s14 /= s6118+  s6120 :: SBool = s_2 == s6119+  s6121 :: SWord8 = s6103 >>> 1+  s6122 :: SWord8 = s19 | s6121+  s6123 :: SWord8 = s21 & s6121+  s6124 :: SWord8 = if s6098 then s6122 else s6123+  s6125 :: SWord8 = s6124 >>> 1+  s6126 :: SWord8 = s19 | s6125+  s6127 :: SWord8 = s21 & s6125+  s6128 :: SWord8 = if s6119 then s6126 else s6127+  s6129 :: SWord1 = choose [0:0] s6112+  s6130 :: SBool = s14 /= s6129+  s6131 :: SWord8 = s6117 >>> 1+  s6132 :: SWord8 = s19 | s6131+  s6133 :: SWord8 = s21 & s6131+  s6134 :: SWord8 = if s6130 then s6132 else s6133+  s6135 :: SWord8 = if s24 then s6052 else s5694+  s6136 :: SWord8 = if s165 then s6069 else s6135+  s6137 :: SWord8 = if s24 then s6074 else s6136+  s6138 :: SWord8 = if s165 then s6090 else s6137+  s6139 :: SWord8 = if s24 then s6095 else s6138+  s6140 :: SWord8 = if s165 then s6111 else s6139+  s6141 :: SWord8 = if s24 then s6116 else s6140+  s6142 :: SWord8 = if s165 then s6134 else s6141+  s6143 :: SWord8 = s6124 + s6142+  s6144 :: SBool = s6143 < s6142+  s6145 :: SBool = s6143 < s6124+  s6146 :: SBool = s6144 | s6145+  s6147 :: SWord8 = s6143 >>> 1+  s6148 :: SWord8 = s19 | s6147+  s6149 :: SWord8 = s21 & s6147+  s6150 :: SWord8 = if s6146 then s6148 else s6149+  s6151 :: SWord8 = if s6120 then s6128 else s6150+  s6152 :: SWord8 = s6103 + s6140+  s6153 :: SWord1 = choose [0:0] s6152+  s6154 :: SBool = s14 /= s6153+  s6155 :: SWord8 = if s6154 then s6114 else s6115+  s6156 :: SWord8 = if s17 then s6155 else s6111+  s6157 :: SWord1 = choose [0:0] s6156+  s6158 :: SBool = s14 /= s6157+  s6159 :: SBool = s_2 == s6158+  s6160 :: SBool = s6152 < s6140+  s6161 :: SBool = s6152 < s6103+  s6162 :: SBool = s6160 | s6161+  s6163 :: SWord8 = s6152 >>> 1+  s6164 :: SWord8 = s19 | s6163+  s6165 :: SWord8 = s21 & s6163+  s6166 :: SWord8 = if s6162 then s6164 else s6165+  s6167 :: SWord8 = s6166 >>> 1+  s6168 :: SWord8 = s19 | s6167+  s6169 :: SWord8 = s21 & s6167+  s6170 :: SWord8 = if s6158 then s6168 else s6169+  s6171 :: SWord8 = s6156 >>> 1+  s6172 :: SWord8 = s19 | s6171+  s6173 :: SWord8 = s21 & s6171+  s6174 :: SWord8 = if s6130 then s6172 else s6173+  s6175 :: SWord8 = if s24 then s6155 else s6140+  s6176 :: SWord8 = if s165 then s6174 else s6175+  s6177 :: SWord8 = s6166 + s6176+  s6178 :: SBool = s6177 < s6176+  s6179 :: SBool = s6177 < s6166+  s6180 :: SBool = s6178 | s6179+  s6181 :: SWord8 = s6177 >>> 1+  s6182 :: SWord8 = s19 | s6181+  s6183 :: SWord8 = s21 & s6181+  s6184 :: SWord8 = if s6180 then s6182 else s6183+  s6185 :: SWord8 = if s6159 then s6170 else s6184+  s6186 :: SWord8 = if s6099 then s6151 else s6185+  s6187 :: SWord8 = s6082 + s6138+  s6188 :: SWord1 = choose [0:0] s6187+  s6189 :: SBool = s14 /= s6188+  s6190 :: SWord8 = if s6189 then s6093 else s6094+  s6191 :: SWord8 = if s17 then s6190 else s6090+  s6192 :: SWord1 = choose [0:0] s6191+  s6193 :: SBool = s14 /= s6192+  s6194 :: SBool = s_2 == s6193+  s6195 :: SBool = s6187 < s6138+  s6196 :: SBool = s6187 < s6082+  s6197 :: SBool = s6195 | s6196+  s6198 :: SWord8 = s6187 >>> 1+  s6199 :: SWord8 = s19 | s6198+  s6200 :: SWord8 = s21 & s6198+  s6201 :: SWord8 = if s6197 then s6199 else s6200+  s6202 :: SWord1 = choose [0:0] s6201+  s6203 :: SBool = s14 /= s6202+  s6204 :: SWord8 = s6191 >>> 1+  s6205 :: SWord8 = s19 | s6204+  s6206 :: SWord8 = s21 & s6204+  s6207 :: SWord8 = if s6107 then s6205 else s6206+  s6208 :: SWord8 = if s17 then s6207 else s6190+  s6209 :: SWord8 = s6208 >>> 1+  s6210 :: SWord8 = s19 | s6209+  s6211 :: SWord8 = s21 & s6209+  s6212 :: SWord8 = if s6203 then s6210 else s6211+  s6213 :: SWord8 = if s17 then s6212 else s6207+  s6214 :: SWord1 = choose [0:0] s6213+  s6215 :: SBool = s14 /= s6214+  s6216 :: SBool = s_2 == s6215+  s6217 :: SWord8 = s6201 >>> 1+  s6218 :: SWord8 = s19 | s6217+  s6219 :: SWord8 = s21 & s6217+  s6220 :: SWord8 = if s6193 then s6218 else s6219+  s6221 :: SWord8 = s6220 >>> 1+  s6222 :: SWord8 = s19 | s6221+  s6223 :: SWord8 = s21 & s6221+  s6224 :: SWord8 = if s6215 then s6222 else s6223+  s6225 :: SWord1 = choose [0:0] s6208+  s6226 :: SBool = s14 /= s6225+  s6227 :: SWord8 = s6213 >>> 1+  s6228 :: SWord8 = s19 | s6227+  s6229 :: SWord8 = s21 & s6227+  s6230 :: SWord8 = if s6226 then s6228 else s6229+  s6231 :: SWord8 = if s24 then s6190 else s6138+  s6232 :: SWord8 = if s165 then s6207 else s6231+  s6233 :: SWord8 = if s24 then s6212 else s6232+  s6234 :: SWord8 = if s165 then s6230 else s6233+  s6235 :: SWord8 = s6220 + s6234+  s6236 :: SBool = s6235 < s6234+  s6237 :: SBool = s6235 < s6220+  s6238 :: SBool = s6236 | s6237+  s6239 :: SWord8 = s6235 >>> 1+  s6240 :: SWord8 = s19 | s6239+  s6241 :: SWord8 = s21 & s6239+  s6242 :: SWord8 = if s6238 then s6240 else s6241+  s6243 :: SWord8 = if s6216 then s6224 else s6242+  s6244 :: SWord8 = s6201 + s6232+  s6245 :: SWord1 = choose [0:0] s6244+  s6246 :: SBool = s14 /= s6245+  s6247 :: SWord8 = if s6246 then s6210 else s6211+  s6248 :: SWord8 = if s17 then s6247 else s6207+  s6249 :: SWord1 = choose [0:0] s6248+  s6250 :: SBool = s14 /= s6249+  s6251 :: SBool = s_2 == s6250+  s6252 :: SBool = s6244 < s6232+  s6253 :: SBool = s6244 < s6201+  s6254 :: SBool = s6252 | s6253+  s6255 :: SWord8 = s6244 >>> 1+  s6256 :: SWord8 = s19 | s6255+  s6257 :: SWord8 = s21 & s6255+  s6258 :: SWord8 = if s6254 then s6256 else s6257+  s6259 :: SWord8 = s6258 >>> 1+  s6260 :: SWord8 = s19 | s6259+  s6261 :: SWord8 = s21 & s6259+  s6262 :: SWord8 = if s6250 then s6260 else s6261+  s6263 :: SWord8 = s6248 >>> 1+  s6264 :: SWord8 = s19 | s6263+  s6265 :: SWord8 = s21 & s6263+  s6266 :: SWord8 = if s6226 then s6264 else s6265+  s6267 :: SWord8 = if s24 then s6247 else s6232+  s6268 :: SWord8 = if s165 then s6266 else s6267+  s6269 :: SWord8 = s6258 + s6268+  s6270 :: SBool = s6269 < s6268+  s6271 :: SBool = s6269 < s6258+  s6272 :: SBool = s6270 | s6271+  s6273 :: SWord8 = s6269 >>> 1+  s6274 :: SWord8 = s19 | s6273+  s6275 :: SWord8 = s21 & s6273+  s6276 :: SWord8 = if s6272 then s6274 else s6275+  s6277 :: SWord8 = if s6251 then s6262 else s6276+  s6278 :: SWord8 = if s6194 then s6243 else s6277+  s6279 :: SWord8 = if s6078 then s6186 else s6278+  s6280 :: SWord8 = s6063 + s6136+  s6281 :: SWord1 = choose [0:0] s6280+  s6282 :: SBool = s14 /= s6281+  s6283 :: SWord8 = if s6282 then s6072 else s6073+  s6284 :: SWord8 = if s17 then s6283 else s6069+  s6285 :: SWord1 = choose [0:0] s6284+  s6286 :: SBool = s14 /= s6285+  s6287 :: SBool = s_2 == s6286+  s6288 :: SBool = s6280 < s6136+  s6289 :: SBool = s6280 < s6063+  s6290 :: SBool = s6288 | s6289+  s6291 :: SWord8 = s6280 >>> 1+  s6292 :: SWord8 = s19 | s6291+  s6293 :: SWord8 = s21 & s6291+  s6294 :: SWord8 = if s6290 then s6292 else s6293+  s6295 :: SWord1 = choose [0:0] s6294+  s6296 :: SBool = s14 /= s6295+  s6297 :: SWord8 = s6284 >>> 1+  s6298 :: SWord8 = s19 | s6297+  s6299 :: SWord8 = s21 & s6297+  s6300 :: SWord8 = if s6086 then s6298 else s6299+  s6301 :: SWord8 = if s17 then s6300 else s6283+  s6302 :: SWord8 = s6301 >>> 1+  s6303 :: SWord8 = s19 | s6302+  s6304 :: SWord8 = s21 & s6302+  s6305 :: SWord8 = if s6296 then s6303 else s6304+  s6306 :: SWord8 = if s17 then s6305 else s6300+  s6307 :: SWord1 = choose [0:0] s6306+  s6308 :: SBool = s14 /= s6307+  s6309 :: SBool = s_2 == s6308+  s6310 :: SWord8 = s6294 >>> 1+  s6311 :: SWord8 = s19 | s6310+  s6312 :: SWord8 = s21 & s6310+  s6313 :: SWord8 = if s6286 then s6311 else s6312+  s6314 :: SWord1 = choose [0:0] s6313+  s6315 :: SBool = s14 /= s6314+  s6316 :: SWord1 = choose [0:0] s6301+  s6317 :: SBool = s14 /= s6316+  s6318 :: SWord8 = s6306 >>> 1+  s6319 :: SWord8 = s19 | s6318+  s6320 :: SWord8 = s21 & s6318+  s6321 :: SWord8 = if s6317 then s6319 else s6320+  s6322 :: SWord8 = if s17 then s6321 else s6305+  s6323 :: SWord8 = s6322 >>> 1+  s6324 :: SWord8 = s19 | s6323+  s6325 :: SWord8 = s21 & s6323+  s6326 :: SWord8 = if s6315 then s6324 else s6325+  s6327 :: SWord8 = if s17 then s6326 else s6321+  s6328 :: SWord1 = choose [0:0] s6327+  s6329 :: SBool = s14 /= s6328+  s6330 :: SBool = s_2 == s6329+  s6331 :: SWord8 = s6313 >>> 1+  s6332 :: SWord8 = s19 | s6331+  s6333 :: SWord8 = s21 & s6331+  s6334 :: SWord8 = if s6308 then s6332 else s6333+  s6335 :: SWord8 = s6334 >>> 1+  s6336 :: SWord8 = s19 | s6335+  s6337 :: SWord8 = s21 & s6335+  s6338 :: SWord8 = if s6329 then s6336 else s6337+  s6339 :: SWord1 = choose [0:0] s6322+  s6340 :: SBool = s14 /= s6339+  s6341 :: SWord8 = s6327 >>> 1+  s6342 :: SWord8 = s19 | s6341+  s6343 :: SWord8 = s21 & s6341+  s6344 :: SWord8 = if s6340 then s6342 else s6343+  s6345 :: SWord8 = if s24 then s6283 else s6136+  s6346 :: SWord8 = if s165 then s6300 else s6345+  s6347 :: SWord8 = if s24 then s6305 else s6346+  s6348 :: SWord8 = if s165 then s6321 else s6347+  s6349 :: SWord8 = if s24 then s6326 else s6348+  s6350 :: SWord8 = if s165 then s6344 else s6349+  s6351 :: SWord8 = s6334 + s6350+  s6352 :: SBool = s6351 < s6350+  s6353 :: SBool = s6351 < s6334+  s6354 :: SBool = s6352 | s6353+  s6355 :: SWord8 = s6351 >>> 1+  s6356 :: SWord8 = s19 | s6355+  s6357 :: SWord8 = s21 & s6355+  s6358 :: SWord8 = if s6354 then s6356 else s6357+  s6359 :: SWord8 = if s6330 then s6338 else s6358+  s6360 :: SWord8 = s6313 + s6348+  s6361 :: SWord1 = choose [0:0] s6360+  s6362 :: SBool = s14 /= s6361+  s6363 :: SWord8 = if s6362 then s6324 else s6325+  s6364 :: SWord8 = if s17 then s6363 else s6321+  s6365 :: SWord1 = choose [0:0] s6364+  s6366 :: SBool = s14 /= s6365+  s6367 :: SBool = s_2 == s6366+  s6368 :: SBool = s6360 < s6348+  s6369 :: SBool = s6360 < s6313+  s6370 :: SBool = s6368 | s6369+  s6371 :: SWord8 = s6360 >>> 1+  s6372 :: SWord8 = s19 | s6371+  s6373 :: SWord8 = s21 & s6371+  s6374 :: SWord8 = if s6370 then s6372 else s6373+  s6375 :: SWord8 = s6374 >>> 1+  s6376 :: SWord8 = s19 | s6375+  s6377 :: SWord8 = s21 & s6375+  s6378 :: SWord8 = if s6366 then s6376 else s6377+  s6379 :: SWord8 = s6364 >>> 1+  s6380 :: SWord8 = s19 | s6379+  s6381 :: SWord8 = s21 & s6379+  s6382 :: SWord8 = if s6340 then s6380 else s6381+  s6383 :: SWord8 = if s24 then s6363 else s6348+  s6384 :: SWord8 = if s165 then s6382 else s6383+  s6385 :: SWord8 = s6374 + s6384+  s6386 :: SBool = s6385 < s6384+  s6387 :: SBool = s6385 < s6374+  s6388 :: SBool = s6386 | s6387+  s6389 :: SWord8 = s6385 >>> 1+  s6390 :: SWord8 = s19 | s6389+  s6391 :: SWord8 = s21 & s6389+  s6392 :: SWord8 = if s6388 then s6390 else s6391+  s6393 :: SWord8 = if s6367 then s6378 else s6392+  s6394 :: SWord8 = if s6309 then s6359 else s6393+  s6395 :: SWord8 = s6294 + s6346+  s6396 :: SWord1 = choose [0:0] s6395+  s6397 :: SBool = s14 /= s6396+  s6398 :: SWord8 = if s6397 then s6303 else s6304+  s6399 :: SWord8 = if s17 then s6398 else s6300+  s6400 :: SWord1 = choose [0:0] s6399+  s6401 :: SBool = s14 /= s6400+  s6402 :: SBool = s_2 == s6401+  s6403 :: SBool = s6395 < s6346+  s6404 :: SBool = s6395 < s6294+  s6405 :: SBool = s6403 | s6404+  s6406 :: SWord8 = s6395 >>> 1+  s6407 :: SWord8 = s19 | s6406+  s6408 :: SWord8 = s21 & s6406+  s6409 :: SWord8 = if s6405 then s6407 else s6408+  s6410 :: SWord1 = choose [0:0] s6409+  s6411 :: SBool = s14 /= s6410+  s6412 :: SWord8 = s6399 >>> 1+  s6413 :: SWord8 = s19 | s6412+  s6414 :: SWord8 = s21 & s6412+  s6415 :: SWord8 = if s6317 then s6413 else s6414+  s6416 :: SWord8 = if s17 then s6415 else s6398+  s6417 :: SWord8 = s6416 >>> 1+  s6418 :: SWord8 = s19 | s6417+  s6419 :: SWord8 = s21 & s6417+  s6420 :: SWord8 = if s6411 then s6418 else s6419+  s6421 :: SWord8 = if s17 then s6420 else s6415+  s6422 :: SWord1 = choose [0:0] s6421+  s6423 :: SBool = s14 /= s6422+  s6424 :: SBool = s_2 == s6423+  s6425 :: SWord8 = s6409 >>> 1+  s6426 :: SWord8 = s19 | s6425+  s6427 :: SWord8 = s21 & s6425+  s6428 :: SWord8 = if s6401 then s6426 else s6427+  s6429 :: SWord8 = s6428 >>> 1+  s6430 :: SWord8 = s19 | s6429+  s6431 :: SWord8 = s21 & s6429+  s6432 :: SWord8 = if s6423 then s6430 else s6431+  s6433 :: SWord1 = choose [0:0] s6416+  s6434 :: SBool = s14 /= s6433+  s6435 :: SWord8 = s6421 >>> 1+  s6436 :: SWord8 = s19 | s6435+  s6437 :: SWord8 = s21 & s6435+  s6438 :: SWord8 = if s6434 then s6436 else s6437+  s6439 :: SWord8 = if s24 then s6398 else s6346+  s6440 :: SWord8 = if s165 then s6415 else s6439+  s6441 :: SWord8 = if s24 then s6420 else s6440+  s6442 :: SWord8 = if s165 then s6438 else s6441+  s6443 :: SWord8 = s6428 + s6442+  s6444 :: SBool = s6443 < s6442+  s6445 :: SBool = s6443 < s6428+  s6446 :: SBool = s6444 | s6445+  s6447 :: SWord8 = s6443 >>> 1+  s6448 :: SWord8 = s19 | s6447+  s6449 :: SWord8 = s21 & s6447+  s6450 :: SWord8 = if s6446 then s6448 else s6449+  s6451 :: SWord8 = if s6424 then s6432 else s6450+  s6452 :: SWord8 = s6409 + s6440+  s6453 :: SWord1 = choose [0:0] s6452+  s6454 :: SBool = s14 /= s6453+  s6455 :: SWord8 = if s6454 then s6418 else s6419+  s6456 :: SWord8 = if s17 then s6455 else s6415+  s6457 :: SWord1 = choose [0:0] s6456+  s6458 :: SBool = s14 /= s6457+  s6459 :: SBool = s_2 == s6458+  s6460 :: SBool = s6452 < s6440+  s6461 :: SBool = s6452 < s6409+  s6462 :: SBool = s6460 | s6461+  s6463 :: SWord8 = s6452 >>> 1+  s6464 :: SWord8 = s19 | s6463+  s6465 :: SWord8 = s21 & s6463+  s6466 :: SWord8 = if s6462 then s6464 else s6465+  s6467 :: SWord8 = s6466 >>> 1+  s6468 :: SWord8 = s19 | s6467+  s6469 :: SWord8 = s21 & s6467+  s6470 :: SWord8 = if s6458 then s6468 else s6469+  s6471 :: SWord8 = s6456 >>> 1+  s6472 :: SWord8 = s19 | s6471+  s6473 :: SWord8 = s21 & s6471+  s6474 :: SWord8 = if s6434 then s6472 else s6473+  s6475 :: SWord8 = if s24 then s6455 else s6440+  s6476 :: SWord8 = if s165 then s6474 else s6475+  s6477 :: SWord8 = s6466 + s6476+  s6478 :: SBool = s6477 < s6476+  s6479 :: SBool = s6477 < s6466+  s6480 :: SBool = s6478 | s6479+  s6481 :: SWord8 = s6477 >>> 1+  s6482 :: SWord8 = s19 | s6481+  s6483 :: SWord8 = s21 & s6481+  s6484 :: SWord8 = if s6480 then s6482 else s6483+  s6485 :: SWord8 = if s6459 then s6470 else s6484+  s6486 :: SWord8 = if s6402 then s6451 else s6485+  s6487 :: SWord8 = if s6287 then s6394 else s6486+  s6488 :: SWord8 = if s6056 then s6279 else s6487+  s6489 :: SWord8 = if s5592 then s6048 else s6488+  s6490 :: SWord8 = s5577 + s5692+  s6491 :: SWord1 = choose [0:0] s6490+  s6492 :: SBool = s14 /= s6491+  s6493 :: SWord8 = if s6492 then s5586 else s5587+  s6494 :: SWord8 = if s17 then s6493 else s5583+  s6495 :: SWord1 = choose [0:0] s6494+  s6496 :: SBool = s14 /= s6495+  s6497 :: SBool = s_2 == s6496+  s6498 :: SBool = s6490 < s5692+  s6499 :: SBool = s6490 < s5577+  s6500 :: SBool = s6498 | s6499+  s6501 :: SWord8 = s6490 >>> 1+  s6502 :: SWord8 = s19 | s6501+  s6503 :: SWord8 = s21 & s6501+  s6504 :: SWord8 = if s6500 then s6502 else s6503+  s6505 :: SWord1 = choose [0:0] s6504+  s6506 :: SBool = s14 /= s6505+  s6507 :: SWord8 = s6494 >>> 1+  s6508 :: SWord8 = s19 | s6507+  s6509 :: SWord8 = s21 & s6507+  s6510 :: SWord8 = if s5600 then s6508 else s6509+  s6511 :: SWord8 = if s17 then s6510 else s6493+  s6512 :: SWord8 = s6511 >>> 1+  s6513 :: SWord8 = s19 | s6512+  s6514 :: SWord8 = s21 & s6512+  s6515 :: SWord8 = if s6506 then s6513 else s6514+  s6516 :: SWord8 = if s17 then s6515 else s6510+  s6517 :: SWord1 = choose [0:0] s6516+  s6518 :: SBool = s14 /= s6517+  s6519 :: SBool = s_2 == s6518+  s6520 :: SWord8 = s6504 >>> 1+  s6521 :: SWord8 = s19 | s6520+  s6522 :: SWord8 = s21 & s6520+  s6523 :: SWord8 = if s6496 then s6521 else s6522+  s6524 :: SWord1 = choose [0:0] s6523+  s6525 :: SBool = s14 /= s6524+  s6526 :: SWord1 = choose [0:0] s6511+  s6527 :: SBool = s14 /= s6526+  s6528 :: SWord8 = s6516 >>> 1+  s6529 :: SWord8 = s19 | s6528+  s6530 :: SWord8 = s21 & s6528+  s6531 :: SWord8 = if s6527 then s6529 else s6530+  s6532 :: SWord8 = if s17 then s6531 else s6515+  s6533 :: SWord8 = s6532 >>> 1+  s6534 :: SWord8 = s19 | s6533+  s6535 :: SWord8 = s21 & s6533+  s6536 :: SWord8 = if s6525 then s6534 else s6535+  s6537 :: SWord8 = if s17 then s6536 else s6531+  s6538 :: SWord1 = choose [0:0] s6537+  s6539 :: SBool = s14 /= s6538+  s6540 :: SBool = s_2 == s6539+  s6541 :: SWord8 = s6523 >>> 1+  s6542 :: SWord8 = s19 | s6541+  s6543 :: SWord8 = s21 & s6541+  s6544 :: SWord8 = if s6518 then s6542 else s6543+  s6545 :: SWord1 = choose [0:0] s6544+  s6546 :: SBool = s14 /= s6545+  s6547 :: SWord1 = choose [0:0] s6532+  s6548 :: SBool = s14 /= s6547+  s6549 :: SWord8 = s6537 >>> 1+  s6550 :: SWord8 = s19 | s6549+  s6551 :: SWord8 = s21 & s6549+  s6552 :: SWord8 = if s6548 then s6550 else s6551+  s6553 :: SWord8 = if s17 then s6552 else s6536+  s6554 :: SWord8 = s6553 >>> 1+  s6555 :: SWord8 = s19 | s6554+  s6556 :: SWord8 = s21 & s6554+  s6557 :: SWord8 = if s6546 then s6555 else s6556+  s6558 :: SWord8 = if s17 then s6557 else s6552+  s6559 :: SWord1 = choose [0:0] s6558+  s6560 :: SBool = s14 /= s6559+  s6561 :: SBool = s_2 == s6560+  s6562 :: SWord8 = s6544 >>> 1+  s6563 :: SWord8 = s19 | s6562+  s6564 :: SWord8 = s21 & s6562+  s6565 :: SWord8 = if s6539 then s6563 else s6564+  s6566 :: SWord1 = choose [0:0] s6565+  s6567 :: SBool = s14 /= s6566+  s6568 :: SWord1 = choose [0:0] s6553+  s6569 :: SBool = s14 /= s6568+  s6570 :: SWord8 = s6558 >>> 1+  s6571 :: SWord8 = s19 | s6570+  s6572 :: SWord8 = s21 & s6570+  s6573 :: SWord8 = if s6569 then s6571 else s6572+  s6574 :: SWord8 = if s17 then s6573 else s6557+  s6575 :: SWord8 = s6574 >>> 1+  s6576 :: SWord8 = s19 | s6575+  s6577 :: SWord8 = s21 & s6575+  s6578 :: SWord8 = if s6567 then s6576 else s6577+  s6579 :: SWord8 = if s17 then s6578 else s6573+  s6580 :: SWord1 = choose [0:0] s6579+  s6581 :: SBool = s14 /= s6580+  s6582 :: SBool = s_2 == s6581+  s6583 :: SWord8 = s6565 >>> 1+  s6584 :: SWord8 = s19 | s6583+  s6585 :: SWord8 = s21 & s6583+  s6586 :: SWord8 = if s6560 then s6584 else s6585+  s6587 :: SWord8 = s6586 >>> 1+  s6588 :: SWord8 = s19 | s6587+  s6589 :: SWord8 = s21 & s6587+  s6590 :: SWord8 = if s6581 then s6588 else s6589+  s6591 :: SWord1 = choose [0:0] s6574+  s6592 :: SBool = s14 /= s6591+  s6593 :: SWord8 = s6579 >>> 1+  s6594 :: SWord8 = s19 | s6593+  s6595 :: SWord8 = s21 & s6593+  s6596 :: SWord8 = if s6592 then s6594 else s6595+  s6597 :: SWord8 = if s24 then s6493 else s5692+  s6598 :: SWord8 = if s165 then s6510 else s6597+  s6599 :: SWord8 = if s24 then s6515 else s6598+  s6600 :: SWord8 = if s165 then s6531 else s6599+  s6601 :: SWord8 = if s24 then s6536 else s6600+  s6602 :: SWord8 = if s165 then s6552 else s6601+  s6603 :: SWord8 = if s24 then s6557 else s6602+  s6604 :: SWord8 = if s165 then s6573 else s6603+  s6605 :: SWord8 = if s24 then s6578 else s6604+  s6606 :: SWord8 = if s165 then s6596 else s6605+  s6607 :: SWord8 = s6586 + s6606+  s6608 :: SBool = s6607 < s6606+  s6609 :: SBool = s6607 < s6586+  s6610 :: SBool = s6608 | s6609+  s6611 :: SWord8 = s6607 >>> 1+  s6612 :: SWord8 = s19 | s6611+  s6613 :: SWord8 = s21 & s6611+  s6614 :: SWord8 = if s6610 then s6612 else s6613+  s6615 :: SWord8 = if s6582 then s6590 else s6614+  s6616 :: SWord8 = s6565 + s6604+  s6617 :: SWord1 = choose [0:0] s6616+  s6618 :: SBool = s14 /= s6617+  s6619 :: SWord8 = if s6618 then s6576 else s6577+  s6620 :: SWord8 = if s17 then s6619 else s6573+  s6621 :: SWord1 = choose [0:0] s6620+  s6622 :: SBool = s14 /= s6621+  s6623 :: SBool = s_2 == s6622+  s6624 :: SBool = s6616 < s6604+  s6625 :: SBool = s6616 < s6565+  s6626 :: SBool = s6624 | s6625+  s6627 :: SWord8 = s6616 >>> 1+  s6628 :: SWord8 = s19 | s6627+  s6629 :: SWord8 = s21 & s6627+  s6630 :: SWord8 = if s6626 then s6628 else s6629+  s6631 :: SWord8 = s6630 >>> 1+  s6632 :: SWord8 = s19 | s6631+  s6633 :: SWord8 = s21 & s6631+  s6634 :: SWord8 = if s6622 then s6632 else s6633+  s6635 :: SWord8 = s6620 >>> 1+  s6636 :: SWord8 = s19 | s6635+  s6637 :: SWord8 = s21 & s6635+  s6638 :: SWord8 = if s6592 then s6636 else s6637+  s6639 :: SWord8 = if s24 then s6619 else s6604+  s6640 :: SWord8 = if s165 then s6638 else s6639+  s6641 :: SWord8 = s6630 + s6640+  s6642 :: SBool = s6641 < s6640+  s6643 :: SBool = s6641 < s6630+  s6644 :: SBool = s6642 | s6643+  s6645 :: SWord8 = s6641 >>> 1+  s6646 :: SWord8 = s19 | s6645+  s6647 :: SWord8 = s21 & s6645+  s6648 :: SWord8 = if s6644 then s6646 else s6647+  s6649 :: SWord8 = if s6623 then s6634 else s6648+  s6650 :: SWord8 = if s6561 then s6615 else s6649+  s6651 :: SWord8 = s6544 + s6602+  s6652 :: SWord1 = choose [0:0] s6651+  s6653 :: SBool = s14 /= s6652+  s6654 :: SWord8 = if s6653 then s6555 else s6556+  s6655 :: SWord8 = if s17 then s6654 else s6552+  s6656 :: SWord1 = choose [0:0] s6655+  s6657 :: SBool = s14 /= s6656+  s6658 :: SBool = s_2 == s6657+  s6659 :: SBool = s6651 < s6602+  s6660 :: SBool = s6651 < s6544+  s6661 :: SBool = s6659 | s6660+  s6662 :: SWord8 = s6651 >>> 1+  s6663 :: SWord8 = s19 | s6662+  s6664 :: SWord8 = s21 & s6662+  s6665 :: SWord8 = if s6661 then s6663 else s6664+  s6666 :: SWord1 = choose [0:0] s6665+  s6667 :: SBool = s14 /= s6666+  s6668 :: SWord8 = s6655 >>> 1+  s6669 :: SWord8 = s19 | s6668+  s6670 :: SWord8 = s21 & s6668+  s6671 :: SWord8 = if s6569 then s6669 else s6670+  s6672 :: SWord8 = if s17 then s6671 else s6654+  s6673 :: SWord8 = s6672 >>> 1+  s6674 :: SWord8 = s19 | s6673+  s6675 :: SWord8 = s21 & s6673+  s6676 :: SWord8 = if s6667 then s6674 else s6675+  s6677 :: SWord8 = if s17 then s6676 else s6671+  s6678 :: SWord1 = choose [0:0] s6677+  s6679 :: SBool = s14 /= s6678+  s6680 :: SBool = s_2 == s6679+  s6681 :: SWord8 = s6665 >>> 1+  s6682 :: SWord8 = s19 | s6681+  s6683 :: SWord8 = s21 & s6681+  s6684 :: SWord8 = if s6657 then s6682 else s6683+  s6685 :: SWord8 = s6684 >>> 1+  s6686 :: SWord8 = s19 | s6685+  s6687 :: SWord8 = s21 & s6685+  s6688 :: SWord8 = if s6679 then s6686 else s6687+  s6689 :: SWord1 = choose [0:0] s6672+  s6690 :: SBool = s14 /= s6689+  s6691 :: SWord8 = s6677 >>> 1+  s6692 :: SWord8 = s19 | s6691+  s6693 :: SWord8 = s21 & s6691+  s6694 :: SWord8 = if s6690 then s6692 else s6693+  s6695 :: SWord8 = if s24 then s6654 else s6602+  s6696 :: SWord8 = if s165 then s6671 else s6695+  s6697 :: SWord8 = if s24 then s6676 else s6696+  s6698 :: SWord8 = if s165 then s6694 else s6697+  s6699 :: SWord8 = s6684 + s6698+  s6700 :: SBool = s6699 < s6698+  s6701 :: SBool = s6699 < s6684+  s6702 :: SBool = s6700 | s6701+  s6703 :: SWord8 = s6699 >>> 1+  s6704 :: SWord8 = s19 | s6703+  s6705 :: SWord8 = s21 & s6703+  s6706 :: SWord8 = if s6702 then s6704 else s6705+  s6707 :: SWord8 = if s6680 then s6688 else s6706+  s6708 :: SWord8 = s6665 + s6696+  s6709 :: SWord1 = choose [0:0] s6708+  s6710 :: SBool = s14 /= s6709+  s6711 :: SWord8 = if s6710 then s6674 else s6675+  s6712 :: SWord8 = if s17 then s6711 else s6671+  s6713 :: SWord1 = choose [0:0] s6712+  s6714 :: SBool = s14 /= s6713+  s6715 :: SBool = s_2 == s6714+  s6716 :: SBool = s6708 < s6696+  s6717 :: SBool = s6708 < s6665+  s6718 :: SBool = s6716 | s6717+  s6719 :: SWord8 = s6708 >>> 1+  s6720 :: SWord8 = s19 | s6719+  s6721 :: SWord8 = s21 & s6719+  s6722 :: SWord8 = if s6718 then s6720 else s6721+  s6723 :: SWord8 = s6722 >>> 1+  s6724 :: SWord8 = s19 | s6723+  s6725 :: SWord8 = s21 & s6723+  s6726 :: SWord8 = if s6714 then s6724 else s6725+  s6727 :: SWord8 = s6712 >>> 1+  s6728 :: SWord8 = s19 | s6727+  s6729 :: SWord8 = s21 & s6727+  s6730 :: SWord8 = if s6690 then s6728 else s6729+  s6731 :: SWord8 = if s24 then s6711 else s6696+  s6732 :: SWord8 = if s165 then s6730 else s6731+  s6733 :: SWord8 = s6722 + s6732+  s6734 :: SBool = s6733 < s6732+  s6735 :: SBool = s6733 < s6722+  s6736 :: SBool = s6734 | s6735+  s6737 :: SWord8 = s6733 >>> 1+  s6738 :: SWord8 = s19 | s6737+  s6739 :: SWord8 = s21 & s6737+  s6740 :: SWord8 = if s6736 then s6738 else s6739+  s6741 :: SWord8 = if s6715 then s6726 else s6740+  s6742 :: SWord8 = if s6658 then s6707 else s6741+  s6743 :: SWord8 = if s6540 then s6650 else s6742+  s6744 :: SWord8 = s6523 + s6600+  s6745 :: SWord1 = choose [0:0] s6744+  s6746 :: SBool = s14 /= s6745+  s6747 :: SWord8 = if s6746 then s6534 else s6535+  s6748 :: SWord8 = if s17 then s6747 else s6531+  s6749 :: SWord1 = choose [0:0] s6748+  s6750 :: SBool = s14 /= s6749+  s6751 :: SBool = s_2 == s6750+  s6752 :: SBool = s6744 < s6600+  s6753 :: SBool = s6744 < s6523+  s6754 :: SBool = s6752 | s6753+  s6755 :: SWord8 = s6744 >>> 1+  s6756 :: SWord8 = s19 | s6755+  s6757 :: SWord8 = s21 & s6755+  s6758 :: SWord8 = if s6754 then s6756 else s6757+  s6759 :: SWord1 = choose [0:0] s6758+  s6760 :: SBool = s14 /= s6759+  s6761 :: SWord8 = s6748 >>> 1+  s6762 :: SWord8 = s19 | s6761+  s6763 :: SWord8 = s21 & s6761+  s6764 :: SWord8 = if s6548 then s6762 else s6763+  s6765 :: SWord8 = if s17 then s6764 else s6747+  s6766 :: SWord8 = s6765 >>> 1+  s6767 :: SWord8 = s19 | s6766+  s6768 :: SWord8 = s21 & s6766+  s6769 :: SWord8 = if s6760 then s6767 else s6768+  s6770 :: SWord8 = if s17 then s6769 else s6764+  s6771 :: SWord1 = choose [0:0] s6770+  s6772 :: SBool = s14 /= s6771+  s6773 :: SBool = s_2 == s6772+  s6774 :: SWord8 = s6758 >>> 1+  s6775 :: SWord8 = s19 | s6774+  s6776 :: SWord8 = s21 & s6774+  s6777 :: SWord8 = if s6750 then s6775 else s6776+  s6778 :: SWord1 = choose [0:0] s6777+  s6779 :: SBool = s14 /= s6778+  s6780 :: SWord1 = choose [0:0] s6765+  s6781 :: SBool = s14 /= s6780+  s6782 :: SWord8 = s6770 >>> 1+  s6783 :: SWord8 = s19 | s6782+  s6784 :: SWord8 = s21 & s6782+  s6785 :: SWord8 = if s6781 then s6783 else s6784+  s6786 :: SWord8 = if s17 then s6785 else s6769+  s6787 :: SWord8 = s6786 >>> 1+  s6788 :: SWord8 = s19 | s6787+  s6789 :: SWord8 = s21 & s6787+  s6790 :: SWord8 = if s6779 then s6788 else s6789+  s6791 :: SWord8 = if s17 then s6790 else s6785+  s6792 :: SWord1 = choose [0:0] s6791+  s6793 :: SBool = s14 /= s6792+  s6794 :: SBool = s_2 == s6793+  s6795 :: SWord8 = s6777 >>> 1+  s6796 :: SWord8 = s19 | s6795+  s6797 :: SWord8 = s21 & s6795+  s6798 :: SWord8 = if s6772 then s6796 else s6797+  s6799 :: SWord8 = s6798 >>> 1+  s6800 :: SWord8 = s19 | s6799+  s6801 :: SWord8 = s21 & s6799+  s6802 :: SWord8 = if s6793 then s6800 else s6801+  s6803 :: SWord1 = choose [0:0] s6786+  s6804 :: SBool = s14 /= s6803+  s6805 :: SWord8 = s6791 >>> 1+  s6806 :: SWord8 = s19 | s6805+  s6807 :: SWord8 = s21 & s6805+  s6808 :: SWord8 = if s6804 then s6806 else s6807+  s6809 :: SWord8 = if s24 then s6747 else s6600+  s6810 :: SWord8 = if s165 then s6764 else s6809+  s6811 :: SWord8 = if s24 then s6769 else s6810+  s6812 :: SWord8 = if s165 then s6785 else s6811+  s6813 :: SWord8 = if s24 then s6790 else s6812+  s6814 :: SWord8 = if s165 then s6808 else s6813+  s6815 :: SWord8 = s6798 + s6814+  s6816 :: SBool = s6815 < s6814+  s6817 :: SBool = s6815 < s6798+  s6818 :: SBool = s6816 | s6817+  s6819 :: SWord8 = s6815 >>> 1+  s6820 :: SWord8 = s19 | s6819+  s6821 :: SWord8 = s21 & s6819+  s6822 :: SWord8 = if s6818 then s6820 else s6821+  s6823 :: SWord8 = if s6794 then s6802 else s6822+  s6824 :: SWord8 = s6777 + s6812+  s6825 :: SWord1 = choose [0:0] s6824+  s6826 :: SBool = s14 /= s6825+  s6827 :: SWord8 = if s6826 then s6788 else s6789+  s6828 :: SWord8 = if s17 then s6827 else s6785+  s6829 :: SWord1 = choose [0:0] s6828+  s6830 :: SBool = s14 /= s6829+  s6831 :: SBool = s_2 == s6830+  s6832 :: SBool = s6824 < s6812+  s6833 :: SBool = s6824 < s6777+  s6834 :: SBool = s6832 | s6833+  s6835 :: SWord8 = s6824 >>> 1+  s6836 :: SWord8 = s19 | s6835+  s6837 :: SWord8 = s21 & s6835+  s6838 :: SWord8 = if s6834 then s6836 else s6837+  s6839 :: SWord8 = s6838 >>> 1+  s6840 :: SWord8 = s19 | s6839+  s6841 :: SWord8 = s21 & s6839+  s6842 :: SWord8 = if s6830 then s6840 else s6841+  s6843 :: SWord8 = s6828 >>> 1+  s6844 :: SWord8 = s19 | s6843+  s6845 :: SWord8 = s21 & s6843+  s6846 :: SWord8 = if s6804 then s6844 else s6845+  s6847 :: SWord8 = if s24 then s6827 else s6812+  s6848 :: SWord8 = if s165 then s6846 else s6847+  s6849 :: SWord8 = s6838 + s6848+  s6850 :: SBool = s6849 < s6848+  s6851 :: SBool = s6849 < s6838+  s6852 :: SBool = s6850 | s6851+  s6853 :: SWord8 = s6849 >>> 1+  s6854 :: SWord8 = s19 | s6853+  s6855 :: SWord8 = s21 & s6853+  s6856 :: SWord8 = if s6852 then s6854 else s6855+  s6857 :: SWord8 = if s6831 then s6842 else s6856+  s6858 :: SWord8 = if s6773 then s6823 else s6857+  s6859 :: SWord8 = s6758 + s6810+  s6860 :: SWord1 = choose [0:0] s6859+  s6861 :: SBool = s14 /= s6860+  s6862 :: SWord8 = if s6861 then s6767 else s6768+  s6863 :: SWord8 = if s17 then s6862 else s6764+  s6864 :: SWord1 = choose [0:0] s6863+  s6865 :: SBool = s14 /= s6864+  s6866 :: SBool = s_2 == s6865+  s6867 :: SBool = s6859 < s6810+  s6868 :: SBool = s6859 < s6758+  s6869 :: SBool = s6867 | s6868+  s6870 :: SWord8 = s6859 >>> 1+  s6871 :: SWord8 = s19 | s6870+  s6872 :: SWord8 = s21 & s6870+  s6873 :: SWord8 = if s6869 then s6871 else s6872+  s6874 :: SWord1 = choose [0:0] s6873+  s6875 :: SBool = s14 /= s6874+  s6876 :: SWord8 = s6863 >>> 1+  s6877 :: SWord8 = s19 | s6876+  s6878 :: SWord8 = s21 & s6876+  s6879 :: SWord8 = if s6781 then s6877 else s6878+  s6880 :: SWord8 = if s17 then s6879 else s6862+  s6881 :: SWord8 = s6880 >>> 1+  s6882 :: SWord8 = s19 | s6881+  s6883 :: SWord8 = s21 & s6881+  s6884 :: SWord8 = if s6875 then s6882 else s6883+  s6885 :: SWord8 = if s17 then s6884 else s6879+  s6886 :: SWord1 = choose [0:0] s6885+  s6887 :: SBool = s14 /= s6886+  s6888 :: SBool = s_2 == s6887+  s6889 :: SWord8 = s6873 >>> 1+  s6890 :: SWord8 = s19 | s6889+  s6891 :: SWord8 = s21 & s6889+  s6892 :: SWord8 = if s6865 then s6890 else s6891+  s6893 :: SWord8 = s6892 >>> 1+  s6894 :: SWord8 = s19 | s6893+  s6895 :: SWord8 = s21 & s6893+  s6896 :: SWord8 = if s6887 then s6894 else s6895+  s6897 :: SWord1 = choose [0:0] s6880+  s6898 :: SBool = s14 /= s6897+  s6899 :: SWord8 = s6885 >>> 1+  s6900 :: SWord8 = s19 | s6899+  s6901 :: SWord8 = s21 & s6899+  s6902 :: SWord8 = if s6898 then s6900 else s6901+  s6903 :: SWord8 = if s24 then s6862 else s6810+  s6904 :: SWord8 = if s165 then s6879 else s6903+  s6905 :: SWord8 = if s24 then s6884 else s6904+  s6906 :: SWord8 = if s165 then s6902 else s6905+  s6907 :: SWord8 = s6892 + s6906+  s6908 :: SBool = s6907 < s6906+  s6909 :: SBool = s6907 < s6892+  s6910 :: SBool = s6908 | s6909+  s6911 :: SWord8 = s6907 >>> 1+  s6912 :: SWord8 = s19 | s6911+  s6913 :: SWord8 = s21 & s6911+  s6914 :: SWord8 = if s6910 then s6912 else s6913+  s6915 :: SWord8 = if s6888 then s6896 else s6914+  s6916 :: SWord8 = s6873 + s6904+  s6917 :: SWord1 = choose [0:0] s6916+  s6918 :: SBool = s14 /= s6917+  s6919 :: SWord8 = if s6918 then s6882 else s6883+  s6920 :: SWord8 = if s17 then s6919 else s6879+  s6921 :: SWord1 = choose [0:0] s6920+  s6922 :: SBool = s14 /= s6921+  s6923 :: SBool = s_2 == s6922+  s6924 :: SBool = s6916 < s6904+  s6925 :: SBool = s6916 < s6873+  s6926 :: SBool = s6924 | s6925+  s6927 :: SWord8 = s6916 >>> 1+  s6928 :: SWord8 = s19 | s6927+  s6929 :: SWord8 = s21 & s6927+  s6930 :: SWord8 = if s6926 then s6928 else s6929+  s6931 :: SWord8 = s6930 >>> 1+  s6932 :: SWord8 = s19 | s6931+  s6933 :: SWord8 = s21 & s6931+  s6934 :: SWord8 = if s6922 then s6932 else s6933+  s6935 :: SWord8 = s6920 >>> 1+  s6936 :: SWord8 = s19 | s6935+  s6937 :: SWord8 = s21 & s6935+  s6938 :: SWord8 = if s6898 then s6936 else s6937+  s6939 :: SWord8 = if s24 then s6919 else s6904+  s6940 :: SWord8 = if s165 then s6938 else s6939+  s6941 :: SWord8 = s6930 + s6940+  s6942 :: SBool = s6941 < s6940+  s6943 :: SBool = s6941 < s6930+  s6944 :: SBool = s6942 | s6943+  s6945 :: SWord8 = s6941 >>> 1+  s6946 :: SWord8 = s19 | s6945+  s6947 :: SWord8 = s21 & s6945+  s6948 :: SWord8 = if s6944 then s6946 else s6947+  s6949 :: SWord8 = if s6923 then s6934 else s6948+  s6950 :: SWord8 = if s6866 then s6915 else s6949+  s6951 :: SWord8 = if s6751 then s6858 else s6950+  s6952 :: SWord8 = if s6519 then s6743 else s6951+  s6953 :: SWord8 = s6504 + s6598+  s6954 :: SWord1 = choose [0:0] s6953+  s6955 :: SBool = s14 /= s6954+  s6956 :: SWord8 = if s6955 then s6513 else s6514+  s6957 :: SWord8 = if s17 then s6956 else s6510+  s6958 :: SWord1 = choose [0:0] s6957+  s6959 :: SBool = s14 /= s6958+  s6960 :: SBool = s_2 == s6959+  s6961 :: SBool = s6953 < s6598+  s6962 :: SBool = s6953 < s6504+  s6963 :: SBool = s6961 | s6962+  s6964 :: SWord8 = s6953 >>> 1+  s6965 :: SWord8 = s19 | s6964+  s6966 :: SWord8 = s21 & s6964+  s6967 :: SWord8 = if s6963 then s6965 else s6966+  s6968 :: SWord1 = choose [0:0] s6967+  s6969 :: SBool = s14 /= s6968+  s6970 :: SWord8 = s6957 >>> 1+  s6971 :: SWord8 = s19 | s6970+  s6972 :: SWord8 = s21 & s6970+  s6973 :: SWord8 = if s6527 then s6971 else s6972+  s6974 :: SWord8 = if s17 then s6973 else s6956+  s6975 :: SWord8 = s6974 >>> 1+  s6976 :: SWord8 = s19 | s6975+  s6977 :: SWord8 = s21 & s6975+  s6978 :: SWord8 = if s6969 then s6976 else s6977+  s6979 :: SWord8 = if s17 then s6978 else s6973+  s6980 :: SWord1 = choose [0:0] s6979+  s6981 :: SBool = s14 /= s6980+  s6982 :: SBool = s_2 == s6981+  s6983 :: SWord8 = s6967 >>> 1+  s6984 :: SWord8 = s19 | s6983+  s6985 :: SWord8 = s21 & s6983+  s6986 :: SWord8 = if s6959 then s6984 else s6985+  s6987 :: SWord1 = choose [0:0] s6986+  s6988 :: SBool = s14 /= s6987+  s6989 :: SWord1 = choose [0:0] s6974+  s6990 :: SBool = s14 /= s6989+  s6991 :: SWord8 = s6979 >>> 1+  s6992 :: SWord8 = s19 | s6991+  s6993 :: SWord8 = s21 & s6991+  s6994 :: SWord8 = if s6990 then s6992 else s6993+  s6995 :: SWord8 = if s17 then s6994 else s6978+  s6996 :: SWord8 = s6995 >>> 1+  s6997 :: SWord8 = s19 | s6996+  s6998 :: SWord8 = s21 & s6996+  s6999 :: SWord8 = if s6988 then s6997 else s6998+  s7000 :: SWord8 = if s17 then s6999 else s6994+  s7001 :: SWord1 = choose [0:0] s7000+  s7002 :: SBool = s14 /= s7001+  s7003 :: SBool = s_2 == s7002+  s7004 :: SWord8 = s6986 >>> 1+  s7005 :: SWord8 = s19 | s7004+  s7006 :: SWord8 = s21 & s7004+  s7007 :: SWord8 = if s6981 then s7005 else s7006+  s7008 :: SWord1 = choose [0:0] s7007+  s7009 :: SBool = s14 /= s7008+  s7010 :: SWord1 = choose [0:0] s6995+  s7011 :: SBool = s14 /= s7010+  s7012 :: SWord8 = s7000 >>> 1+  s7013 :: SWord8 = s19 | s7012+  s7014 :: SWord8 = s21 & s7012+  s7015 :: SWord8 = if s7011 then s7013 else s7014+  s7016 :: SWord8 = if s17 then s7015 else s6999+  s7017 :: SWord8 = s7016 >>> 1+  s7018 :: SWord8 = s19 | s7017+  s7019 :: SWord8 = s21 & s7017+  s7020 :: SWord8 = if s7009 then s7018 else s7019+  s7021 :: SWord8 = if s17 then s7020 else s7015+  s7022 :: SWord1 = choose [0:0] s7021+  s7023 :: SBool = s14 /= s7022+  s7024 :: SBool = s_2 == s7023+  s7025 :: SWord8 = s7007 >>> 1+  s7026 :: SWord8 = s19 | s7025+  s7027 :: SWord8 = s21 & s7025+  s7028 :: SWord8 = if s7002 then s7026 else s7027+  s7029 :: SWord8 = s7028 >>> 1+  s7030 :: SWord8 = s19 | s7029+  s7031 :: SWord8 = s21 & s7029+  s7032 :: SWord8 = if s7023 then s7030 else s7031+  s7033 :: SWord1 = choose [0:0] s7016+  s7034 :: SBool = s14 /= s7033+  s7035 :: SWord8 = s7021 >>> 1+  s7036 :: SWord8 = s19 | s7035+  s7037 :: SWord8 = s21 & s7035+  s7038 :: SWord8 = if s7034 then s7036 else s7037+  s7039 :: SWord8 = if s24 then s6956 else s6598+  s7040 :: SWord8 = if s165 then s6973 else s7039+  s7041 :: SWord8 = if s24 then s6978 else s7040+  s7042 :: SWord8 = if s165 then s6994 else s7041+  s7043 :: SWord8 = if s24 then s6999 else s7042+  s7044 :: SWord8 = if s165 then s7015 else s7043+  s7045 :: SWord8 = if s24 then s7020 else s7044+  s7046 :: SWord8 = if s165 then s7038 else s7045+  s7047 :: SWord8 = s7028 + s7046+  s7048 :: SBool = s7047 < s7046+  s7049 :: SBool = s7047 < s7028+  s7050 :: SBool = s7048 | s7049+  s7051 :: SWord8 = s7047 >>> 1+  s7052 :: SWord8 = s19 | s7051+  s7053 :: SWord8 = s21 & s7051+  s7054 :: SWord8 = if s7050 then s7052 else s7053+  s7055 :: SWord8 = if s7024 then s7032 else s7054+  s7056 :: SWord8 = s7007 + s7044+  s7057 :: SWord1 = choose [0:0] s7056+  s7058 :: SBool = s14 /= s7057+  s7059 :: SWord8 = if s7058 then s7018 else s7019+  s7060 :: SWord8 = if s17 then s7059 else s7015+  s7061 :: SWord1 = choose [0:0] s7060+  s7062 :: SBool = s14 /= s7061+  s7063 :: SBool = s_2 == s7062+  s7064 :: SBool = s7056 < s7044+  s7065 :: SBool = s7056 < s7007+  s7066 :: SBool = s7064 | s7065+  s7067 :: SWord8 = s7056 >>> 1+  s7068 :: SWord8 = s19 | s7067+  s7069 :: SWord8 = s21 & s7067+  s7070 :: SWord8 = if s7066 then s7068 else s7069+  s7071 :: SWord8 = s7070 >>> 1+  s7072 :: SWord8 = s19 | s7071+  s7073 :: SWord8 = s21 & s7071+  s7074 :: SWord8 = if s7062 then s7072 else s7073+  s7075 :: SWord8 = s7060 >>> 1+  s7076 :: SWord8 = s19 | s7075+  s7077 :: SWord8 = s21 & s7075+  s7078 :: SWord8 = if s7034 then s7076 else s7077+  s7079 :: SWord8 = if s24 then s7059 else s7044+  s7080 :: SWord8 = if s165 then s7078 else s7079+  s7081 :: SWord8 = s7070 + s7080+  s7082 :: SBool = s7081 < s7080+  s7083 :: SBool = s7081 < s7070+  s7084 :: SBool = s7082 | s7083+  s7085 :: SWord8 = s7081 >>> 1+  s7086 :: SWord8 = s19 | s7085+  s7087 :: SWord8 = s21 & s7085+  s7088 :: SWord8 = if s7084 then s7086 else s7087+  s7089 :: SWord8 = if s7063 then s7074 else s7088+  s7090 :: SWord8 = if s7003 then s7055 else s7089+  s7091 :: SWord8 = s6986 + s7042+  s7092 :: SWord1 = choose [0:0] s7091+  s7093 :: SBool = s14 /= s7092+  s7094 :: SWord8 = if s7093 then s6997 else s6998+  s7095 :: SWord8 = if s17 then s7094 else s6994+  s7096 :: SWord1 = choose [0:0] s7095+  s7097 :: SBool = s14 /= s7096+  s7098 :: SBool = s_2 == s7097+  s7099 :: SBool = s7091 < s7042+  s7100 :: SBool = s7091 < s6986+  s7101 :: SBool = s7099 | s7100+  s7102 :: SWord8 = s7091 >>> 1+  s7103 :: SWord8 = s19 | s7102+  s7104 :: SWord8 = s21 & s7102+  s7105 :: SWord8 = if s7101 then s7103 else s7104+  s7106 :: SWord1 = choose [0:0] s7105+  s7107 :: SBool = s14 /= s7106+  s7108 :: SWord8 = s7095 >>> 1+  s7109 :: SWord8 = s19 | s7108+  s7110 :: SWord8 = s21 & s7108+  s7111 :: SWord8 = if s7011 then s7109 else s7110+  s7112 :: SWord8 = if s17 then s7111 else s7094+  s7113 :: SWord8 = s7112 >>> 1+  s7114 :: SWord8 = s19 | s7113+  s7115 :: SWord8 = s21 & s7113+  s7116 :: SWord8 = if s7107 then s7114 else s7115+  s7117 :: SWord8 = if s17 then s7116 else s7111+  s7118 :: SWord1 = choose [0:0] s7117+  s7119 :: SBool = s14 /= s7118+  s7120 :: SBool = s_2 == s7119+  s7121 :: SWord8 = s7105 >>> 1+  s7122 :: SWord8 = s19 | s7121+  s7123 :: SWord8 = s21 & s7121+  s7124 :: SWord8 = if s7097 then s7122 else s7123+  s7125 :: SWord8 = s7124 >>> 1+  s7126 :: SWord8 = s19 | s7125+  s7127 :: SWord8 = s21 & s7125+  s7128 :: SWord8 = if s7119 then s7126 else s7127+  s7129 :: SWord1 = choose [0:0] s7112+  s7130 :: SBool = s14 /= s7129+  s7131 :: SWord8 = s7117 >>> 1+  s7132 :: SWord8 = s19 | s7131+  s7133 :: SWord8 = s21 & s7131+  s7134 :: SWord8 = if s7130 then s7132 else s7133+  s7135 :: SWord8 = if s24 then s7094 else s7042+  s7136 :: SWord8 = if s165 then s7111 else s7135+  s7137 :: SWord8 = if s24 then s7116 else s7136+  s7138 :: SWord8 = if s165 then s7134 else s7137+  s7139 :: SWord8 = s7124 + s7138+  s7140 :: SBool = s7139 < s7138+  s7141 :: SBool = s7139 < s7124+  s7142 :: SBool = s7140 | s7141+  s7143 :: SWord8 = s7139 >>> 1+  s7144 :: SWord8 = s19 | s7143+  s7145 :: SWord8 = s21 & s7143+  s7146 :: SWord8 = if s7142 then s7144 else s7145+  s7147 :: SWord8 = if s7120 then s7128 else s7146+  s7148 :: SWord8 = s7105 + s7136+  s7149 :: SWord1 = choose [0:0] s7148+  s7150 :: SBool = s14 /= s7149+  s7151 :: SWord8 = if s7150 then s7114 else s7115+  s7152 :: SWord8 = if s17 then s7151 else s7111+  s7153 :: SWord1 = choose [0:0] s7152+  s7154 :: SBool = s14 /= s7153+  s7155 :: SBool = s_2 == s7154+  s7156 :: SBool = s7148 < s7136+  s7157 :: SBool = s7148 < s7105+  s7158 :: SBool = s7156 | s7157+  s7159 :: SWord8 = s7148 >>> 1+  s7160 :: SWord8 = s19 | s7159+  s7161 :: SWord8 = s21 & s7159+  s7162 :: SWord8 = if s7158 then s7160 else s7161+  s7163 :: SWord8 = s7162 >>> 1+  s7164 :: SWord8 = s19 | s7163+  s7165 :: SWord8 = s21 & s7163+  s7166 :: SWord8 = if s7154 then s7164 else s7165+  s7167 :: SWord8 = s7152 >>> 1+  s7168 :: SWord8 = s19 | s7167+  s7169 :: SWord8 = s21 & s7167+  s7170 :: SWord8 = if s7130 then s7168 else s7169+  s7171 :: SWord8 = if s24 then s7151 else s7136+  s7172 :: SWord8 = if s165 then s7170 else s7171+  s7173 :: SWord8 = s7162 + s7172+  s7174 :: SBool = s7173 < s7172+  s7175 :: SBool = s7173 < s7162+  s7176 :: SBool = s7174 | s7175+  s7177 :: SWord8 = s7173 >>> 1+  s7178 :: SWord8 = s19 | s7177+  s7179 :: SWord8 = s21 & s7177+  s7180 :: SWord8 = if s7176 then s7178 else s7179+  s7181 :: SWord8 = if s7155 then s7166 else s7180+  s7182 :: SWord8 = if s7098 then s7147 else s7181+  s7183 :: SWord8 = if s6982 then s7090 else s7182+  s7184 :: SWord8 = s6967 + s7040+  s7185 :: SWord1 = choose [0:0] s7184+  s7186 :: SBool = s14 /= s7185+  s7187 :: SWord8 = if s7186 then s6976 else s6977+  s7188 :: SWord8 = if s17 then s7187 else s6973+  s7189 :: SWord1 = choose [0:0] s7188+  s7190 :: SBool = s14 /= s7189+  s7191 :: SBool = s_2 == s7190+  s7192 :: SBool = s7184 < s7040+  s7193 :: SBool = s7184 < s6967+  s7194 :: SBool = s7192 | s7193+  s7195 :: SWord8 = s7184 >>> 1+  s7196 :: SWord8 = s19 | s7195+  s7197 :: SWord8 = s21 & s7195+  s7198 :: SWord8 = if s7194 then s7196 else s7197+  s7199 :: SWord1 = choose [0:0] s7198+  s7200 :: SBool = s14 /= s7199+  s7201 :: SWord8 = s7188 >>> 1+  s7202 :: SWord8 = s19 | s7201+  s7203 :: SWord8 = s21 & s7201+  s7204 :: SWord8 = if s6990 then s7202 else s7203+  s7205 :: SWord8 = if s17 then s7204 else s7187+  s7206 :: SWord8 = s7205 >>> 1+  s7207 :: SWord8 = s19 | s7206+  s7208 :: SWord8 = s21 & s7206+  s7209 :: SWord8 = if s7200 then s7207 else s7208+  s7210 :: SWord8 = if s17 then s7209 else s7204+  s7211 :: SWord1 = choose [0:0] s7210+  s7212 :: SBool = s14 /= s7211+  s7213 :: SBool = s_2 == s7212+  s7214 :: SWord8 = s7198 >>> 1+  s7215 :: SWord8 = s19 | s7214+  s7216 :: SWord8 = s21 & s7214+  s7217 :: SWord8 = if s7190 then s7215 else s7216+  s7218 :: SWord1 = choose [0:0] s7217+  s7219 :: SBool = s14 /= s7218+  s7220 :: SWord1 = choose [0:0] s7205+  s7221 :: SBool = s14 /= s7220+  s7222 :: SWord8 = s7210 >>> 1+  s7223 :: SWord8 = s19 | s7222+  s7224 :: SWord8 = s21 & s7222+  s7225 :: SWord8 = if s7221 then s7223 else s7224+  s7226 :: SWord8 = if s17 then s7225 else s7209+  s7227 :: SWord8 = s7226 >>> 1+  s7228 :: SWord8 = s19 | s7227+  s7229 :: SWord8 = s21 & s7227+  s7230 :: SWord8 = if s7219 then s7228 else s7229+  s7231 :: SWord8 = if s17 then s7230 else s7225+  s7232 :: SWord1 = choose [0:0] s7231+  s7233 :: SBool = s14 /= s7232+  s7234 :: SBool = s_2 == s7233+  s7235 :: SWord8 = s7217 >>> 1+  s7236 :: SWord8 = s19 | s7235+  s7237 :: SWord8 = s21 & s7235+  s7238 :: SWord8 = if s7212 then s7236 else s7237+  s7239 :: SWord8 = s7238 >>> 1+  s7240 :: SWord8 = s19 | s7239+  s7241 :: SWord8 = s21 & s7239+  s7242 :: SWord8 = if s7233 then s7240 else s7241+  s7243 :: SWord1 = choose [0:0] s7226+  s7244 :: SBool = s14 /= s7243+  s7245 :: SWord8 = s7231 >>> 1+  s7246 :: SWord8 = s19 | s7245+  s7247 :: SWord8 = s21 & s7245+  s7248 :: SWord8 = if s7244 then s7246 else s7247+  s7249 :: SWord8 = if s24 then s7187 else s7040+  s7250 :: SWord8 = if s165 then s7204 else s7249+  s7251 :: SWord8 = if s24 then s7209 else s7250+  s7252 :: SWord8 = if s165 then s7225 else s7251+  s7253 :: SWord8 = if s24 then s7230 else s7252+  s7254 :: SWord8 = if s165 then s7248 else s7253+  s7255 :: SWord8 = s7238 + s7254+  s7256 :: SBool = s7255 < s7254+  s7257 :: SBool = s7255 < s7238+  s7258 :: SBool = s7256 | s7257+  s7259 :: SWord8 = s7255 >>> 1+  s7260 :: SWord8 = s19 | s7259+  s7261 :: SWord8 = s21 & s7259+  s7262 :: SWord8 = if s7258 then s7260 else s7261+  s7263 :: SWord8 = if s7234 then s7242 else s7262+  s7264 :: SWord8 = s7217 + s7252+  s7265 :: SWord1 = choose [0:0] s7264+  s7266 :: SBool = s14 /= s7265+  s7267 :: SWord8 = if s7266 then s7228 else s7229+  s7268 :: SWord8 = if s17 then s7267 else s7225+  s7269 :: SWord1 = choose [0:0] s7268+  s7270 :: SBool = s14 /= s7269+  s7271 :: SBool = s_2 == s7270+  s7272 :: SBool = s7264 < s7252+  s7273 :: SBool = s7264 < s7217+  s7274 :: SBool = s7272 | s7273+  s7275 :: SWord8 = s7264 >>> 1+  s7276 :: SWord8 = s19 | s7275+  s7277 :: SWord8 = s21 & s7275+  s7278 :: SWord8 = if s7274 then s7276 else s7277+  s7279 :: SWord8 = s7278 >>> 1+  s7280 :: SWord8 = s19 | s7279+  s7281 :: SWord8 = s21 & s7279+  s7282 :: SWord8 = if s7270 then s7280 else s7281+  s7283 :: SWord8 = s7268 >>> 1+  s7284 :: SWord8 = s19 | s7283+  s7285 :: SWord8 = s21 & s7283+  s7286 :: SWord8 = if s7244 then s7284 else s7285+  s7287 :: SWord8 = if s24 then s7267 else s7252+  s7288 :: SWord8 = if s165 then s7286 else s7287+  s7289 :: SWord8 = s7278 + s7288+  s7290 :: SBool = s7289 < s7288+  s7291 :: SBool = s7289 < s7278+  s7292 :: SBool = s7290 | s7291+  s7293 :: SWord8 = s7289 >>> 1+  s7294 :: SWord8 = s19 | s7293+  s7295 :: SWord8 = s21 & s7293+  s7296 :: SWord8 = if s7292 then s7294 else s7295+  s7297 :: SWord8 = if s7271 then s7282 else s7296+  s7298 :: SWord8 = if s7213 then s7263 else s7297+  s7299 :: SWord8 = s7198 + s7250+  s7300 :: SWord1 = choose [0:0] s7299+  s7301 :: SBool = s14 /= s7300+  s7302 :: SWord8 = if s7301 then s7207 else s7208+  s7303 :: SWord8 = if s17 then s7302 else s7204+  s7304 :: SWord1 = choose [0:0] s7303+  s7305 :: SBool = s14 /= s7304+  s7306 :: SBool = s_2 == s7305+  s7307 :: SBool = s7299 < s7250+  s7308 :: SBool = s7299 < s7198+  s7309 :: SBool = s7307 | s7308+  s7310 :: SWord8 = s7299 >>> 1+  s7311 :: SWord8 = s19 | s7310+  s7312 :: SWord8 = s21 & s7310+  s7313 :: SWord8 = if s7309 then s7311 else s7312+  s7314 :: SWord1 = choose [0:0] s7313+  s7315 :: SBool = s14 /= s7314+  s7316 :: SWord8 = s7303 >>> 1+  s7317 :: SWord8 = s19 | s7316+  s7318 :: SWord8 = s21 & s7316+  s7319 :: SWord8 = if s7221 then s7317 else s7318+  s7320 :: SWord8 = if s17 then s7319 else s7302+  s7321 :: SWord8 = s7320 >>> 1+  s7322 :: SWord8 = s19 | s7321+  s7323 :: SWord8 = s21 & s7321+  s7324 :: SWord8 = if s7315 then s7322 else s7323+  s7325 :: SWord8 = if s17 then s7324 else s7319+  s7326 :: SWord1 = choose [0:0] s7325+  s7327 :: SBool = s14 /= s7326+  s7328 :: SBool = s_2 == s7327+  s7329 :: SWord8 = s7313 >>> 1+  s7330 :: SWord8 = s19 | s7329+  s7331 :: SWord8 = s21 & s7329+  s7332 :: SWord8 = if s7305 then s7330 else s7331+  s7333 :: SWord8 = s7332 >>> 1+  s7334 :: SWord8 = s19 | s7333+  s7335 :: SWord8 = s21 & s7333+  s7336 :: SWord8 = if s7327 then s7334 else s7335+  s7337 :: SWord1 = choose [0:0] s7320+  s7338 :: SBool = s14 /= s7337+  s7339 :: SWord8 = s7325 >>> 1+  s7340 :: SWord8 = s19 | s7339+  s7341 :: SWord8 = s21 & s7339+  s7342 :: SWord8 = if s7338 then s7340 else s7341+  s7343 :: SWord8 = if s24 then s7302 else s7250+  s7344 :: SWord8 = if s165 then s7319 else s7343+  s7345 :: SWord8 = if s24 then s7324 else s7344+  s7346 :: SWord8 = if s165 then s7342 else s7345+  s7347 :: SWord8 = s7332 + s7346+  s7348 :: SBool = s7347 < s7346+  s7349 :: SBool = s7347 < s7332+  s7350 :: SBool = s7348 | s7349+  s7351 :: SWord8 = s7347 >>> 1+  s7352 :: SWord8 = s19 | s7351+  s7353 :: SWord8 = s21 & s7351+  s7354 :: SWord8 = if s7350 then s7352 else s7353+  s7355 :: SWord8 = if s7328 then s7336 else s7354+  s7356 :: SWord8 = s7313 + s7344+  s7357 :: SWord1 = choose [0:0] s7356+  s7358 :: SBool = s14 /= s7357+  s7359 :: SWord8 = if s7358 then s7322 else s7323+  s7360 :: SWord8 = if s17 then s7359 else s7319+  s7361 :: SWord1 = choose [0:0] s7360+  s7362 :: SBool = s14 /= s7361+  s7363 :: SBool = s_2 == s7362+  s7364 :: SBool = s7356 < s7344+  s7365 :: SBool = s7356 < s7313+  s7366 :: SBool = s7364 | s7365+  s7367 :: SWord8 = s7356 >>> 1+  s7368 :: SWord8 = s19 | s7367+  s7369 :: SWord8 = s21 & s7367+  s7370 :: SWord8 = if s7366 then s7368 else s7369+  s7371 :: SWord8 = s7370 >>> 1+  s7372 :: SWord8 = s19 | s7371+  s7373 :: SWord8 = s21 & s7371+  s7374 :: SWord8 = if s7362 then s7372 else s7373+  s7375 :: SWord8 = s7360 >>> 1+  s7376 :: SWord8 = s19 | s7375+  s7377 :: SWord8 = s21 & s7375+  s7378 :: SWord8 = if s7338 then s7376 else s7377+  s7379 :: SWord8 = if s24 then s7359 else s7344+  s7380 :: SWord8 = if s165 then s7378 else s7379+  s7381 :: SWord8 = s7370 + s7380+  s7382 :: SBool = s7381 < s7380+  s7383 :: SBool = s7381 < s7370+  s7384 :: SBool = s7382 | s7383+  s7385 :: SWord8 = s7381 >>> 1+  s7386 :: SWord8 = s19 | s7385+  s7387 :: SWord8 = s21 & s7385+  s7388 :: SWord8 = if s7384 then s7386 else s7387+  s7389 :: SWord8 = if s7363 then s7374 else s7388+  s7390 :: SWord8 = if s7306 then s7355 else s7389+  s7391 :: SWord8 = if s7191 then s7298 else s7390+  s7392 :: SWord8 = if s6960 then s7183 else s7391+  s7393 :: SWord8 = if s6497 then s6952 else s7392+  s7394 :: SWord8 = if s5570 then s6489 else s7393+  s7395 :: SWord8 = if s3720 then s5562 else s7394+  s7396 :: SWord8 = if s16 then s3712 else s7395+  s7397 :: SWord16 = s12 # s7396+  s7398 :: SWord16 = s11 * s7397+  s7399 :: SWord1 = choose [0:0] s160+  s7400 :: SBool = s14 /= s7399+  s7401 :: SWord8 = if s17 then s171 else s152+  s7402 :: SWord8 = s7401 >>> 1+  s7403 :: SWord8 = s19 | s7402+  s7404 :: SWord8 = s21 & s7402+  s7405 :: SWord8 = if s7400 then s7403 else s7404+  s7406 :: SWord1 = choose [0:0] s188+  s7407 :: SBool = s14 /= s7406+  s7408 :: SWord8 = if s7407 then s7403 else s7404+  s7409 :: SWord8 = if s156 then s7405 else s7408+  s7410 :: SWord1 = choose [0:0] s211+  s7411 :: SBool = s14 /= s7410+  s7412 :: SWord8 = if s17 then s219 else s200+  s7413 :: SWord8 = s7412 >>> 1+  s7414 :: SWord8 = s19 | s7413+  s7415 :: SWord8 = s21 & s7413+  s7416 :: SWord8 = if s7411 then s7414 else s7415+  s7417 :: SWord1 = choose [0:0] s222+  s7418 :: SBool = s14 /= s7417+  s7419 :: SWord8 = if s7418 then s7414 else s7415+  s7420 :: SWord8 = if s204 then s7416 else s7419+  s7421 :: SWord8 = if s135 then s7409 else s7420+  s7422 :: SWord1 = choose [0:0] s265+  s7423 :: SBool = s14 /= s7422+  s7424 :: SWord8 = if s17 then s275 else s257+  s7425 :: SWord8 = s7424 >>> 1+  s7426 :: SWord8 = s19 | s7425+  s7427 :: SWord8 = s21 & s7425+  s7428 :: SWord8 = if s7423 then s7426 else s7427+  s7429 :: SWord1 = choose [0:0] s280+  s7430 :: SBool = s14 /= s7429+  s7431 :: SWord8 = if s7430 then s7426 else s7427+  s7432 :: SWord8 = if s261 then s7428 else s7431+  s7433 :: SWord1 = choose [0:0] s303+  s7434 :: SBool = s14 /= s7433+  s7435 :: SWord8 = if s17 then s311 else s292+  s7436 :: SWord8 = s7435 >>> 1+  s7437 :: SWord8 = s19 | s7436+  s7438 :: SWord8 = s21 & s7436+  s7439 :: SWord8 = if s7434 then s7437 else s7438+  s7440 :: SWord1 = choose [0:0] s314+  s7441 :: SBool = s14 /= s7440+  s7442 :: SWord8 = if s7441 then s7437 else s7438+  s7443 :: SWord8 = if s296 then s7439 else s7442+  s7444 :: SWord8 = if s239 then s7432 else s7443+  s7445 :: SWord8 = if s114 then s7421 else s7444+  s7446 :: SWord1 = choose [0:0] s379+  s7447 :: SBool = s14 /= s7446+  s7448 :: SWord8 = if s17 then s389 else s371+  s7449 :: SWord8 = s7448 >>> 1+  s7450 :: SWord8 = s19 | s7449+  s7451 :: SWord8 = s21 & s7449+  s7452 :: SWord8 = if s7447 then s7450 else s7451+  s7453 :: SWord1 = choose [0:0] s396+  s7454 :: SBool = s14 /= s7453+  s7455 :: SWord8 = if s7454 then s7450 else s7451+  s7456 :: SWord8 = if s375 then s7452 else s7455+  s7457 :: SWord1 = choose [0:0] s419+  s7458 :: SBool = s14 /= s7457+  s7459 :: SWord8 = if s17 then s427 else s408+  s7460 :: SWord8 = s7459 >>> 1+  s7461 :: SWord8 = s19 | s7460+  s7462 :: SWord8 = s21 & s7460+  s7463 :: SWord8 = if s7458 then s7461 else s7462+  s7464 :: SWord1 = choose [0:0] s430+  s7465 :: SBool = s14 /= s7464+  s7466 :: SWord8 = if s7465 then s7461 else s7462+  s7467 :: SWord8 = if s412 then s7463 else s7466+  s7468 :: SWord8 = if s354 then s7456 else s7467+  s7469 :: SWord1 = choose [0:0] s473+  s7470 :: SBool = s14 /= s7469+  s7471 :: SWord8 = if s17 then s483 else s465+  s7472 :: SWord8 = s7471 >>> 1+  s7473 :: SWord8 = s19 | s7472+  s7474 :: SWord8 = s21 & s7472+  s7475 :: SWord8 = if s7470 then s7473 else s7474+  s7476 :: SWord1 = choose [0:0] s488+  s7477 :: SBool = s14 /= s7476+  s7478 :: SWord8 = if s7477 then s7473 else s7474+  s7479 :: SWord8 = if s469 then s7475 else s7478+  s7480 :: SWord1 = choose [0:0] s511+  s7481 :: SBool = s14 /= s7480+  s7482 :: SWord8 = if s17 then s519 else s500+  s7483 :: SWord8 = s7482 >>> 1+  s7484 :: SWord8 = s19 | s7483+  s7485 :: SWord8 = s21 & s7483+  s7486 :: SWord8 = if s7481 then s7484 else s7485+  s7487 :: SWord1 = choose [0:0] s522+  s7488 :: SBool = s14 /= s7487+  s7489 :: SWord8 = if s7488 then s7484 else s7485+  s7490 :: SWord8 = if s504 then s7486 else s7489+  s7491 :: SWord8 = if s447 then s7479 else s7490+  s7492 :: SWord8 = if s332 then s7468 else s7491+  s7493 :: SWord8 = if s93 then s7445 else s7492+  s7494 :: SWord1 = choose [0:0] s609+  s7495 :: SBool = s14 /= s7494+  s7496 :: SWord8 = if s17 then s619 else s601+  s7497 :: SWord8 = s7496 >>> 1+  s7498 :: SWord8 = s19 | s7497+  s7499 :: SWord8 = s21 & s7497+  s7500 :: SWord8 = if s7495 then s7498 else s7499+  s7501 :: SWord1 = choose [0:0] s628+  s7502 :: SBool = s14 /= s7501+  s7503 :: SWord8 = if s7502 then s7498 else s7499+  s7504 :: SWord8 = if s605 then s7500 else s7503+  s7505 :: SWord1 = choose [0:0] s651+  s7506 :: SBool = s14 /= s7505+  s7507 :: SWord8 = if s17 then s659 else s640+  s7508 :: SWord8 = s7507 >>> 1+  s7509 :: SWord8 = s19 | s7508+  s7510 :: SWord8 = s21 & s7508+  s7511 :: SWord8 = if s7506 then s7509 else s7510+  s7512 :: SWord1 = choose [0:0] s662+  s7513 :: SBool = s14 /= s7512+  s7514 :: SWord8 = if s7513 then s7509 else s7510+  s7515 :: SWord8 = if s644 then s7511 else s7514+  s7516 :: SWord8 = if s584 then s7504 else s7515+  s7517 :: SWord1 = choose [0:0] s705+  s7518 :: SBool = s14 /= s7517+  s7519 :: SWord8 = if s17 then s715 else s697+  s7520 :: SWord8 = s7519 >>> 1+  s7521 :: SWord8 = s19 | s7520+  s7522 :: SWord8 = s21 & s7520+  s7523 :: SWord8 = if s7518 then s7521 else s7522+  s7524 :: SWord1 = choose [0:0] s720+  s7525 :: SBool = s14 /= s7524+  s7526 :: SWord8 = if s7525 then s7521 else s7522+  s7527 :: SWord8 = if s701 then s7523 else s7526+  s7528 :: SWord1 = choose [0:0] s743+  s7529 :: SBool = s14 /= s7528+  s7530 :: SWord8 = if s17 then s751 else s732+  s7531 :: SWord8 = s7530 >>> 1+  s7532 :: SWord8 = s19 | s7531+  s7533 :: SWord8 = s21 & s7531+  s7534 :: SWord8 = if s7529 then s7532 else s7533+  s7535 :: SWord1 = choose [0:0] s754+  s7536 :: SBool = s14 /= s7535+  s7537 :: SWord8 = if s7536 then s7532 else s7533+  s7538 :: SWord8 = if s736 then s7534 else s7537+  s7539 :: SWord8 = if s679 then s7527 else s7538+  s7540 :: SWord8 = if s563 then s7516 else s7539+  s7541 :: SWord1 = choose [0:0] s819+  s7542 :: SBool = s14 /= s7541+  s7543 :: SWord8 = if s17 then s829 else s811+  s7544 :: SWord8 = s7543 >>> 1+  s7545 :: SWord8 = s19 | s7544+  s7546 :: SWord8 = s21 & s7544+  s7547 :: SWord8 = if s7542 then s7545 else s7546+  s7548 :: SWord1 = choose [0:0] s836+  s7549 :: SBool = s14 /= s7548+  s7550 :: SWord8 = if s7549 then s7545 else s7546+  s7551 :: SWord8 = if s815 then s7547 else s7550+  s7552 :: SWord1 = choose [0:0] s859+  s7553 :: SBool = s14 /= s7552+  s7554 :: SWord8 = if s17 then s867 else s848+  s7555 :: SWord8 = s7554 >>> 1+  s7556 :: SWord8 = s19 | s7555+  s7557 :: SWord8 = s21 & s7555+  s7558 :: SWord8 = if s7553 then s7556 else s7557+  s7559 :: SWord1 = choose [0:0] s870+  s7560 :: SBool = s14 /= s7559+  s7561 :: SWord8 = if s7560 then s7556 else s7557+  s7562 :: SWord8 = if s852 then s7558 else s7561+  s7563 :: SWord8 = if s794 then s7551 else s7562+  s7564 :: SWord1 = choose [0:0] s913+  s7565 :: SBool = s14 /= s7564+  s7566 :: SWord8 = if s17 then s923 else s905+  s7567 :: SWord8 = s7566 >>> 1+  s7568 :: SWord8 = s19 | s7567+  s7569 :: SWord8 = s21 & s7567+  s7570 :: SWord8 = if s7565 then s7568 else s7569+  s7571 :: SWord1 = choose [0:0] s928+  s7572 :: SBool = s14 /= s7571+  s7573 :: SWord8 = if s7572 then s7568 else s7569+  s7574 :: SWord8 = if s909 then s7570 else s7573+  s7575 :: SWord1 = choose [0:0] s951+  s7576 :: SBool = s14 /= s7575+  s7577 :: SWord8 = if s17 then s959 else s940+  s7578 :: SWord8 = s7577 >>> 1+  s7579 :: SWord8 = s19 | s7578+  s7580 :: SWord8 = s21 & s7578+  s7581 :: SWord8 = if s7576 then s7579 else s7580+  s7582 :: SWord1 = choose [0:0] s962+  s7583 :: SBool = s14 /= s7582+  s7584 :: SWord8 = if s7583 then s7579 else s7580+  s7585 :: SWord8 = if s944 then s7581 else s7584+  s7586 :: SWord8 = if s887 then s7574 else s7585+  s7587 :: SWord8 = if s772 then s7563 else s7586+  s7588 :: SWord8 = if s541 then s7540 else s7587+  s7589 :: SWord8 = if s72 then s7493 else s7588+  s7590 :: SWord1 = choose [0:0] s1071+  s7591 :: SBool = s14 /= s7590+  s7592 :: SWord8 = if s17 then s1081 else s1063+  s7593 :: SWord8 = s7592 >>> 1+  s7594 :: SWord8 = s19 | s7593+  s7595 :: SWord8 = s21 & s7593+  s7596 :: SWord8 = if s7591 then s7594 else s7595+  s7597 :: SWord1 = choose [0:0] s1092+  s7598 :: SBool = s14 /= s7597+  s7599 :: SWord8 = if s7598 then s7594 else s7595+  s7600 :: SWord8 = if s1067 then s7596 else s7599+  s7601 :: SWord1 = choose [0:0] s1115+  s7602 :: SBool = s14 /= s7601+  s7603 :: SWord8 = if s17 then s1123 else s1104+  s7604 :: SWord8 = s7603 >>> 1+  s7605 :: SWord8 = s19 | s7604+  s7606 :: SWord8 = s21 & s7604+  s7607 :: SWord8 = if s7602 then s7605 else s7606+  s7608 :: SWord1 = choose [0:0] s1126+  s7609 :: SBool = s14 /= s7608+  s7610 :: SWord8 = if s7609 then s7605 else s7606+  s7611 :: SWord8 = if s1108 then s7607 else s7610+  s7612 :: SWord8 = if s1046 then s7600 else s7611+  s7613 :: SWord1 = choose [0:0] s1169+  s7614 :: SBool = s14 /= s7613+  s7615 :: SWord8 = if s17 then s1179 else s1161+  s7616 :: SWord8 = s7615 >>> 1+  s7617 :: SWord8 = s19 | s7616+  s7618 :: SWord8 = s21 & s7616+  s7619 :: SWord8 = if s7614 then s7617 else s7618+  s7620 :: SWord1 = choose [0:0] s1184+  s7621 :: SBool = s14 /= s7620+  s7622 :: SWord8 = if s7621 then s7617 else s7618+  s7623 :: SWord8 = if s1165 then s7619 else s7622+  s7624 :: SWord1 = choose [0:0] s1207+  s7625 :: SBool = s14 /= s7624+  s7626 :: SWord8 = if s17 then s1215 else s1196+  s7627 :: SWord8 = s7626 >>> 1+  s7628 :: SWord8 = s19 | s7627+  s7629 :: SWord8 = s21 & s7627+  s7630 :: SWord8 = if s7625 then s7628 else s7629+  s7631 :: SWord1 = choose [0:0] s1218+  s7632 :: SBool = s14 /= s7631+  s7633 :: SWord8 = if s7632 then s7628 else s7629+  s7634 :: SWord8 = if s1200 then s7630 else s7633+  s7635 :: SWord8 = if s1143 then s7623 else s7634+  s7636 :: SWord8 = if s1025 then s7612 else s7635+  s7637 :: SWord1 = choose [0:0] s1283+  s7638 :: SBool = s14 /= s7637+  s7639 :: SWord8 = if s17 then s1293 else s1275+  s7640 :: SWord8 = s7639 >>> 1+  s7641 :: SWord8 = s19 | s7640+  s7642 :: SWord8 = s21 & s7640+  s7643 :: SWord8 = if s7638 then s7641 else s7642+  s7644 :: SWord1 = choose [0:0] s1300+  s7645 :: SBool = s14 /= s7644+  s7646 :: SWord8 = if s7645 then s7641 else s7642+  s7647 :: SWord8 = if s1279 then s7643 else s7646+  s7648 :: SWord1 = choose [0:0] s1323+  s7649 :: SBool = s14 /= s7648+  s7650 :: SWord8 = if s17 then s1331 else s1312+  s7651 :: SWord8 = s7650 >>> 1+  s7652 :: SWord8 = s19 | s7651+  s7653 :: SWord8 = s21 & s7651+  s7654 :: SWord8 = if s7649 then s7652 else s7653+  s7655 :: SWord1 = choose [0:0] s1334+  s7656 :: SBool = s14 /= s7655+  s7657 :: SWord8 = if s7656 then s7652 else s7653+  s7658 :: SWord8 = if s1316 then s7654 else s7657+  s7659 :: SWord8 = if s1258 then s7647 else s7658+  s7660 :: SWord1 = choose [0:0] s1377+  s7661 :: SBool = s14 /= s7660+  s7662 :: SWord8 = if s17 then s1387 else s1369+  s7663 :: SWord8 = s7662 >>> 1+  s7664 :: SWord8 = s19 | s7663+  s7665 :: SWord8 = s21 & s7663+  s7666 :: SWord8 = if s7661 then s7664 else s7665+  s7667 :: SWord1 = choose [0:0] s1392+  s7668 :: SBool = s14 /= s7667+  s7669 :: SWord8 = if s7668 then s7664 else s7665+  s7670 :: SWord8 = if s1373 then s7666 else s7669+  s7671 :: SWord1 = choose [0:0] s1415+  s7672 :: SBool = s14 /= s7671+  s7673 :: SWord8 = if s17 then s1423 else s1404+  s7674 :: SWord8 = s7673 >>> 1+  s7675 :: SWord8 = s19 | s7674+  s7676 :: SWord8 = s21 & s7674+  s7677 :: SWord8 = if s7672 then s7675 else s7676+  s7678 :: SWord1 = choose [0:0] s1426+  s7679 :: SBool = s14 /= s7678+  s7680 :: SWord8 = if s7679 then s7675 else s7676+  s7681 :: SWord8 = if s1408 then s7677 else s7680+  s7682 :: SWord8 = if s1351 then s7670 else s7681+  s7683 :: SWord8 = if s1236 then s7659 else s7682+  s7684 :: SWord8 = if s1004 then s7636 else s7683+  s7685 :: SWord1 = choose [0:0] s1513+  s7686 :: SBool = s14 /= s7685+  s7687 :: SWord8 = if s17 then s1523 else s1505+  s7688 :: SWord8 = s7687 >>> 1+  s7689 :: SWord8 = s19 | s7688+  s7690 :: SWord8 = s21 & s7688+  s7691 :: SWord8 = if s7686 then s7689 else s7690+  s7692 :: SWord1 = choose [0:0] s1532+  s7693 :: SBool = s14 /= s7692+  s7694 :: SWord8 = if s7693 then s7689 else s7690+  s7695 :: SWord8 = if s1509 then s7691 else s7694+  s7696 :: SWord1 = choose [0:0] s1555+  s7697 :: SBool = s14 /= s7696+  s7698 :: SWord8 = if s17 then s1563 else s1544+  s7699 :: SWord8 = s7698 >>> 1+  s7700 :: SWord8 = s19 | s7699+  s7701 :: SWord8 = s21 & s7699+  s7702 :: SWord8 = if s7697 then s7700 else s7701+  s7703 :: SWord1 = choose [0:0] s1566+  s7704 :: SBool = s14 /= s7703+  s7705 :: SWord8 = if s7704 then s7700 else s7701+  s7706 :: SWord8 = if s1548 then s7702 else s7705+  s7707 :: SWord8 = if s1488 then s7695 else s7706+  s7708 :: SWord1 = choose [0:0] s1609+  s7709 :: SBool = s14 /= s7708+  s7710 :: SWord8 = if s17 then s1619 else s1601+  s7711 :: SWord8 = s7710 >>> 1+  s7712 :: SWord8 = s19 | s7711+  s7713 :: SWord8 = s21 & s7711+  s7714 :: SWord8 = if s7709 then s7712 else s7713+  s7715 :: SWord1 = choose [0:0] s1624+  s7716 :: SBool = s14 /= s7715+  s7717 :: SWord8 = if s7716 then s7712 else s7713+  s7718 :: SWord8 = if s1605 then s7714 else s7717+  s7719 :: SWord1 = choose [0:0] s1647+  s7720 :: SBool = s14 /= s7719+  s7721 :: SWord8 = if s17 then s1655 else s1636+  s7722 :: SWord8 = s7721 >>> 1+  s7723 :: SWord8 = s19 | s7722+  s7724 :: SWord8 = s21 & s7722+  s7725 :: SWord8 = if s7720 then s7723 else s7724+  s7726 :: SWord1 = choose [0:0] s1658+  s7727 :: SBool = s14 /= s7726+  s7728 :: SWord8 = if s7727 then s7723 else s7724+  s7729 :: SWord8 = if s1640 then s7725 else s7728+  s7730 :: SWord8 = if s1583 then s7718 else s7729+  s7731 :: SWord8 = if s1467 then s7707 else s7730+  s7732 :: SWord1 = choose [0:0] s1723+  s7733 :: SBool = s14 /= s7732+  s7734 :: SWord8 = if s17 then s1733 else s1715+  s7735 :: SWord8 = s7734 >>> 1+  s7736 :: SWord8 = s19 | s7735+  s7737 :: SWord8 = s21 & s7735+  s7738 :: SWord8 = if s7733 then s7736 else s7737+  s7739 :: SWord1 = choose [0:0] s1740+  s7740 :: SBool = s14 /= s7739+  s7741 :: SWord8 = if s7740 then s7736 else s7737+  s7742 :: SWord8 = if s1719 then s7738 else s7741+  s7743 :: SWord1 = choose [0:0] s1763+  s7744 :: SBool = s14 /= s7743+  s7745 :: SWord8 = if s17 then s1771 else s1752+  s7746 :: SWord8 = s7745 >>> 1+  s7747 :: SWord8 = s19 | s7746+  s7748 :: SWord8 = s21 & s7746+  s7749 :: SWord8 = if s7744 then s7747 else s7748+  s7750 :: SWord1 = choose [0:0] s1774+  s7751 :: SBool = s14 /= s7750+  s7752 :: SWord8 = if s7751 then s7747 else s7748+  s7753 :: SWord8 = if s1756 then s7749 else s7752+  s7754 :: SWord8 = if s1698 then s7742 else s7753+  s7755 :: SWord1 = choose [0:0] s1817+  s7756 :: SBool = s14 /= s7755+  s7757 :: SWord8 = if s17 then s1827 else s1809+  s7758 :: SWord8 = s7757 >>> 1+  s7759 :: SWord8 = s19 | s7758+  s7760 :: SWord8 = s21 & s7758+  s7761 :: SWord8 = if s7756 then s7759 else s7760+  s7762 :: SWord1 = choose [0:0] s1832+  s7763 :: SBool = s14 /= s7762+  s7764 :: SWord8 = if s7763 then s7759 else s7760+  s7765 :: SWord8 = if s1813 then s7761 else s7764+  s7766 :: SWord1 = choose [0:0] s1855+  s7767 :: SBool = s14 /= s7766+  s7768 :: SWord8 = if s17 then s1863 else s1844+  s7769 :: SWord8 = s7768 >>> 1+  s7770 :: SWord8 = s19 | s7769+  s7771 :: SWord8 = s21 & s7769+  s7772 :: SWord8 = if s7767 then s7770 else s7771+  s7773 :: SWord1 = choose [0:0] s1866+  s7774 :: SBool = s14 /= s7773+  s7775 :: SWord8 = if s7774 then s7770 else s7771+  s7776 :: SWord8 = if s1848 then s7772 else s7775+  s7777 :: SWord8 = if s1791 then s7765 else s7776+  s7778 :: SWord8 = if s1676 then s7754 else s7777+  s7779 :: SWord8 = if s1445 then s7731 else s7778+  s7780 :: SWord8 = if s982 then s7684 else s7779+  s7781 :: SWord8 = if s51 then s7589 else s7780+  s7782 :: SWord1 = choose [0:0] s1997+  s7783 :: SBool = s14 /= s7782+  s7784 :: SWord8 = if s17 then s2007 else s1989+  s7785 :: SWord8 = s7784 >>> 1+  s7786 :: SWord8 = s19 | s7785+  s7787 :: SWord8 = s21 & s7785+  s7788 :: SWord8 = if s7783 then s7786 else s7787+  s7789 :: SWord1 = choose [0:0] s2020+  s7790 :: SBool = s14 /= s7789+  s7791 :: SWord8 = if s7790 then s7786 else s7787+  s7792 :: SWord8 = if s1993 then s7788 else s7791+  s7793 :: SWord1 = choose [0:0] s2043+  s7794 :: SBool = s14 /= s7793+  s7795 :: SWord8 = if s17 then s2051 else s2032+  s7796 :: SWord8 = s7795 >>> 1+  s7797 :: SWord8 = s19 | s7796+  s7798 :: SWord8 = s21 & s7796+  s7799 :: SWord8 = if s7794 then s7797 else s7798+  s7800 :: SWord1 = choose [0:0] s2054+  s7801 :: SBool = s14 /= s7800+  s7802 :: SWord8 = if s7801 then s7797 else s7798+  s7803 :: SWord8 = if s2036 then s7799 else s7802+  s7804 :: SWord8 = if s1972 then s7792 else s7803+  s7805 :: SWord1 = choose [0:0] s2097+  s7806 :: SBool = s14 /= s7805+  s7807 :: SWord8 = if s17 then s2107 else s2089+  s7808 :: SWord8 = s7807 >>> 1+  s7809 :: SWord8 = s19 | s7808+  s7810 :: SWord8 = s21 & s7808+  s7811 :: SWord8 = if s7806 then s7809 else s7810+  s7812 :: SWord1 = choose [0:0] s2112+  s7813 :: SBool = s14 /= s7812+  s7814 :: SWord8 = if s7813 then s7809 else s7810+  s7815 :: SWord8 = if s2093 then s7811 else s7814+  s7816 :: SWord1 = choose [0:0] s2135+  s7817 :: SBool = s14 /= s7816+  s7818 :: SWord8 = if s17 then s2143 else s2124+  s7819 :: SWord8 = s7818 >>> 1+  s7820 :: SWord8 = s19 | s7819+  s7821 :: SWord8 = s21 & s7819+  s7822 :: SWord8 = if s7817 then s7820 else s7821+  s7823 :: SWord1 = choose [0:0] s2146+  s7824 :: SBool = s14 /= s7823+  s7825 :: SWord8 = if s7824 then s7820 else s7821+  s7826 :: SWord8 = if s2128 then s7822 else s7825+  s7827 :: SWord8 = if s2071 then s7815 else s7826+  s7828 :: SWord8 = if s1951 then s7804 else s7827+  s7829 :: SWord1 = choose [0:0] s2211+  s7830 :: SBool = s14 /= s7829+  s7831 :: SWord8 = if s17 then s2221 else s2203+  s7832 :: SWord8 = s7831 >>> 1+  s7833 :: SWord8 = s19 | s7832+  s7834 :: SWord8 = s21 & s7832+  s7835 :: SWord8 = if s7830 then s7833 else s7834+  s7836 :: SWord1 = choose [0:0] s2228+  s7837 :: SBool = s14 /= s7836+  s7838 :: SWord8 = if s7837 then s7833 else s7834+  s7839 :: SWord8 = if s2207 then s7835 else s7838+  s7840 :: SWord1 = choose [0:0] s2251+  s7841 :: SBool = s14 /= s7840+  s7842 :: SWord8 = if s17 then s2259 else s2240+  s7843 :: SWord8 = s7842 >>> 1+  s7844 :: SWord8 = s19 | s7843+  s7845 :: SWord8 = s21 & s7843+  s7846 :: SWord8 = if s7841 then s7844 else s7845+  s7847 :: SWord1 = choose [0:0] s2262+  s7848 :: SBool = s14 /= s7847+  s7849 :: SWord8 = if s7848 then s7844 else s7845+  s7850 :: SWord8 = if s2244 then s7846 else s7849+  s7851 :: SWord8 = if s2186 then s7839 else s7850+  s7852 :: SWord1 = choose [0:0] s2305+  s7853 :: SBool = s14 /= s7852+  s7854 :: SWord8 = if s17 then s2315 else s2297+  s7855 :: SWord8 = s7854 >>> 1+  s7856 :: SWord8 = s19 | s7855+  s7857 :: SWord8 = s21 & s7855+  s7858 :: SWord8 = if s7853 then s7856 else s7857+  s7859 :: SWord1 = choose [0:0] s2320+  s7860 :: SBool = s14 /= s7859+  s7861 :: SWord8 = if s7860 then s7856 else s7857+  s7862 :: SWord8 = if s2301 then s7858 else s7861+  s7863 :: SWord1 = choose [0:0] s2343+  s7864 :: SBool = s14 /= s7863+  s7865 :: SWord8 = if s17 then s2351 else s2332+  s7866 :: SWord8 = s7865 >>> 1+  s7867 :: SWord8 = s19 | s7866+  s7868 :: SWord8 = s21 & s7866+  s7869 :: SWord8 = if s7864 then s7867 else s7868+  s7870 :: SWord1 = choose [0:0] s2354+  s7871 :: SBool = s14 /= s7870+  s7872 :: SWord8 = if s7871 then s7867 else s7868+  s7873 :: SWord8 = if s2336 then s7869 else s7872+  s7874 :: SWord8 = if s2279 then s7862 else s7873+  s7875 :: SWord8 = if s2164 then s7851 else s7874+  s7876 :: SWord8 = if s1930 then s7828 else s7875+  s7877 :: SWord1 = choose [0:0] s2441+  s7878 :: SBool = s14 /= s7877+  s7879 :: SWord8 = if s17 then s2451 else s2433+  s7880 :: SWord8 = s7879 >>> 1+  s7881 :: SWord8 = s19 | s7880+  s7882 :: SWord8 = s21 & s7880+  s7883 :: SWord8 = if s7878 then s7881 else s7882+  s7884 :: SWord1 = choose [0:0] s2460+  s7885 :: SBool = s14 /= s7884+  s7886 :: SWord8 = if s7885 then s7881 else s7882+  s7887 :: SWord8 = if s2437 then s7883 else s7886+  s7888 :: SWord1 = choose [0:0] s2483+  s7889 :: SBool = s14 /= s7888+  s7890 :: SWord8 = if s17 then s2491 else s2472+  s7891 :: SWord8 = s7890 >>> 1+  s7892 :: SWord8 = s19 | s7891+  s7893 :: SWord8 = s21 & s7891+  s7894 :: SWord8 = if s7889 then s7892 else s7893+  s7895 :: SWord1 = choose [0:0] s2494+  s7896 :: SBool = s14 /= s7895+  s7897 :: SWord8 = if s7896 then s7892 else s7893+  s7898 :: SWord8 = if s2476 then s7894 else s7897+  s7899 :: SWord8 = if s2416 then s7887 else s7898+  s7900 :: SWord1 = choose [0:0] s2537+  s7901 :: SBool = s14 /= s7900+  s7902 :: SWord8 = if s17 then s2547 else s2529+  s7903 :: SWord8 = s7902 >>> 1+  s7904 :: SWord8 = s19 | s7903+  s7905 :: SWord8 = s21 & s7903+  s7906 :: SWord8 = if s7901 then s7904 else s7905+  s7907 :: SWord1 = choose [0:0] s2552+  s7908 :: SBool = s14 /= s7907+  s7909 :: SWord8 = if s7908 then s7904 else s7905+  s7910 :: SWord8 = if s2533 then s7906 else s7909+  s7911 :: SWord1 = choose [0:0] s2575+  s7912 :: SBool = s14 /= s7911+  s7913 :: SWord8 = if s17 then s2583 else s2564+  s7914 :: SWord8 = s7913 >>> 1+  s7915 :: SWord8 = s19 | s7914+  s7916 :: SWord8 = s21 & s7914+  s7917 :: SWord8 = if s7912 then s7915 else s7916+  s7918 :: SWord1 = choose [0:0] s2586+  s7919 :: SBool = s14 /= s7918+  s7920 :: SWord8 = if s7919 then s7915 else s7916+  s7921 :: SWord8 = if s2568 then s7917 else s7920+  s7922 :: SWord8 = if s2511 then s7910 else s7921+  s7923 :: SWord8 = if s2395 then s7899 else s7922+  s7924 :: SWord1 = choose [0:0] s2651+  s7925 :: SBool = s14 /= s7924+  s7926 :: SWord8 = if s17 then s2661 else s2643+  s7927 :: SWord8 = s7926 >>> 1+  s7928 :: SWord8 = s19 | s7927+  s7929 :: SWord8 = s21 & s7927+  s7930 :: SWord8 = if s7925 then s7928 else s7929+  s7931 :: SWord1 = choose [0:0] s2668+  s7932 :: SBool = s14 /= s7931+  s7933 :: SWord8 = if s7932 then s7928 else s7929+  s7934 :: SWord8 = if s2647 then s7930 else s7933+  s7935 :: SWord1 = choose [0:0] s2691+  s7936 :: SBool = s14 /= s7935+  s7937 :: SWord8 = if s17 then s2699 else s2680+  s7938 :: SWord8 = s7937 >>> 1+  s7939 :: SWord8 = s19 | s7938+  s7940 :: SWord8 = s21 & s7938+  s7941 :: SWord8 = if s7936 then s7939 else s7940+  s7942 :: SWord1 = choose [0:0] s2702+  s7943 :: SBool = s14 /= s7942+  s7944 :: SWord8 = if s7943 then s7939 else s7940+  s7945 :: SWord8 = if s2684 then s7941 else s7944+  s7946 :: SWord8 = if s2626 then s7934 else s7945+  s7947 :: SWord1 = choose [0:0] s2745+  s7948 :: SBool = s14 /= s7947+  s7949 :: SWord8 = if s17 then s2755 else s2737+  s7950 :: SWord8 = s7949 >>> 1+  s7951 :: SWord8 = s19 | s7950+  s7952 :: SWord8 = s21 & s7950+  s7953 :: SWord8 = if s7948 then s7951 else s7952+  s7954 :: SWord1 = choose [0:0] s2760+  s7955 :: SBool = s14 /= s7954+  s7956 :: SWord8 = if s7955 then s7951 else s7952+  s7957 :: SWord8 = if s2741 then s7953 else s7956+  s7958 :: SWord1 = choose [0:0] s2783+  s7959 :: SBool = s14 /= s7958+  s7960 :: SWord8 = if s17 then s2791 else s2772+  s7961 :: SWord8 = s7960 >>> 1+  s7962 :: SWord8 = s19 | s7961+  s7963 :: SWord8 = s21 & s7961+  s7964 :: SWord8 = if s7959 then s7962 else s7963+  s7965 :: SWord1 = choose [0:0] s2794+  s7966 :: SBool = s14 /= s7965+  s7967 :: SWord8 = if s7966 then s7962 else s7963+  s7968 :: SWord8 = if s2776 then s7964 else s7967+  s7969 :: SWord8 = if s2719 then s7957 else s7968+  s7970 :: SWord8 = if s2604 then s7946 else s7969+  s7971 :: SWord8 = if s2373 then s7923 else s7970+  s7972 :: SWord8 = if s1909 then s7876 else s7971+  s7973 :: SWord1 = choose [0:0] s2903+  s7974 :: SBool = s14 /= s7973+  s7975 :: SWord8 = if s17 then s2913 else s2895+  s7976 :: SWord8 = s7975 >>> 1+  s7977 :: SWord8 = s19 | s7976+  s7978 :: SWord8 = s21 & s7976+  s7979 :: SWord8 = if s7974 then s7977 else s7978+  s7980 :: SWord1 = choose [0:0] s2924+  s7981 :: SBool = s14 /= s7980+  s7982 :: SWord8 = if s7981 then s7977 else s7978+  s7983 :: SWord8 = if s2899 then s7979 else s7982+  s7984 :: SWord1 = choose [0:0] s2947+  s7985 :: SBool = s14 /= s7984+  s7986 :: SWord8 = if s17 then s2955 else s2936+  s7987 :: SWord8 = s7986 >>> 1+  s7988 :: SWord8 = s19 | s7987+  s7989 :: SWord8 = s21 & s7987+  s7990 :: SWord8 = if s7985 then s7988 else s7989+  s7991 :: SWord1 = choose [0:0] s2958+  s7992 :: SBool = s14 /= s7991+  s7993 :: SWord8 = if s7992 then s7988 else s7989+  s7994 :: SWord8 = if s2940 then s7990 else s7993+  s7995 :: SWord8 = if s2878 then s7983 else s7994+  s7996 :: SWord1 = choose [0:0] s3001+  s7997 :: SBool = s14 /= s7996+  s7998 :: SWord8 = if s17 then s3011 else s2993+  s7999 :: SWord8 = s7998 >>> 1+  s8000 :: SWord8 = s19 | s7999+  s8001 :: SWord8 = s21 & s7999+  s8002 :: SWord8 = if s7997 then s8000 else s8001+  s8003 :: SWord1 = choose [0:0] s3016+  s8004 :: SBool = s14 /= s8003+  s8005 :: SWord8 = if s8004 then s8000 else s8001+  s8006 :: SWord8 = if s2997 then s8002 else s8005+  s8007 :: SWord1 = choose [0:0] s3039+  s8008 :: SBool = s14 /= s8007+  s8009 :: SWord8 = if s17 then s3047 else s3028+  s8010 :: SWord8 = s8009 >>> 1+  s8011 :: SWord8 = s19 | s8010+  s8012 :: SWord8 = s21 & s8010+  s8013 :: SWord8 = if s8008 then s8011 else s8012+  s8014 :: SWord1 = choose [0:0] s3050+  s8015 :: SBool = s14 /= s8014+  s8016 :: SWord8 = if s8015 then s8011 else s8012+  s8017 :: SWord8 = if s3032 then s8013 else s8016+  s8018 :: SWord8 = if s2975 then s8006 else s8017+  s8019 :: SWord8 = if s2857 then s7995 else s8018+  s8020 :: SWord1 = choose [0:0] s3115+  s8021 :: SBool = s14 /= s8020+  s8022 :: SWord8 = if s17 then s3125 else s3107+  s8023 :: SWord8 = s8022 >>> 1+  s8024 :: SWord8 = s19 | s8023+  s8025 :: SWord8 = s21 & s8023+  s8026 :: SWord8 = if s8021 then s8024 else s8025+  s8027 :: SWord1 = choose [0:0] s3132+  s8028 :: SBool = s14 /= s8027+  s8029 :: SWord8 = if s8028 then s8024 else s8025+  s8030 :: SWord8 = if s3111 then s8026 else s8029+  s8031 :: SWord1 = choose [0:0] s3155+  s8032 :: SBool = s14 /= s8031+  s8033 :: SWord8 = if s17 then s3163 else s3144+  s8034 :: SWord8 = s8033 >>> 1+  s8035 :: SWord8 = s19 | s8034+  s8036 :: SWord8 = s21 & s8034+  s8037 :: SWord8 = if s8032 then s8035 else s8036+  s8038 :: SWord1 = choose [0:0] s3166+  s8039 :: SBool = s14 /= s8038+  s8040 :: SWord8 = if s8039 then s8035 else s8036+  s8041 :: SWord8 = if s3148 then s8037 else s8040+  s8042 :: SWord8 = if s3090 then s8030 else s8041+  s8043 :: SWord1 = choose [0:0] s3209+  s8044 :: SBool = s14 /= s8043+  s8045 :: SWord8 = if s17 then s3219 else s3201+  s8046 :: SWord8 = s8045 >>> 1+  s8047 :: SWord8 = s19 | s8046+  s8048 :: SWord8 = s21 & s8046+  s8049 :: SWord8 = if s8044 then s8047 else s8048+  s8050 :: SWord1 = choose [0:0] s3224+  s8051 :: SBool = s14 /= s8050+  s8052 :: SWord8 = if s8051 then s8047 else s8048+  s8053 :: SWord8 = if s3205 then s8049 else s8052+  s8054 :: SWord1 = choose [0:0] s3247+  s8055 :: SBool = s14 /= s8054+  s8056 :: SWord8 = if s17 then s3255 else s3236+  s8057 :: SWord8 = s8056 >>> 1+  s8058 :: SWord8 = s19 | s8057+  s8059 :: SWord8 = s21 & s8057+  s8060 :: SWord8 = if s8055 then s8058 else s8059+  s8061 :: SWord1 = choose [0:0] s3258+  s8062 :: SBool = s14 /= s8061+  s8063 :: SWord8 = if s8062 then s8058 else s8059+  s8064 :: SWord8 = if s3240 then s8060 else s8063+  s8065 :: SWord8 = if s3183 then s8053 else s8064+  s8066 :: SWord8 = if s3068 then s8042 else s8065+  s8067 :: SWord8 = if s2836 then s8019 else s8066+  s8068 :: SWord1 = choose [0:0] s3345+  s8069 :: SBool = s14 /= s8068+  s8070 :: SWord8 = if s17 then s3355 else s3337+  s8071 :: SWord8 = s8070 >>> 1+  s8072 :: SWord8 = s19 | s8071+  s8073 :: SWord8 = s21 & s8071+  s8074 :: SWord8 = if s8069 then s8072 else s8073+  s8075 :: SWord1 = choose [0:0] s3364+  s8076 :: SBool = s14 /= s8075+  s8077 :: SWord8 = if s8076 then s8072 else s8073+  s8078 :: SWord8 = if s3341 then s8074 else s8077+  s8079 :: SWord1 = choose [0:0] s3387+  s8080 :: SBool = s14 /= s8079+  s8081 :: SWord8 = if s17 then s3395 else s3376+  s8082 :: SWord8 = s8081 >>> 1+  s8083 :: SWord8 = s19 | s8082+  s8084 :: SWord8 = s21 & s8082+  s8085 :: SWord8 = if s8080 then s8083 else s8084+  s8086 :: SWord1 = choose [0:0] s3398+  s8087 :: SBool = s14 /= s8086+  s8088 :: SWord8 = if s8087 then s8083 else s8084+  s8089 :: SWord8 = if s3380 then s8085 else s8088+  s8090 :: SWord8 = if s3320 then s8078 else s8089+  s8091 :: SWord1 = choose [0:0] s3441+  s8092 :: SBool = s14 /= s8091+  s8093 :: SWord8 = if s17 then s3451 else s3433+  s8094 :: SWord8 = s8093 >>> 1+  s8095 :: SWord8 = s19 | s8094+  s8096 :: SWord8 = s21 & s8094+  s8097 :: SWord8 = if s8092 then s8095 else s8096+  s8098 :: SWord1 = choose [0:0] s3456+  s8099 :: SBool = s14 /= s8098+  s8100 :: SWord8 = if s8099 then s8095 else s8096+  s8101 :: SWord8 = if s3437 then s8097 else s8100+  s8102 :: SWord1 = choose [0:0] s3479+  s8103 :: SBool = s14 /= s8102+  s8104 :: SWord8 = if s17 then s3487 else s3468+  s8105 :: SWord8 = s8104 >>> 1+  s8106 :: SWord8 = s19 | s8105+  s8107 :: SWord8 = s21 & s8105+  s8108 :: SWord8 = if s8103 then s8106 else s8107+  s8109 :: SWord1 = choose [0:0] s3490+  s8110 :: SBool = s14 /= s8109+  s8111 :: SWord8 = if s8110 then s8106 else s8107+  s8112 :: SWord8 = if s3472 then s8108 else s8111+  s8113 :: SWord8 = if s3415 then s8101 else s8112+  s8114 :: SWord8 = if s3299 then s8090 else s8113+  s8115 :: SWord1 = choose [0:0] s3555+  s8116 :: SBool = s14 /= s8115+  s8117 :: SWord8 = if s17 then s3565 else s3547+  s8118 :: SWord8 = s8117 >>> 1+  s8119 :: SWord8 = s19 | s8118+  s8120 :: SWord8 = s21 & s8118+  s8121 :: SWord8 = if s8116 then s8119 else s8120+  s8122 :: SWord1 = choose [0:0] s3572+  s8123 :: SBool = s14 /= s8122+  s8124 :: SWord8 = if s8123 then s8119 else s8120+  s8125 :: SWord8 = if s3551 then s8121 else s8124+  s8126 :: SWord1 = choose [0:0] s3595+  s8127 :: SBool = s14 /= s8126+  s8128 :: SWord8 = if s17 then s3603 else s3584+  s8129 :: SWord8 = s8128 >>> 1+  s8130 :: SWord8 = s19 | s8129+  s8131 :: SWord8 = s21 & s8129+  s8132 :: SWord8 = if s8127 then s8130 else s8131+  s8133 :: SWord1 = choose [0:0] s3606+  s8134 :: SBool = s14 /= s8133+  s8135 :: SWord8 = if s8134 then s8130 else s8131+  s8136 :: SWord8 = if s3588 then s8132 else s8135+  s8137 :: SWord8 = if s3530 then s8125 else s8136+  s8138 :: SWord1 = choose [0:0] s3649+  s8139 :: SBool = s14 /= s8138+  s8140 :: SWord8 = if s17 then s3659 else s3641+  s8141 :: SWord8 = s8140 >>> 1+  s8142 :: SWord8 = s19 | s8141+  s8143 :: SWord8 = s21 & s8141+  s8144 :: SWord8 = if s8139 then s8142 else s8143+  s8145 :: SWord1 = choose [0:0] s3664+  s8146 :: SBool = s14 /= s8145+  s8147 :: SWord8 = if s8146 then s8142 else s8143+  s8148 :: SWord8 = if s3645 then s8144 else s8147+  s8149 :: SWord1 = choose [0:0] s3687+  s8150 :: SBool = s14 /= s8149+  s8151 :: SWord8 = if s17 then s3695 else s3676+  s8152 :: SWord8 = s8151 >>> 1+  s8153 :: SWord8 = s19 | s8152+  s8154 :: SWord8 = s21 & s8152+  s8155 :: SWord8 = if s8150 then s8153 else s8154+  s8156 :: SWord1 = choose [0:0] s3698+  s8157 :: SBool = s14 /= s8156+  s8158 :: SWord8 = if s8157 then s8153 else s8154+  s8159 :: SWord8 = if s3680 then s8155 else s8158+  s8160 :: SWord8 = if s3623 then s8148 else s8159+  s8161 :: SWord8 = if s3508 then s8137 else s8160+  s8162 :: SWord8 = if s3277 then s8114 else s8161+  s8163 :: SWord8 = if s2814 then s8067 else s8162+  s8164 :: SWord8 = if s1887 then s7972 else s8163+  s8165 :: SWord8 = if s33 then s7781 else s8164+  s8166 :: SWord1 = choose [0:0] s3846+  s8167 :: SBool = s14 /= s8166+  s8168 :: SWord8 = if s17 then s3856 else s3838+  s8169 :: SWord8 = s8168 >>> 1+  s8170 :: SWord8 = s19 | s8169+  s8171 :: SWord8 = s21 & s8169+  s8172 :: SWord8 = if s8167 then s8170 else s8171+  s8173 :: SWord1 = choose [0:0] s3871+  s8174 :: SBool = s14 /= s8173+  s8175 :: SWord8 = if s8174 then s8170 else s8171+  s8176 :: SWord8 = if s3842 then s8172 else s8175+  s8177 :: SWord1 = choose [0:0] s3894+  s8178 :: SBool = s14 /= s8177+  s8179 :: SWord8 = if s17 then s3902 else s3883+  s8180 :: SWord8 = s8179 >>> 1+  s8181 :: SWord8 = s19 | s8180+  s8182 :: SWord8 = s21 & s8180+  s8183 :: SWord8 = if s8178 then s8181 else s8182+  s8184 :: SWord1 = choose [0:0] s3905+  s8185 :: SBool = s14 /= s8184+  s8186 :: SWord8 = if s8185 then s8181 else s8182+  s8187 :: SWord8 = if s3887 then s8183 else s8186+  s8188 :: SWord8 = if s3821 then s8176 else s8187+  s8189 :: SWord1 = choose [0:0] s3948+  s8190 :: SBool = s14 /= s8189+  s8191 :: SWord8 = if s17 then s3958 else s3940+  s8192 :: SWord8 = s8191 >>> 1+  s8193 :: SWord8 = s19 | s8192+  s8194 :: SWord8 = s21 & s8192+  s8195 :: SWord8 = if s8190 then s8193 else s8194+  s8196 :: SWord1 = choose [0:0] s3963+  s8197 :: SBool = s14 /= s8196+  s8198 :: SWord8 = if s8197 then s8193 else s8194+  s8199 :: SWord8 = if s3944 then s8195 else s8198+  s8200 :: SWord1 = choose [0:0] s3986+  s8201 :: SBool = s14 /= s8200+  s8202 :: SWord8 = if s17 then s3994 else s3975+  s8203 :: SWord8 = s8202 >>> 1+  s8204 :: SWord8 = s19 | s8203+  s8205 :: SWord8 = s21 & s8203+  s8206 :: SWord8 = if s8201 then s8204 else s8205+  s8207 :: SWord1 = choose [0:0] s3997+  s8208 :: SBool = s14 /= s8207+  s8209 :: SWord8 = if s8208 then s8204 else s8205+  s8210 :: SWord8 = if s3979 then s8206 else s8209+  s8211 :: SWord8 = if s3922 then s8199 else s8210+  s8212 :: SWord8 = if s3800 then s8188 else s8211+  s8213 :: SWord1 = choose [0:0] s4062+  s8214 :: SBool = s14 /= s8213+  s8215 :: SWord8 = if s17 then s4072 else s4054+  s8216 :: SWord8 = s8215 >>> 1+  s8217 :: SWord8 = s19 | s8216+  s8218 :: SWord8 = s21 & s8216+  s8219 :: SWord8 = if s8214 then s8217 else s8218+  s8220 :: SWord1 = choose [0:0] s4079+  s8221 :: SBool = s14 /= s8220+  s8222 :: SWord8 = if s8221 then s8217 else s8218+  s8223 :: SWord8 = if s4058 then s8219 else s8222+  s8224 :: SWord1 = choose [0:0] s4102+  s8225 :: SBool = s14 /= s8224+  s8226 :: SWord8 = if s17 then s4110 else s4091+  s8227 :: SWord8 = s8226 >>> 1+  s8228 :: SWord8 = s19 | s8227+  s8229 :: SWord8 = s21 & s8227+  s8230 :: SWord8 = if s8225 then s8228 else s8229+  s8231 :: SWord1 = choose [0:0] s4113+  s8232 :: SBool = s14 /= s8231+  s8233 :: SWord8 = if s8232 then s8228 else s8229+  s8234 :: SWord8 = if s4095 then s8230 else s8233+  s8235 :: SWord8 = if s4037 then s8223 else s8234+  s8236 :: SWord1 = choose [0:0] s4156+  s8237 :: SBool = s14 /= s8236+  s8238 :: SWord8 = if s17 then s4166 else s4148+  s8239 :: SWord8 = s8238 >>> 1+  s8240 :: SWord8 = s19 | s8239+  s8241 :: SWord8 = s21 & s8239+  s8242 :: SWord8 = if s8237 then s8240 else s8241+  s8243 :: SWord1 = choose [0:0] s4171+  s8244 :: SBool = s14 /= s8243+  s8245 :: SWord8 = if s8244 then s8240 else s8241+  s8246 :: SWord8 = if s4152 then s8242 else s8245+  s8247 :: SWord1 = choose [0:0] s4194+  s8248 :: SBool = s14 /= s8247+  s8249 :: SWord8 = if s17 then s4202 else s4183+  s8250 :: SWord8 = s8249 >>> 1+  s8251 :: SWord8 = s19 | s8250+  s8252 :: SWord8 = s21 & s8250+  s8253 :: SWord8 = if s8248 then s8251 else s8252+  s8254 :: SWord1 = choose [0:0] s4205+  s8255 :: SBool = s14 /= s8254+  s8256 :: SWord8 = if s8255 then s8251 else s8252+  s8257 :: SWord8 = if s4187 then s8253 else s8256+  s8258 :: SWord8 = if s4130 then s8246 else s8257+  s8259 :: SWord8 = if s4015 then s8235 else s8258+  s8260 :: SWord8 = if s3779 then s8212 else s8259+  s8261 :: SWord1 = choose [0:0] s4292+  s8262 :: SBool = s14 /= s8261+  s8263 :: SWord8 = if s17 then s4302 else s4284+  s8264 :: SWord8 = s8263 >>> 1+  s8265 :: SWord8 = s19 | s8264+  s8266 :: SWord8 = s21 & s8264+  s8267 :: SWord8 = if s8262 then s8265 else s8266+  s8268 :: SWord1 = choose [0:0] s4311+  s8269 :: SBool = s14 /= s8268+  s8270 :: SWord8 = if s8269 then s8265 else s8266+  s8271 :: SWord8 = if s4288 then s8267 else s8270+  s8272 :: SWord1 = choose [0:0] s4334+  s8273 :: SBool = s14 /= s8272+  s8274 :: SWord8 = if s17 then s4342 else s4323+  s8275 :: SWord8 = s8274 >>> 1+  s8276 :: SWord8 = s19 | s8275+  s8277 :: SWord8 = s21 & s8275+  s8278 :: SWord8 = if s8273 then s8276 else s8277+  s8279 :: SWord1 = choose [0:0] s4345+  s8280 :: SBool = s14 /= s8279+  s8281 :: SWord8 = if s8280 then s8276 else s8277+  s8282 :: SWord8 = if s4327 then s8278 else s8281+  s8283 :: SWord8 = if s4267 then s8271 else s8282+  s8284 :: SWord1 = choose [0:0] s4388+  s8285 :: SBool = s14 /= s8284+  s8286 :: SWord8 = if s17 then s4398 else s4380+  s8287 :: SWord8 = s8286 >>> 1+  s8288 :: SWord8 = s19 | s8287+  s8289 :: SWord8 = s21 & s8287+  s8290 :: SWord8 = if s8285 then s8288 else s8289+  s8291 :: SWord1 = choose [0:0] s4403+  s8292 :: SBool = s14 /= s8291+  s8293 :: SWord8 = if s8292 then s8288 else s8289+  s8294 :: SWord8 = if s4384 then s8290 else s8293+  s8295 :: SWord1 = choose [0:0] s4426+  s8296 :: SBool = s14 /= s8295+  s8297 :: SWord8 = if s17 then s4434 else s4415+  s8298 :: SWord8 = s8297 >>> 1+  s8299 :: SWord8 = s19 | s8298+  s8300 :: SWord8 = s21 & s8298+  s8301 :: SWord8 = if s8296 then s8299 else s8300+  s8302 :: SWord1 = choose [0:0] s4437+  s8303 :: SBool = s14 /= s8302+  s8304 :: SWord8 = if s8303 then s8299 else s8300+  s8305 :: SWord8 = if s4419 then s8301 else s8304+  s8306 :: SWord8 = if s4362 then s8294 else s8305+  s8307 :: SWord8 = if s4246 then s8283 else s8306+  s8308 :: SWord1 = choose [0:0] s4502+  s8309 :: SBool = s14 /= s8308+  s8310 :: SWord8 = if s17 then s4512 else s4494+  s8311 :: SWord8 = s8310 >>> 1+  s8312 :: SWord8 = s19 | s8311+  s8313 :: SWord8 = s21 & s8311+  s8314 :: SWord8 = if s8309 then s8312 else s8313+  s8315 :: SWord1 = choose [0:0] s4519+  s8316 :: SBool = s14 /= s8315+  s8317 :: SWord8 = if s8316 then s8312 else s8313+  s8318 :: SWord8 = if s4498 then s8314 else s8317+  s8319 :: SWord1 = choose [0:0] s4542+  s8320 :: SBool = s14 /= s8319+  s8321 :: SWord8 = if s17 then s4550 else s4531+  s8322 :: SWord8 = s8321 >>> 1+  s8323 :: SWord8 = s19 | s8322+  s8324 :: SWord8 = s21 & s8322+  s8325 :: SWord8 = if s8320 then s8323 else s8324+  s8326 :: SWord1 = choose [0:0] s4553+  s8327 :: SBool = s14 /= s8326+  s8328 :: SWord8 = if s8327 then s8323 else s8324+  s8329 :: SWord8 = if s4535 then s8325 else s8328+  s8330 :: SWord8 = if s4477 then s8318 else s8329+  s8331 :: SWord1 = choose [0:0] s4596+  s8332 :: SBool = s14 /= s8331+  s8333 :: SWord8 = if s17 then s4606 else s4588+  s8334 :: SWord8 = s8333 >>> 1+  s8335 :: SWord8 = s19 | s8334+  s8336 :: SWord8 = s21 & s8334+  s8337 :: SWord8 = if s8332 then s8335 else s8336+  s8338 :: SWord1 = choose [0:0] s4611+  s8339 :: SBool = s14 /= s8338+  s8340 :: SWord8 = if s8339 then s8335 else s8336+  s8341 :: SWord8 = if s4592 then s8337 else s8340+  s8342 :: SWord1 = choose [0:0] s4634+  s8343 :: SBool = s14 /= s8342+  s8344 :: SWord8 = if s17 then s4642 else s4623+  s8345 :: SWord8 = s8344 >>> 1+  s8346 :: SWord8 = s19 | s8345+  s8347 :: SWord8 = s21 & s8345+  s8348 :: SWord8 = if s8343 then s8346 else s8347+  s8349 :: SWord1 = choose [0:0] s4645+  s8350 :: SBool = s14 /= s8349+  s8351 :: SWord8 = if s8350 then s8346 else s8347+  s8352 :: SWord8 = if s4627 then s8348 else s8351+  s8353 :: SWord8 = if s4570 then s8341 else s8352+  s8354 :: SWord8 = if s4455 then s8330 else s8353+  s8355 :: SWord8 = if s4224 then s8307 else s8354+  s8356 :: SWord8 = if s3758 then s8260 else s8355+  s8357 :: SWord1 = choose [0:0] s4754+  s8358 :: SBool = s14 /= s8357+  s8359 :: SWord8 = if s17 then s4764 else s4746+  s8360 :: SWord8 = s8359 >>> 1+  s8361 :: SWord8 = s19 | s8360+  s8362 :: SWord8 = s21 & s8360+  s8363 :: SWord8 = if s8358 then s8361 else s8362+  s8364 :: SWord1 = choose [0:0] s4775+  s8365 :: SBool = s14 /= s8364+  s8366 :: SWord8 = if s8365 then s8361 else s8362+  s8367 :: SWord8 = if s4750 then s8363 else s8366+  s8368 :: SWord1 = choose [0:0] s4798+  s8369 :: SBool = s14 /= s8368+  s8370 :: SWord8 = if s17 then s4806 else s4787+  s8371 :: SWord8 = s8370 >>> 1+  s8372 :: SWord8 = s19 | s8371+  s8373 :: SWord8 = s21 & s8371+  s8374 :: SWord8 = if s8369 then s8372 else s8373+  s8375 :: SWord1 = choose [0:0] s4809+  s8376 :: SBool = s14 /= s8375+  s8377 :: SWord8 = if s8376 then s8372 else s8373+  s8378 :: SWord8 = if s4791 then s8374 else s8377+  s8379 :: SWord8 = if s4729 then s8367 else s8378+  s8380 :: SWord1 = choose [0:0] s4852+  s8381 :: SBool = s14 /= s8380+  s8382 :: SWord8 = if s17 then s4862 else s4844+  s8383 :: SWord8 = s8382 >>> 1+  s8384 :: SWord8 = s19 | s8383+  s8385 :: SWord8 = s21 & s8383+  s8386 :: SWord8 = if s8381 then s8384 else s8385+  s8387 :: SWord1 = choose [0:0] s4867+  s8388 :: SBool = s14 /= s8387+  s8389 :: SWord8 = if s8388 then s8384 else s8385+  s8390 :: SWord8 = if s4848 then s8386 else s8389+  s8391 :: SWord1 = choose [0:0] s4890+  s8392 :: SBool = s14 /= s8391+  s8393 :: SWord8 = if s17 then s4898 else s4879+  s8394 :: SWord8 = s8393 >>> 1+  s8395 :: SWord8 = s19 | s8394+  s8396 :: SWord8 = s21 & s8394+  s8397 :: SWord8 = if s8392 then s8395 else s8396+  s8398 :: SWord1 = choose [0:0] s4901+  s8399 :: SBool = s14 /= s8398+  s8400 :: SWord8 = if s8399 then s8395 else s8396+  s8401 :: SWord8 = if s4883 then s8397 else s8400+  s8402 :: SWord8 = if s4826 then s8390 else s8401+  s8403 :: SWord8 = if s4708 then s8379 else s8402+  s8404 :: SWord1 = choose [0:0] s4966+  s8405 :: SBool = s14 /= s8404+  s8406 :: SWord8 = if s17 then s4976 else s4958+  s8407 :: SWord8 = s8406 >>> 1+  s8408 :: SWord8 = s19 | s8407+  s8409 :: SWord8 = s21 & s8407+  s8410 :: SWord8 = if s8405 then s8408 else s8409+  s8411 :: SWord1 = choose [0:0] s4983+  s8412 :: SBool = s14 /= s8411+  s8413 :: SWord8 = if s8412 then s8408 else s8409+  s8414 :: SWord8 = if s4962 then s8410 else s8413+  s8415 :: SWord1 = choose [0:0] s5006+  s8416 :: SBool = s14 /= s8415+  s8417 :: SWord8 = if s17 then s5014 else s4995+  s8418 :: SWord8 = s8417 >>> 1+  s8419 :: SWord8 = s19 | s8418+  s8420 :: SWord8 = s21 & s8418+  s8421 :: SWord8 = if s8416 then s8419 else s8420+  s8422 :: SWord1 = choose [0:0] s5017+  s8423 :: SBool = s14 /= s8422+  s8424 :: SWord8 = if s8423 then s8419 else s8420+  s8425 :: SWord8 = if s4999 then s8421 else s8424+  s8426 :: SWord8 = if s4941 then s8414 else s8425+  s8427 :: SWord1 = choose [0:0] s5060+  s8428 :: SBool = s14 /= s8427+  s8429 :: SWord8 = if s17 then s5070 else s5052+  s8430 :: SWord8 = s8429 >>> 1+  s8431 :: SWord8 = s19 | s8430+  s8432 :: SWord8 = s21 & s8430+  s8433 :: SWord8 = if s8428 then s8431 else s8432+  s8434 :: SWord1 = choose [0:0] s5075+  s8435 :: SBool = s14 /= s8434+  s8436 :: SWord8 = if s8435 then s8431 else s8432+  s8437 :: SWord8 = if s5056 then s8433 else s8436+  s8438 :: SWord1 = choose [0:0] s5098+  s8439 :: SBool = s14 /= s8438+  s8440 :: SWord8 = if s17 then s5106 else s5087+  s8441 :: SWord8 = s8440 >>> 1+  s8442 :: SWord8 = s19 | s8441+  s8443 :: SWord8 = s21 & s8441+  s8444 :: SWord8 = if s8439 then s8442 else s8443+  s8445 :: SWord1 = choose [0:0] s5109+  s8446 :: SBool = s14 /= s8445+  s8447 :: SWord8 = if s8446 then s8442 else s8443+  s8448 :: SWord8 = if s5091 then s8444 else s8447+  s8449 :: SWord8 = if s5034 then s8437 else s8448+  s8450 :: SWord8 = if s4919 then s8426 else s8449+  s8451 :: SWord8 = if s4687 then s8403 else s8450+  s8452 :: SWord1 = choose [0:0] s5196+  s8453 :: SBool = s14 /= s8452+  s8454 :: SWord8 = if s17 then s5206 else s5188+  s8455 :: SWord8 = s8454 >>> 1+  s8456 :: SWord8 = s19 | s8455+  s8457 :: SWord8 = s21 & s8455+  s8458 :: SWord8 = if s8453 then s8456 else s8457+  s8459 :: SWord1 = choose [0:0] s5215+  s8460 :: SBool = s14 /= s8459+  s8461 :: SWord8 = if s8460 then s8456 else s8457+  s8462 :: SWord8 = if s5192 then s8458 else s8461+  s8463 :: SWord1 = choose [0:0] s5238+  s8464 :: SBool = s14 /= s8463+  s8465 :: SWord8 = if s17 then s5246 else s5227+  s8466 :: SWord8 = s8465 >>> 1+  s8467 :: SWord8 = s19 | s8466+  s8468 :: SWord8 = s21 & s8466+  s8469 :: SWord8 = if s8464 then s8467 else s8468+  s8470 :: SWord1 = choose [0:0] s5249+  s8471 :: SBool = s14 /= s8470+  s8472 :: SWord8 = if s8471 then s8467 else s8468+  s8473 :: SWord8 = if s5231 then s8469 else s8472+  s8474 :: SWord8 = if s5171 then s8462 else s8473+  s8475 :: SWord1 = choose [0:0] s5292+  s8476 :: SBool = s14 /= s8475+  s8477 :: SWord8 = if s17 then s5302 else s5284+  s8478 :: SWord8 = s8477 >>> 1+  s8479 :: SWord8 = s19 | s8478+  s8480 :: SWord8 = s21 & s8478+  s8481 :: SWord8 = if s8476 then s8479 else s8480+  s8482 :: SWord1 = choose [0:0] s5307+  s8483 :: SBool = s14 /= s8482+  s8484 :: SWord8 = if s8483 then s8479 else s8480+  s8485 :: SWord8 = if s5288 then s8481 else s8484+  s8486 :: SWord1 = choose [0:0] s5330+  s8487 :: SBool = s14 /= s8486+  s8488 :: SWord8 = if s17 then s5338 else s5319+  s8489 :: SWord8 = s8488 >>> 1+  s8490 :: SWord8 = s19 | s8489+  s8491 :: SWord8 = s21 & s8489+  s8492 :: SWord8 = if s8487 then s8490 else s8491+  s8493 :: SWord1 = choose [0:0] s5341+  s8494 :: SBool = s14 /= s8493+  s8495 :: SWord8 = if s8494 then s8490 else s8491+  s8496 :: SWord8 = if s5323 then s8492 else s8495+  s8497 :: SWord8 = if s5266 then s8485 else s8496+  s8498 :: SWord8 = if s5150 then s8474 else s8497+  s8499 :: SWord1 = choose [0:0] s5406+  s8500 :: SBool = s14 /= s8499+  s8501 :: SWord8 = if s17 then s5416 else s5398+  s8502 :: SWord8 = s8501 >>> 1+  s8503 :: SWord8 = s19 | s8502+  s8504 :: SWord8 = s21 & s8502+  s8505 :: SWord8 = if s8500 then s8503 else s8504+  s8506 :: SWord1 = choose [0:0] s5423+  s8507 :: SBool = s14 /= s8506+  s8508 :: SWord8 = if s8507 then s8503 else s8504+  s8509 :: SWord8 = if s5402 then s8505 else s8508+  s8510 :: SWord1 = choose [0:0] s5446+  s8511 :: SBool = s14 /= s8510+  s8512 :: SWord8 = if s17 then s5454 else s5435+  s8513 :: SWord8 = s8512 >>> 1+  s8514 :: SWord8 = s19 | s8513+  s8515 :: SWord8 = s21 & s8513+  s8516 :: SWord8 = if s8511 then s8514 else s8515+  s8517 :: SWord1 = choose [0:0] s5457+  s8518 :: SBool = s14 /= s8517+  s8519 :: SWord8 = if s8518 then s8514 else s8515+  s8520 :: SWord8 = if s5439 then s8516 else s8519+  s8521 :: SWord8 = if s5381 then s8509 else s8520+  s8522 :: SWord1 = choose [0:0] s5500+  s8523 :: SBool = s14 /= s8522+  s8524 :: SWord8 = if s17 then s5510 else s5492+  s8525 :: SWord8 = s8524 >>> 1+  s8526 :: SWord8 = s19 | s8525+  s8527 :: SWord8 = s21 & s8525+  s8528 :: SWord8 = if s8523 then s8526 else s8527+  s8529 :: SWord1 = choose [0:0] s5515+  s8530 :: SBool = s14 /= s8529+  s8531 :: SWord8 = if s8530 then s8526 else s8527+  s8532 :: SWord8 = if s5496 then s8528 else s8531+  s8533 :: SWord1 = choose [0:0] s5538+  s8534 :: SBool = s14 /= s8533+  s8535 :: SWord8 = if s17 then s5546 else s5527+  s8536 :: SWord8 = s8535 >>> 1+  s8537 :: SWord8 = s19 | s8536+  s8538 :: SWord8 = s21 & s8536+  s8539 :: SWord8 = if s8534 then s8537 else s8538+  s8540 :: SWord1 = choose [0:0] s5549+  s8541 :: SBool = s14 /= s8540+  s8542 :: SWord8 = if s8541 then s8537 else s8538+  s8543 :: SWord8 = if s5531 then s8539 else s8542+  s8544 :: SWord8 = if s5474 then s8532 else s8543+  s8545 :: SWord8 = if s5359 then s8521 else s8544+  s8546 :: SWord8 = if s5128 then s8498 else s8545+  s8547 :: SWord8 = if s4665 then s8451 else s8546+  s8548 :: SWord8 = if s3737 then s8356 else s8547+  s8549 :: SWord1 = choose [0:0] s5680+  s8550 :: SBool = s14 /= s8549+  s8551 :: SWord8 = if s17 then s5690 else s5672+  s8552 :: SWord8 = s8551 >>> 1+  s8553 :: SWord8 = s19 | s8552+  s8554 :: SWord8 = s21 & s8552+  s8555 :: SWord8 = if s8550 then s8553 else s8554+  s8556 :: SWord1 = choose [0:0] s5703+  s8557 :: SBool = s14 /= s8556+  s8558 :: SWord8 = if s8557 then s8553 else s8554+  s8559 :: SWord8 = if s5676 then s8555 else s8558+  s8560 :: SWord1 = choose [0:0] s5726+  s8561 :: SBool = s14 /= s8560+  s8562 :: SWord8 = if s17 then s5734 else s5715+  s8563 :: SWord8 = s8562 >>> 1+  s8564 :: SWord8 = s19 | s8563+  s8565 :: SWord8 = s21 & s8563+  s8566 :: SWord8 = if s8561 then s8564 else s8565+  s8567 :: SWord1 = choose [0:0] s5737+  s8568 :: SBool = s14 /= s8567+  s8569 :: SWord8 = if s8568 then s8564 else s8565+  s8570 :: SWord8 = if s5719 then s8566 else s8569+  s8571 :: SWord8 = if s5655 then s8559 else s8570+  s8572 :: SWord1 = choose [0:0] s5780+  s8573 :: SBool = s14 /= s8572+  s8574 :: SWord8 = if s17 then s5790 else s5772+  s8575 :: SWord8 = s8574 >>> 1+  s8576 :: SWord8 = s19 | s8575+  s8577 :: SWord8 = s21 & s8575+  s8578 :: SWord8 = if s8573 then s8576 else s8577+  s8579 :: SWord1 = choose [0:0] s5795+  s8580 :: SBool = s14 /= s8579+  s8581 :: SWord8 = if s8580 then s8576 else s8577+  s8582 :: SWord8 = if s5776 then s8578 else s8581+  s8583 :: SWord1 = choose [0:0] s5818+  s8584 :: SBool = s14 /= s8583+  s8585 :: SWord8 = if s17 then s5826 else s5807+  s8586 :: SWord8 = s8585 >>> 1+  s8587 :: SWord8 = s19 | s8586+  s8588 :: SWord8 = s21 & s8586+  s8589 :: SWord8 = if s8584 then s8587 else s8588+  s8590 :: SWord1 = choose [0:0] s5829+  s8591 :: SBool = s14 /= s8590+  s8592 :: SWord8 = if s8591 then s8587 else s8588+  s8593 :: SWord8 = if s5811 then s8589 else s8592+  s8594 :: SWord8 = if s5754 then s8582 else s8593+  s8595 :: SWord8 = if s5634 then s8571 else s8594+  s8596 :: SWord1 = choose [0:0] s5894+  s8597 :: SBool = s14 /= s8596+  s8598 :: SWord8 = if s17 then s5904 else s5886+  s8599 :: SWord8 = s8598 >>> 1+  s8600 :: SWord8 = s19 | s8599+  s8601 :: SWord8 = s21 & s8599+  s8602 :: SWord8 = if s8597 then s8600 else s8601+  s8603 :: SWord1 = choose [0:0] s5911+  s8604 :: SBool = s14 /= s8603+  s8605 :: SWord8 = if s8604 then s8600 else s8601+  s8606 :: SWord8 = if s5890 then s8602 else s8605+  s8607 :: SWord1 = choose [0:0] s5934+  s8608 :: SBool = s14 /= s8607+  s8609 :: SWord8 = if s17 then s5942 else s5923+  s8610 :: SWord8 = s8609 >>> 1+  s8611 :: SWord8 = s19 | s8610+  s8612 :: SWord8 = s21 & s8610+  s8613 :: SWord8 = if s8608 then s8611 else s8612+  s8614 :: SWord1 = choose [0:0] s5945+  s8615 :: SBool = s14 /= s8614+  s8616 :: SWord8 = if s8615 then s8611 else s8612+  s8617 :: SWord8 = if s5927 then s8613 else s8616+  s8618 :: SWord8 = if s5869 then s8606 else s8617+  s8619 :: SWord1 = choose [0:0] s5988+  s8620 :: SBool = s14 /= s8619+  s8621 :: SWord8 = if s17 then s5998 else s5980+  s8622 :: SWord8 = s8621 >>> 1+  s8623 :: SWord8 = s19 | s8622+  s8624 :: SWord8 = s21 & s8622+  s8625 :: SWord8 = if s8620 then s8623 else s8624+  s8626 :: SWord1 = choose [0:0] s6003+  s8627 :: SBool = s14 /= s8626+  s8628 :: SWord8 = if s8627 then s8623 else s8624+  s8629 :: SWord8 = if s5984 then s8625 else s8628+  s8630 :: SWord1 = choose [0:0] s6026+  s8631 :: SBool = s14 /= s8630+  s8632 :: SWord8 = if s17 then s6034 else s6015+  s8633 :: SWord8 = s8632 >>> 1+  s8634 :: SWord8 = s19 | s8633+  s8635 :: SWord8 = s21 & s8633+  s8636 :: SWord8 = if s8631 then s8634 else s8635+  s8637 :: SWord1 = choose [0:0] s6037+  s8638 :: SBool = s14 /= s8637+  s8639 :: SWord8 = if s8638 then s8634 else s8635+  s8640 :: SWord8 = if s6019 then s8636 else s8639+  s8641 :: SWord8 = if s5962 then s8629 else s8640+  s8642 :: SWord8 = if s5847 then s8618 else s8641+  s8643 :: SWord8 = if s5613 then s8595 else s8642+  s8644 :: SWord1 = choose [0:0] s6124+  s8645 :: SBool = s14 /= s8644+  s8646 :: SWord8 = if s17 then s6134 else s6116+  s8647 :: SWord8 = s8646 >>> 1+  s8648 :: SWord8 = s19 | s8647+  s8649 :: SWord8 = s21 & s8647+  s8650 :: SWord8 = if s8645 then s8648 else s8649+  s8651 :: SWord1 = choose [0:0] s6143+  s8652 :: SBool = s14 /= s8651+  s8653 :: SWord8 = if s8652 then s8648 else s8649+  s8654 :: SWord8 = if s6120 then s8650 else s8653+  s8655 :: SWord1 = choose [0:0] s6166+  s8656 :: SBool = s14 /= s8655+  s8657 :: SWord8 = if s17 then s6174 else s6155+  s8658 :: SWord8 = s8657 >>> 1+  s8659 :: SWord8 = s19 | s8658+  s8660 :: SWord8 = s21 & s8658+  s8661 :: SWord8 = if s8656 then s8659 else s8660+  s8662 :: SWord1 = choose [0:0] s6177+  s8663 :: SBool = s14 /= s8662+  s8664 :: SWord8 = if s8663 then s8659 else s8660+  s8665 :: SWord8 = if s6159 then s8661 else s8664+  s8666 :: SWord8 = if s6099 then s8654 else s8665+  s8667 :: SWord1 = choose [0:0] s6220+  s8668 :: SBool = s14 /= s8667+  s8669 :: SWord8 = if s17 then s6230 else s6212+  s8670 :: SWord8 = s8669 >>> 1+  s8671 :: SWord8 = s19 | s8670+  s8672 :: SWord8 = s21 & s8670+  s8673 :: SWord8 = if s8668 then s8671 else s8672+  s8674 :: SWord1 = choose [0:0] s6235+  s8675 :: SBool = s14 /= s8674+  s8676 :: SWord8 = if s8675 then s8671 else s8672+  s8677 :: SWord8 = if s6216 then s8673 else s8676+  s8678 :: SWord1 = choose [0:0] s6258+  s8679 :: SBool = s14 /= s8678+  s8680 :: SWord8 = if s17 then s6266 else s6247+  s8681 :: SWord8 = s8680 >>> 1+  s8682 :: SWord8 = s19 | s8681+  s8683 :: SWord8 = s21 & s8681+  s8684 :: SWord8 = if s8679 then s8682 else s8683+  s8685 :: SWord1 = choose [0:0] s6269+  s8686 :: SBool = s14 /= s8685+  s8687 :: SWord8 = if s8686 then s8682 else s8683+  s8688 :: SWord8 = if s6251 then s8684 else s8687+  s8689 :: SWord8 = if s6194 then s8677 else s8688+  s8690 :: SWord8 = if s6078 then s8666 else s8689+  s8691 :: SWord1 = choose [0:0] s6334+  s8692 :: SBool = s14 /= s8691+  s8693 :: SWord8 = if s17 then s6344 else s6326+  s8694 :: SWord8 = s8693 >>> 1+  s8695 :: SWord8 = s19 | s8694+  s8696 :: SWord8 = s21 & s8694+  s8697 :: SWord8 = if s8692 then s8695 else s8696+  s8698 :: SWord1 = choose [0:0] s6351+  s8699 :: SBool = s14 /= s8698+  s8700 :: SWord8 = if s8699 then s8695 else s8696+  s8701 :: SWord8 = if s6330 then s8697 else s8700+  s8702 :: SWord1 = choose [0:0] s6374+  s8703 :: SBool = s14 /= s8702+  s8704 :: SWord8 = if s17 then s6382 else s6363+  s8705 :: SWord8 = s8704 >>> 1+  s8706 :: SWord8 = s19 | s8705+  s8707 :: SWord8 = s21 & s8705+  s8708 :: SWord8 = if s8703 then s8706 else s8707+  s8709 :: SWord1 = choose [0:0] s6385+  s8710 :: SBool = s14 /= s8709+  s8711 :: SWord8 = if s8710 then s8706 else s8707+  s8712 :: SWord8 = if s6367 then s8708 else s8711+  s8713 :: SWord8 = if s6309 then s8701 else s8712+  s8714 :: SWord1 = choose [0:0] s6428+  s8715 :: SBool = s14 /= s8714+  s8716 :: SWord8 = if s17 then s6438 else s6420+  s8717 :: SWord8 = s8716 >>> 1+  s8718 :: SWord8 = s19 | s8717+  s8719 :: SWord8 = s21 & s8717+  s8720 :: SWord8 = if s8715 then s8718 else s8719+  s8721 :: SWord1 = choose [0:0] s6443+  s8722 :: SBool = s14 /= s8721+  s8723 :: SWord8 = if s8722 then s8718 else s8719+  s8724 :: SWord8 = if s6424 then s8720 else s8723+  s8725 :: SWord1 = choose [0:0] s6466+  s8726 :: SBool = s14 /= s8725+  s8727 :: SWord8 = if s17 then s6474 else s6455+  s8728 :: SWord8 = s8727 >>> 1+  s8729 :: SWord8 = s19 | s8728+  s8730 :: SWord8 = s21 & s8728+  s8731 :: SWord8 = if s8726 then s8729 else s8730+  s8732 :: SWord1 = choose [0:0] s6477+  s8733 :: SBool = s14 /= s8732+  s8734 :: SWord8 = if s8733 then s8729 else s8730+  s8735 :: SWord8 = if s6459 then s8731 else s8734+  s8736 :: SWord8 = if s6402 then s8724 else s8735+  s8737 :: SWord8 = if s6287 then s8713 else s8736+  s8738 :: SWord8 = if s6056 then s8690 else s8737+  s8739 :: SWord8 = if s5592 then s8643 else s8738+  s8740 :: SWord1 = choose [0:0] s6586+  s8741 :: SBool = s14 /= s8740+  s8742 :: SWord8 = if s17 then s6596 else s6578+  s8743 :: SWord8 = s8742 >>> 1+  s8744 :: SWord8 = s19 | s8743+  s8745 :: SWord8 = s21 & s8743+  s8746 :: SWord8 = if s8741 then s8744 else s8745+  s8747 :: SWord1 = choose [0:0] s6607+  s8748 :: SBool = s14 /= s8747+  s8749 :: SWord8 = if s8748 then s8744 else s8745+  s8750 :: SWord8 = if s6582 then s8746 else s8749+  s8751 :: SWord1 = choose [0:0] s6630+  s8752 :: SBool = s14 /= s8751+  s8753 :: SWord8 = if s17 then s6638 else s6619+  s8754 :: SWord8 = s8753 >>> 1+  s8755 :: SWord8 = s19 | s8754+  s8756 :: SWord8 = s21 & s8754+  s8757 :: SWord8 = if s8752 then s8755 else s8756+  s8758 :: SWord1 = choose [0:0] s6641+  s8759 :: SBool = s14 /= s8758+  s8760 :: SWord8 = if s8759 then s8755 else s8756+  s8761 :: SWord8 = if s6623 then s8757 else s8760+  s8762 :: SWord8 = if s6561 then s8750 else s8761+  s8763 :: SWord1 = choose [0:0] s6684+  s8764 :: SBool = s14 /= s8763+  s8765 :: SWord8 = if s17 then s6694 else s6676+  s8766 :: SWord8 = s8765 >>> 1+  s8767 :: SWord8 = s19 | s8766+  s8768 :: SWord8 = s21 & s8766+  s8769 :: SWord8 = if s8764 then s8767 else s8768+  s8770 :: SWord1 = choose [0:0] s6699+  s8771 :: SBool = s14 /= s8770+  s8772 :: SWord8 = if s8771 then s8767 else s8768+  s8773 :: SWord8 = if s6680 then s8769 else s8772+  s8774 :: SWord1 = choose [0:0] s6722+  s8775 :: SBool = s14 /= s8774+  s8776 :: SWord8 = if s17 then s6730 else s6711+  s8777 :: SWord8 = s8776 >>> 1+  s8778 :: SWord8 = s19 | s8777+  s8779 :: SWord8 = s21 & s8777+  s8780 :: SWord8 = if s8775 then s8778 else s8779+  s8781 :: SWord1 = choose [0:0] s6733+  s8782 :: SBool = s14 /= s8781+  s8783 :: SWord8 = if s8782 then s8778 else s8779+  s8784 :: SWord8 = if s6715 then s8780 else s8783+  s8785 :: SWord8 = if s6658 then s8773 else s8784+  s8786 :: SWord8 = if s6540 then s8762 else s8785+  s8787 :: SWord1 = choose [0:0] s6798+  s8788 :: SBool = s14 /= s8787+  s8789 :: SWord8 = if s17 then s6808 else s6790+  s8790 :: SWord8 = s8789 >>> 1+  s8791 :: SWord8 = s19 | s8790+  s8792 :: SWord8 = s21 & s8790+  s8793 :: SWord8 = if s8788 then s8791 else s8792+  s8794 :: SWord1 = choose [0:0] s6815+  s8795 :: SBool = s14 /= s8794+  s8796 :: SWord8 = if s8795 then s8791 else s8792+  s8797 :: SWord8 = if s6794 then s8793 else s8796+  s8798 :: SWord1 = choose [0:0] s6838+  s8799 :: SBool = s14 /= s8798+  s8800 :: SWord8 = if s17 then s6846 else s6827+  s8801 :: SWord8 = s8800 >>> 1+  s8802 :: SWord8 = s19 | s8801+  s8803 :: SWord8 = s21 & s8801+  s8804 :: SWord8 = if s8799 then s8802 else s8803+  s8805 :: SWord1 = choose [0:0] s6849+  s8806 :: SBool = s14 /= s8805+  s8807 :: SWord8 = if s8806 then s8802 else s8803+  s8808 :: SWord8 = if s6831 then s8804 else s8807+  s8809 :: SWord8 = if s6773 then s8797 else s8808+  s8810 :: SWord1 = choose [0:0] s6892+  s8811 :: SBool = s14 /= s8810+  s8812 :: SWord8 = if s17 then s6902 else s6884+  s8813 :: SWord8 = s8812 >>> 1+  s8814 :: SWord8 = s19 | s8813+  s8815 :: SWord8 = s21 & s8813+  s8816 :: SWord8 = if s8811 then s8814 else s8815+  s8817 :: SWord1 = choose [0:0] s6907+  s8818 :: SBool = s14 /= s8817+  s8819 :: SWord8 = if s8818 then s8814 else s8815+  s8820 :: SWord8 = if s6888 then s8816 else s8819+  s8821 :: SWord1 = choose [0:0] s6930+  s8822 :: SBool = s14 /= s8821+  s8823 :: SWord8 = if s17 then s6938 else s6919+  s8824 :: SWord8 = s8823 >>> 1+  s8825 :: SWord8 = s19 | s8824+  s8826 :: SWord8 = s21 & s8824+  s8827 :: SWord8 = if s8822 then s8825 else s8826+  s8828 :: SWord1 = choose [0:0] s6941+  s8829 :: SBool = s14 /= s8828+  s8830 :: SWord8 = if s8829 then s8825 else s8826+  s8831 :: SWord8 = if s6923 then s8827 else s8830+  s8832 :: SWord8 = if s6866 then s8820 else s8831+  s8833 :: SWord8 = if s6751 then s8809 else s8832+  s8834 :: SWord8 = if s6519 then s8786 else s8833+  s8835 :: SWord1 = choose [0:0] s7028+  s8836 :: SBool = s14 /= s8835+  s8837 :: SWord8 = if s17 then s7038 else s7020+  s8838 :: SWord8 = s8837 >>> 1+  s8839 :: SWord8 = s19 | s8838+  s8840 :: SWord8 = s21 & s8838+  s8841 :: SWord8 = if s8836 then s8839 else s8840+  s8842 :: SWord1 = choose [0:0] s7047+  s8843 :: SBool = s14 /= s8842+  s8844 :: SWord8 = if s8843 then s8839 else s8840+  s8845 :: SWord8 = if s7024 then s8841 else s8844+  s8846 :: SWord1 = choose [0:0] s7070+  s8847 :: SBool = s14 /= s8846+  s8848 :: SWord8 = if s17 then s7078 else s7059+  s8849 :: SWord8 = s8848 >>> 1+  s8850 :: SWord8 = s19 | s8849+  s8851 :: SWord8 = s21 & s8849+  s8852 :: SWord8 = if s8847 then s8850 else s8851+  s8853 :: SWord1 = choose [0:0] s7081+  s8854 :: SBool = s14 /= s8853+  s8855 :: SWord8 = if s8854 then s8850 else s8851+  s8856 :: SWord8 = if s7063 then s8852 else s8855+  s8857 :: SWord8 = if s7003 then s8845 else s8856+  s8858 :: SWord1 = choose [0:0] s7124+  s8859 :: SBool = s14 /= s8858+  s8860 :: SWord8 = if s17 then s7134 else s7116+  s8861 :: SWord8 = s8860 >>> 1+  s8862 :: SWord8 = s19 | s8861+  s8863 :: SWord8 = s21 & s8861+  s8864 :: SWord8 = if s8859 then s8862 else s8863+  s8865 :: SWord1 = choose [0:0] s7139+  s8866 :: SBool = s14 /= s8865+  s8867 :: SWord8 = if s8866 then s8862 else s8863+  s8868 :: SWord8 = if s7120 then s8864 else s8867+  s8869 :: SWord1 = choose [0:0] s7162+  s8870 :: SBool = s14 /= s8869+  s8871 :: SWord8 = if s17 then s7170 else s7151+  s8872 :: SWord8 = s8871 >>> 1+  s8873 :: SWord8 = s19 | s8872+  s8874 :: SWord8 = s21 & s8872+  s8875 :: SWord8 = if s8870 then s8873 else s8874+  s8876 :: SWord1 = choose [0:0] s7173+  s8877 :: SBool = s14 /= s8876+  s8878 :: SWord8 = if s8877 then s8873 else s8874+  s8879 :: SWord8 = if s7155 then s8875 else s8878+  s8880 :: SWord8 = if s7098 then s8868 else s8879+  s8881 :: SWord8 = if s6982 then s8857 else s8880+  s8882 :: SWord1 = choose [0:0] s7238+  s8883 :: SBool = s14 /= s8882+  s8884 :: SWord8 = if s17 then s7248 else s7230+  s8885 :: SWord8 = s8884 >>> 1+  s8886 :: SWord8 = s19 | s8885+  s8887 :: SWord8 = s21 & s8885+  s8888 :: SWord8 = if s8883 then s8886 else s8887+  s8889 :: SWord1 = choose [0:0] s7255+  s8890 :: SBool = s14 /= s8889+  s8891 :: SWord8 = if s8890 then s8886 else s8887+  s8892 :: SWord8 = if s7234 then s8888 else s8891+  s8893 :: SWord1 = choose [0:0] s7278+  s8894 :: SBool = s14 /= s8893+  s8895 :: SWord8 = if s17 then s7286 else s7267+  s8896 :: SWord8 = s8895 >>> 1+  s8897 :: SWord8 = s19 | s8896+  s8898 :: SWord8 = s21 & s8896+  s8899 :: SWord8 = if s8894 then s8897 else s8898+  s8900 :: SWord1 = choose [0:0] s7289+  s8901 :: SBool = s14 /= s8900+  s8902 :: SWord8 = if s8901 then s8897 else s8898+  s8903 :: SWord8 = if s7271 then s8899 else s8902+  s8904 :: SWord8 = if s7213 then s8892 else s8903+  s8905 :: SWord1 = choose [0:0] s7332+  s8906 :: SBool = s14 /= s8905+  s8907 :: SWord8 = if s17 then s7342 else s7324+  s8908 :: SWord8 = s8907 >>> 1+  s8909 :: SWord8 = s19 | s8908+  s8910 :: SWord8 = s21 & s8908+  s8911 :: SWord8 = if s8906 then s8909 else s8910+  s8912 :: SWord1 = choose [0:0] s7347+  s8913 :: SBool = s14 /= s8912+  s8914 :: SWord8 = if s8913 then s8909 else s8910+  s8915 :: SWord8 = if s7328 then s8911 else s8914+  s8916 :: SWord1 = choose [0:0] s7370+  s8917 :: SBool = s14 /= s8916+  s8918 :: SWord8 = if s17 then s7378 else s7359+  s8919 :: SWord8 = s8918 >>> 1+  s8920 :: SWord8 = s19 | s8919+  s8921 :: SWord8 = s21 & s8919+  s8922 :: SWord8 = if s8917 then s8920 else s8921+  s8923 :: SWord1 = choose [0:0] s7381+  s8924 :: SBool = s14 /= s8923+  s8925 :: SWord8 = if s8924 then s8920 else s8921+  s8926 :: SWord8 = if s7363 then s8922 else s8925+  s8927 :: SWord8 = if s7306 then s8915 else s8926+  s8928 :: SWord8 = if s7191 then s8904 else s8927+  s8929 :: SWord8 = if s6960 then s8881 else s8928+  s8930 :: SWord8 = if s6497 then s8834 else s8929+  s8931 :: SWord8 = if s5570 then s8739 else s8930+  s8932 :: SWord8 = if s3720 then s8548 else s8931+  s8933 :: SWord8 = if s16 then s8165 else s8932+  s8934 :: SWord16 = s12 # s8933+  s8935 :: SWord16 = s7398 + s8934+  s8936 :: SWord16 = s12 # s1+  s8937 :: SWord16 = s12 # s3+  s8938 :: SWord16 = s8936 * s8937+  s8939 :: SBool = s8935 == s8938+  s8940 :: SBool = s10 | s8939+CONSTRAINTS+ASSERTIONS+OUTPUTS+  s8940
+ SBVTestSuite/GoldFiles/legato_c.gold view
@@ -0,0 +1,6425 @@+== BEGIN: "Makefile" ================+# Makefile for legatoMult. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: legatoMult_driver++legatoMult.o: legatoMult.c legatoMult.h+	${CC} ${CCFLAGS} -c $< -o $@++legatoMult_driver.o: legatoMult_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++legatoMult_driver: legatoMult.o legatoMult_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f legatoMult_driver+== END: "Makefile" ==================+== BEGIN: "legatoMult.h" ================+/* Header file for legatoMult. Automatically generated by SBV. Do not edit! */++#ifndef __legatoMult__HEADER_INCLUDED__+#define __legatoMult__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+void legatoMult(const SWord8 x, const SWord8 y, SWord8 *hi,+                SWord8 *lo);++#endif /* __legatoMult__HEADER_INCLUDED__ */+== END: "legatoMult.h" ==================+== BEGIN: "legatoMult_driver.c" ================+/* Example driver program for legatoMult. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "legatoMult.h"++int main(void)+{+  SWord8 hi;+  SWord8 lo;++  legatoMult(87, 92, &hi, &lo);++  printf("legatoMult(87, 92, &hi, &lo) ->\n");+  printf("  hi = %"PRIu8"\n", hi);+  printf("  lo = %"PRIu8"\n", lo);++  return 0;+}+== END: "legatoMult_driver.c" ==================+== BEGIN: "legatoMult.c" ================+/* File: "legatoMult.c". Automatically generated by SBV. Do not edit! */++#include "legatoMult.h"++void legatoMult(const SWord8 x, const SWord8 y, SWord8 *hi,+                SWord8 *lo)+{+  const SWord8 s0 = x;+  const SWord8 s1 = y;+  const SBool  s2 = (SBool) ((s0 >> 0) & 1);+  const SBool  s4 = s2 != false;+  const SBool  s5 = false == s4;+  const SWord8 s6 = (s0 >> 1) | (s0 << 7);+  const SWord8 s8 = s6 & 127;+  const SBool  s9 = (SBool) ((s8 >> 0) & 1);+  const SBool  s10 = false != s9;+  const SBool  s11 = false == s10;+  const SWord8 s12 = (s8 >> 1) | (s8 << 7);+  const SWord8 s13 = 127 & s12;+  const SBool  s14 = (SBool) ((s13 >> 0) & 1);+  const SBool  s15 = false != s14;+  const SBool  s16 = false == s15;+  const SWord8 s17 = (s13 >> 1) | (s13 << 7);+  const SWord8 s18 = 127 & s17;+  const SBool  s19 = (SBool) ((s18 >> 0) & 1);+  const SBool  s20 = false != s19;+  const SBool  s21 = false == s20;+  const SWord8 s24 = s4 ? 128 : 0;+  const SBool  s25 = (SBool) ((s24 >> 0) & 1);+  const SBool  s26 = false != s25;+  const SWord8 s27 = s26 ? 128 : 0;+  const SBool  s28 = (SBool) ((s27 >> 0) & 1);+  const SBool  s29 = false != s28;+  const SWord8 s30 = (s18 >> 1) | (s18 << 7);+  const SWord8 s31 = 128 | s30;+  const SWord8 s32 = 127 & s30;+  const SWord8 s33 = s29 ? s31 : s32;+  const SBool  s34 = (SBool) ((s33 >> 0) & 1);+  const SBool  s35 = false != s34;+  const SBool  s36 = false == s35;+  const SWord8 s37 = (s24 >> 1) | (s24 << 7);+  const SWord8 s38 = 128 | s37;+  const SWord8 s39 = 127 & s37;+  const SWord8 s40 = s10 ? s38 : s39;+  const SBool  s41 = (SBool) ((s40 >> 0) & 1);+  const SBool  s42 = false != s41;+  const SWord8 s43 = (s27 >> 1) | (s27 << 7);+  const SWord8 s44 = 128 | s43;+  const SWord8 s45 = 127 & s43;+  const SWord8 s46 = s42 ? s44 : s45;+  const SBool  s47 = (SBool) ((s46 >> 0) & 1);+  const SBool  s48 = false != s47;+  const SWord8 s49 = (s33 >> 1) | (s33 << 7);+  const SWord8 s50 = 128 | s49;+  const SWord8 s51 = 127 & s49;+  const SWord8 s52 = s48 ? s50 : s51;+  const SBool  s53 = (SBool) ((s52 >> 0) & 1);+  const SBool  s54 = false != s53;+  const SBool  s55 = false == s54;+  const SWord8 s56 = (s40 >> 1) | (s40 << 7);+  const SWord8 s57 = 128 | s56;+  const SWord8 s58 = 127 & s56;+  const SWord8 s59 = s15 ? s57 : s58;+  const SBool  s60 = (SBool) ((s59 >> 0) & 1);+  const SBool  s61 = false != s60;+  const SWord8 s62 = (s46 >> 1) | (s46 << 7);+  const SWord8 s63 = 128 | s62;+  const SWord8 s64 = 127 & s62;+  const SWord8 s65 = s61 ? s63 : s64;+  const SBool  s66 = (SBool) ((s65 >> 0) & 1);+  const SBool  s67 = false != s66;+  const SWord8 s68 = (s52 >> 1) | (s52 << 7);+  const SWord8 s69 = 128 | s68;+  const SWord8 s70 = 127 & s68;+  const SWord8 s71 = s67 ? s69 : s70;+  const SBool  s72 = (SBool) ((s71 >> 0) & 1);+  const SBool  s73 = false != s72;+  const SBool  s74 = false == s73;+  const SWord8 s75 = (s59 >> 1) | (s59 << 7);+  const SWord8 s76 = 128 | s75;+  const SWord8 s77 = 127 & s75;+  const SWord8 s78 = s20 ? s76 : s77;+  const SBool  s79 = (SBool) ((s78 >> 0) & 1);+  const SBool  s80 = false != s79;+  const SWord8 s81 = (s65 >> 1) | (s65 << 7);+  const SWord8 s82 = 128 | s81;+  const SWord8 s83 = 127 & s81;+  const SWord8 s84 = s80 ? s82 : s83;+  const SBool  s85 = (SBool) ((s84 >> 0) & 1);+  const SBool  s86 = false != s85;+  const SWord8 s87 = (s71 >> 1) | (s71 << 7);+  const SWord8 s88 = 128 | s87;+  const SWord8 s89 = 127 & s87;+  const SWord8 s90 = s86 ? s88 : s89;+  const SBool  s91 = (SBool) ((s90 >> 0) & 1);+  const SBool  s92 = false != s91;+  const SBool  s93 = false == s92;+  const SWord8 s94 = (s78 >> 1) | (s78 << 7);+  const SWord8 s95 = 128 | s94;+  const SWord8 s96 = 127 & s94;+  const SWord8 s97 = s35 ? s95 : s96;+  const SWord8 s98 = (s97 >> 1) | (s97 << 7);+  const SWord8 s99 = 128 | s98;+  const SWord8 s100 = 127 & s98;+  const SWord8 s101 = s54 ? s99 : s100;+  const SWord8 s102 = (s101 >> 1) | (s101 << 7);+  const SWord8 s103 = 128 | s102;+  const SWord8 s104 = 127 & s102;+  const SWord8 s105 = s73 ? s103 : s104;+  const SWord8 s106 = (s105 >> 1) | (s105 << 7);+  const SWord8 s107 = 128 | s106;+  const SWord8 s108 = 127 & s106;+  const SWord8 s109 = s92 ? s107 : s108;+  const SWord8 s110 = s1 + s105;+  const SBool  s111 = s110 < s1;+  const SBool  s112 = s110 < s105;+  const SBool  s113 = s111 || s112;+  const SWord8 s114 = (s110 >> 1) | (s110 << 7);+  const SWord8 s115 = 128 | s114;+  const SWord8 s116 = 127 & s114;+  const SWord8 s117 = s113 ? s115 : s116;+  const SWord8 s118 = s93 ? s109 : s117;+  const SWord8 s119 = s1 + s101;+  const SBool  s120 = s119 < s1;+  const SBool  s121 = s119 < s101;+  const SBool  s122 = s120 || s121;+  const SWord8 s123 = (s119 >> 1) | (s119 << 7);+  const SWord8 s124 = 128 | s123;+  const SWord8 s125 = 127 & s123;+  const SWord8 s126 = s122 ? s124 : s125;+  const SWord8 s127 = (s126 >> 1) | (s126 << 7);+  const SWord8 s128 = 128 | s127;+  const SWord8 s129 = 127 & s127;+  const SWord8 s130 = s92 ? s128 : s129;+  const SWord8 s131 = s1 + s126;+  const SBool  s132 = s131 < s1;+  const SBool  s133 = s131 < s126;+  const SBool  s134 = s132 || s133;+  const SWord8 s135 = (s131 >> 1) | (s131 << 7);+  const SWord8 s136 = 128 | s135;+  const SWord8 s137 = 127 & s135;+  const SWord8 s138 = s134 ? s136 : s137;+  const SWord8 s139 = s93 ? s130 : s138;+  const SWord8 s140 = s74 ? s118 : s139;+  const SWord8 s141 = s1 + s97;+  const SBool  s142 = s141 < s1;+  const SBool  s143 = s141 < s97;+  const SBool  s144 = s142 || s143;+  const SWord8 s145 = (s141 >> 1) | (s141 << 7);+  const SWord8 s146 = 128 | s145;+  const SWord8 s147 = 127 & s145;+  const SWord8 s148 = s144 ? s146 : s147;+  const SWord8 s149 = (s148 >> 1) | (s148 << 7);+  const SWord8 s150 = 128 | s149;+  const SWord8 s151 = 127 & s149;+  const SWord8 s152 = s73 ? s150 : s151;+  const SWord8 s153 = (s152 >> 1) | (s152 << 7);+  const SWord8 s154 = 128 | s153;+  const SWord8 s155 = 127 & s153;+  const SWord8 s156 = s92 ? s154 : s155;+  const SWord8 s157 = s1 + s152;+  const SBool  s158 = s157 < s1;+  const SBool  s159 = s157 < s152;+  const SBool  s160 = s158 || s159;+  const SWord8 s161 = (s157 >> 1) | (s157 << 7);+  const SWord8 s162 = 128 | s161;+  const SWord8 s163 = 127 & s161;+  const SWord8 s164 = s160 ? s162 : s163;+  const SWord8 s165 = s93 ? s156 : s164;+  const SWord8 s166 = s1 + s148;+  const SBool  s167 = s166 < s1;+  const SBool  s168 = s166 < s148;+  const SBool  s169 = s167 || s168;+  const SWord8 s170 = (s166 >> 1) | (s166 << 7);+  const SWord8 s171 = 128 | s170;+  const SWord8 s172 = 127 & s170;+  const SWord8 s173 = s169 ? s171 : s172;+  const SWord8 s174 = (s173 >> 1) | (s173 << 7);+  const SWord8 s175 = 128 | s174;+  const SWord8 s176 = 127 & s174;+  const SWord8 s177 = s92 ? s175 : s176;+  const SWord8 s178 = s1 + s173;+  const SBool  s179 = s178 < s1;+  const SBool  s180 = s178 < s173;+  const SBool  s181 = s179 || s180;+  const SWord8 s182 = (s178 >> 1) | (s178 << 7);+  const SWord8 s183 = 128 | s182;+  const SWord8 s184 = 127 & s182;+  const SWord8 s185 = s181 ? s183 : s184;+  const SWord8 s186 = s93 ? s177 : s185;+  const SWord8 s187 = s74 ? s165 : s186;+  const SWord8 s188 = s55 ? s140 : s187;+  const SWord8 s189 = s1 + s78;+  const SBool  s190 = (SBool) ((s189 >> 0) & 1);+  const SBool  s191 = false != s190;+  const SWord8 s192 = s191 ? s82 : s83;+  const SBool  s193 = (SBool) ((s192 >> 0) & 1);+  const SBool  s194 = false != s193;+  const SWord8 s195 = s194 ? s88 : s89;+  const SBool  s196 = (SBool) ((s195 >> 0) & 1);+  const SBool  s197 = false != s196;+  const SBool  s198 = false == s197;+  const SBool  s199 = s189 < s1;+  const SBool  s200 = s189 < s78;+  const SBool  s201 = s199 || s200;+  const SWord8 s202 = (s189 >> 1) | (s189 << 7);+  const SWord8 s203 = 128 | s202;+  const SWord8 s204 = 127 & s202;+  const SWord8 s205 = s201 ? s203 : s204;+  const SWord8 s206 = (s205 >> 1) | (s205 << 7);+  const SWord8 s207 = 128 | s206;+  const SWord8 s208 = 127 & s206;+  const SWord8 s209 = s54 ? s207 : s208;+  const SWord8 s210 = (s209 >> 1) | (s209 << 7);+  const SWord8 s211 = 128 | s210;+  const SWord8 s212 = 127 & s210;+  const SWord8 s213 = s73 ? s211 : s212;+  const SWord8 s214 = (s213 >> 1) | (s213 << 7);+  const SWord8 s215 = 128 | s214;+  const SWord8 s216 = 127 & s214;+  const SWord8 s217 = s197 ? s215 : s216;+  const SWord8 s218 = s1 + s213;+  const SBool  s219 = s218 < s1;+  const SBool  s220 = s218 < s213;+  const SBool  s221 = s219 || s220;+  const SWord8 s222 = (s218 >> 1) | (s218 << 7);+  const SWord8 s223 = 128 | s222;+  const SWord8 s224 = 127 & s222;+  const SWord8 s225 = s221 ? s223 : s224;+  const SWord8 s226 = s198 ? s217 : s225;+  const SWord8 s227 = s1 + s209;+  const SBool  s228 = s227 < s1;+  const SBool  s229 = s227 < s209;+  const SBool  s230 = s228 || s229;+  const SWord8 s231 = (s227 >> 1) | (s227 << 7);+  const SWord8 s232 = 128 | s231;+  const SWord8 s233 = 127 & s231;+  const SWord8 s234 = s230 ? s232 : s233;+  const SWord8 s235 = (s234 >> 1) | (s234 << 7);+  const SWord8 s236 = 128 | s235;+  const SWord8 s237 = 127 & s235;+  const SWord8 s238 = s197 ? s236 : s237;+  const SWord8 s239 = s1 + s234;+  const SBool  s240 = s239 < s1;+  const SBool  s241 = s239 < s234;+  const SBool  s242 = s240 || s241;+  const SWord8 s243 = (s239 >> 1) | (s239 << 7);+  const SWord8 s244 = 128 | s243;+  const SWord8 s245 = 127 & s243;+  const SWord8 s246 = s242 ? s244 : s245;+  const SWord8 s247 = s198 ? s238 : s246;+  const SWord8 s248 = s74 ? s226 : s247;+  const SWord8 s249 = s1 + s205;+  const SBool  s250 = s249 < s1;+  const SBool  s251 = s249 < s205;+  const SBool  s252 = s250 || s251;+  const SWord8 s253 = (s249 >> 1) | (s249 << 7);+  const SWord8 s254 = 128 | s253;+  const SWord8 s255 = 127 & s253;+  const SWord8 s256 = s252 ? s254 : s255;+  const SWord8 s257 = (s256 >> 1) | (s256 << 7);+  const SWord8 s258 = 128 | s257;+  const SWord8 s259 = 127 & s257;+  const SWord8 s260 = s73 ? s258 : s259;+  const SWord8 s261 = (s260 >> 1) | (s260 << 7);+  const SWord8 s262 = 128 | s261;+  const SWord8 s263 = 127 & s261;+  const SWord8 s264 = s197 ? s262 : s263;+  const SWord8 s265 = s1 + s260;+  const SBool  s266 = s265 < s1;+  const SBool  s267 = s265 < s260;+  const SBool  s268 = s266 || s267;+  const SWord8 s269 = (s265 >> 1) | (s265 << 7);+  const SWord8 s270 = 128 | s269;+  const SWord8 s271 = 127 & s269;+  const SWord8 s272 = s268 ? s270 : s271;+  const SWord8 s273 = s198 ? s264 : s272;+  const SWord8 s274 = s1 + s256;+  const SBool  s275 = s274 < s1;+  const SBool  s276 = s274 < s256;+  const SBool  s277 = s275 || s276;+  const SWord8 s278 = (s274 >> 1) | (s274 << 7);+  const SWord8 s279 = 128 | s278;+  const SWord8 s280 = 127 & s278;+  const SWord8 s281 = s277 ? s279 : s280;+  const SWord8 s282 = (s281 >> 1) | (s281 << 7);+  const SWord8 s283 = 128 | s282;+  const SWord8 s284 = 127 & s282;+  const SWord8 s285 = s197 ? s283 : s284;+  const SWord8 s286 = s1 + s281;+  const SBool  s287 = s286 < s1;+  const SBool  s288 = s286 < s281;+  const SBool  s289 = s287 || s288;+  const SWord8 s290 = (s286 >> 1) | (s286 << 7);+  const SWord8 s291 = 128 | s290;+  const SWord8 s292 = 127 & s290;+  const SWord8 s293 = s289 ? s291 : s292;+  const SWord8 s294 = s198 ? s285 : s293;+  const SWord8 s295 = s74 ? s273 : s294;+  const SWord8 s296 = s55 ? s248 : s295;+  const SWord8 s297 = s36 ? s188 : s296;+  const SWord8 s298 = s1 + s59;+  const SBool  s299 = (SBool) ((s298 >> 0) & 1);+  const SBool  s300 = false != s299;+  const SWord8 s301 = s300 ? s63 : s64;+  const SBool  s302 = (SBool) ((s301 >> 0) & 1);+  const SBool  s303 = false != s302;+  const SWord8 s304 = s303 ? s69 : s70;+  const SBool  s305 = (SBool) ((s304 >> 0) & 1);+  const SBool  s306 = false != s305;+  const SBool  s307 = false == s306;+  const SBool  s308 = s298 < s1;+  const SBool  s309 = s298 < s59;+  const SBool  s310 = s308 || s309;+  const SWord8 s311 = (s298 >> 1) | (s298 << 7);+  const SWord8 s312 = 128 | s311;+  const SWord8 s313 = 127 & s311;+  const SWord8 s314 = s310 ? s312 : s313;+  const SBool  s315 = (SBool) ((s314 >> 0) & 1);+  const SBool  s316 = false != s315;+  const SWord8 s317 = (s301 >> 1) | (s301 << 7);+  const SWord8 s318 = 128 | s317;+  const SWord8 s319 = 127 & s317;+  const SWord8 s320 = s316 ? s318 : s319;+  const SBool  s321 = (SBool) ((s320 >> 0) & 1);+  const SBool  s322 = false != s321;+  const SWord8 s323 = (s304 >> 1) | (s304 << 7);+  const SWord8 s324 = 128 | s323;+  const SWord8 s325 = 127 & s323;+  const SWord8 s326 = s322 ? s324 : s325;+  const SBool  s327 = (SBool) ((s326 >> 0) & 1);+  const SBool  s328 = false != s327;+  const SBool  s329 = false == s328;+  const SWord8 s330 = (s314 >> 1) | (s314 << 7);+  const SWord8 s331 = 128 | s330;+  const SWord8 s332 = 127 & s330;+  const SWord8 s333 = s35 ? s331 : s332;+  const SWord8 s334 = (s333 >> 1) | (s333 << 7);+  const SWord8 s335 = 128 | s334;+  const SWord8 s336 = 127 & s334;+  const SWord8 s337 = s54 ? s335 : s336;+  const SWord8 s338 = (s337 >> 1) | (s337 << 7);+  const SWord8 s339 = 128 | s338;+  const SWord8 s340 = 127 & s338;+  const SWord8 s341 = s306 ? s339 : s340;+  const SWord8 s342 = (s341 >> 1) | (s341 << 7);+  const SWord8 s343 = 128 | s342;+  const SWord8 s344 = 127 & s342;+  const SWord8 s345 = s328 ? s343 : s344;+  const SWord8 s346 = s1 + s341;+  const SBool  s347 = s346 < s1;+  const SBool  s348 = s346 < s341;+  const SBool  s349 = s347 || s348;+  const SWord8 s350 = (s346 >> 1) | (s346 << 7);+  const SWord8 s351 = 128 | s350;+  const SWord8 s352 = 127 & s350;+  const SWord8 s353 = s349 ? s351 : s352;+  const SWord8 s354 = s329 ? s345 : s353;+  const SWord8 s355 = s1 + s337;+  const SBool  s356 = s355 < s1;+  const SBool  s357 = s355 < s337;+  const SBool  s358 = s356 || s357;+  const SWord8 s359 = (s355 >> 1) | (s355 << 7);+  const SWord8 s360 = 128 | s359;+  const SWord8 s361 = 127 & s359;+  const SWord8 s362 = s358 ? s360 : s361;+  const SWord8 s363 = (s362 >> 1) | (s362 << 7);+  const SWord8 s364 = 128 | s363;+  const SWord8 s365 = 127 & s363;+  const SWord8 s366 = s328 ? s364 : s365;+  const SWord8 s367 = s1 + s362;+  const SBool  s368 = s367 < s1;+  const SBool  s369 = s367 < s362;+  const SBool  s370 = s368 || s369;+  const SWord8 s371 = (s367 >> 1) | (s367 << 7);+  const SWord8 s372 = 128 | s371;+  const SWord8 s373 = 127 & s371;+  const SWord8 s374 = s370 ? s372 : s373;+  const SWord8 s375 = s329 ? s366 : s374;+  const SWord8 s376 = s307 ? s354 : s375;+  const SWord8 s377 = s1 + s333;+  const SBool  s378 = s377 < s1;+  const SBool  s379 = s377 < s333;+  const SBool  s380 = s378 || s379;+  const SWord8 s381 = (s377 >> 1) | (s377 << 7);+  const SWord8 s382 = 128 | s381;+  const SWord8 s383 = 127 & s381;+  const SWord8 s384 = s380 ? s382 : s383;+  const SWord8 s385 = (s384 >> 1) | (s384 << 7);+  const SWord8 s386 = 128 | s385;+  const SWord8 s387 = 127 & s385;+  const SWord8 s388 = s306 ? s386 : s387;+  const SWord8 s389 = (s388 >> 1) | (s388 << 7);+  const SWord8 s390 = 128 | s389;+  const SWord8 s391 = 127 & s389;+  const SWord8 s392 = s328 ? s390 : s391;+  const SWord8 s393 = s1 + s388;+  const SBool  s394 = s393 < s1;+  const SBool  s395 = s393 < s388;+  const SBool  s396 = s394 || s395;+  const SWord8 s397 = (s393 >> 1) | (s393 << 7);+  const SWord8 s398 = 128 | s397;+  const SWord8 s399 = 127 & s397;+  const SWord8 s400 = s396 ? s398 : s399;+  const SWord8 s401 = s329 ? s392 : s400;+  const SWord8 s402 = s1 + s384;+  const SBool  s403 = s402 < s1;+  const SBool  s404 = s402 < s384;+  const SBool  s405 = s403 || s404;+  const SWord8 s406 = (s402 >> 1) | (s402 << 7);+  const SWord8 s407 = 128 | s406;+  const SWord8 s408 = 127 & s406;+  const SWord8 s409 = s405 ? s407 : s408;+  const SWord8 s410 = (s409 >> 1) | (s409 << 7);+  const SWord8 s411 = 128 | s410;+  const SWord8 s412 = 127 & s410;+  const SWord8 s413 = s328 ? s411 : s412;+  const SWord8 s414 = s1 + s409;+  const SBool  s415 = s414 < s1;+  const SBool  s416 = s414 < s409;+  const SBool  s417 = s415 || s416;+  const SWord8 s418 = (s414 >> 1) | (s414 << 7);+  const SWord8 s419 = 128 | s418;+  const SWord8 s420 = 127 & s418;+  const SWord8 s421 = s417 ? s419 : s420;+  const SWord8 s422 = s329 ? s413 : s421;+  const SWord8 s423 = s307 ? s401 : s422;+  const SWord8 s424 = s55 ? s376 : s423;+  const SWord8 s425 = s1 + s314;+  const SBool  s426 = (SBool) ((s425 >> 0) & 1);+  const SBool  s427 = false != s426;+  const SWord8 s428 = s427 ? s318 : s319;+  const SBool  s429 = (SBool) ((s428 >> 0) & 1);+  const SBool  s430 = false != s429;+  const SWord8 s431 = s430 ? s324 : s325;+  const SBool  s432 = (SBool) ((s431 >> 0) & 1);+  const SBool  s433 = false != s432;+  const SBool  s434 = false == s433;+  const SBool  s435 = s425 < s1;+  const SBool  s436 = s425 < s314;+  const SBool  s437 = s435 || s436;+  const SWord8 s438 = (s425 >> 1) | (s425 << 7);+  const SWord8 s439 = 128 | s438;+  const SWord8 s440 = 127 & s438;+  const SWord8 s441 = s437 ? s439 : s440;+  const SWord8 s442 = (s441 >> 1) | (s441 << 7);+  const SWord8 s443 = 128 | s442;+  const SWord8 s444 = 127 & s442;+  const SWord8 s445 = s54 ? s443 : s444;+  const SWord8 s446 = (s445 >> 1) | (s445 << 7);+  const SWord8 s447 = 128 | s446;+  const SWord8 s448 = 127 & s446;+  const SWord8 s449 = s306 ? s447 : s448;+  const SWord8 s450 = (s449 >> 1) | (s449 << 7);+  const SWord8 s451 = 128 | s450;+  const SWord8 s452 = 127 & s450;+  const SWord8 s453 = s433 ? s451 : s452;+  const SWord8 s454 = s1 + s449;+  const SBool  s455 = s454 < s1;+  const SBool  s456 = s454 < s449;+  const SBool  s457 = s455 || s456;+  const SWord8 s458 = (s454 >> 1) | (s454 << 7);+  const SWord8 s459 = 128 | s458;+  const SWord8 s460 = 127 & s458;+  const SWord8 s461 = s457 ? s459 : s460;+  const SWord8 s462 = s434 ? s453 : s461;+  const SWord8 s463 = s1 + s445;+  const SBool  s464 = s463 < s1;+  const SBool  s465 = s463 < s445;+  const SBool  s466 = s464 || s465;+  const SWord8 s467 = (s463 >> 1) | (s463 << 7);+  const SWord8 s468 = 128 | s467;+  const SWord8 s469 = 127 & s467;+  const SWord8 s470 = s466 ? s468 : s469;+  const SWord8 s471 = (s470 >> 1) | (s470 << 7);+  const SWord8 s472 = 128 | s471;+  const SWord8 s473 = 127 & s471;+  const SWord8 s474 = s433 ? s472 : s473;+  const SWord8 s475 = s1 + s470;+  const SBool  s476 = s475 < s1;+  const SBool  s477 = s475 < s470;+  const SBool  s478 = s476 || s477;+  const SWord8 s479 = (s475 >> 1) | (s475 << 7);+  const SWord8 s480 = 128 | s479;+  const SWord8 s481 = 127 & s479;+  const SWord8 s482 = s478 ? s480 : s481;+  const SWord8 s483 = s434 ? s474 : s482;+  const SWord8 s484 = s307 ? s462 : s483;+  const SWord8 s485 = s1 + s441;+  const SBool  s486 = s485 < s1;+  const SBool  s487 = s485 < s441;+  const SBool  s488 = s486 || s487;+  const SWord8 s489 = (s485 >> 1) | (s485 << 7);+  const SWord8 s490 = 128 | s489;+  const SWord8 s491 = 127 & s489;+  const SWord8 s492 = s488 ? s490 : s491;+  const SWord8 s493 = (s492 >> 1) | (s492 << 7);+  const SWord8 s494 = 128 | s493;+  const SWord8 s495 = 127 & s493;+  const SWord8 s496 = s306 ? s494 : s495;+  const SWord8 s497 = (s496 >> 1) | (s496 << 7);+  const SWord8 s498 = 128 | s497;+  const SWord8 s499 = 127 & s497;+  const SWord8 s500 = s433 ? s498 : s499;+  const SWord8 s501 = s1 + s496;+  const SBool  s502 = s501 < s1;+  const SBool  s503 = s501 < s496;+  const SBool  s504 = s502 || s503;+  const SWord8 s505 = (s501 >> 1) | (s501 << 7);+  const SWord8 s506 = 128 | s505;+  const SWord8 s507 = 127 & s505;+  const SWord8 s508 = s504 ? s506 : s507;+  const SWord8 s509 = s434 ? s500 : s508;+  const SWord8 s510 = s1 + s492;+  const SBool  s511 = s510 < s1;+  const SBool  s512 = s510 < s492;+  const SBool  s513 = s511 || s512;+  const SWord8 s514 = (s510 >> 1) | (s510 << 7);+  const SWord8 s515 = 128 | s514;+  const SWord8 s516 = 127 & s514;+  const SWord8 s517 = s513 ? s515 : s516;+  const SWord8 s518 = (s517 >> 1) | (s517 << 7);+  const SWord8 s519 = 128 | s518;+  const SWord8 s520 = 127 & s518;+  const SWord8 s521 = s433 ? s519 : s520;+  const SWord8 s522 = s1 + s517;+  const SBool  s523 = s522 < s1;+  const SBool  s524 = s522 < s517;+  const SBool  s525 = s523 || s524;+  const SWord8 s526 = (s522 >> 1) | (s522 << 7);+  const SWord8 s527 = 128 | s526;+  const SWord8 s528 = 127 & s526;+  const SWord8 s529 = s525 ? s527 : s528;+  const SWord8 s530 = s434 ? s521 : s529;+  const SWord8 s531 = s307 ? s509 : s530;+  const SWord8 s532 = s55 ? s484 : s531;+  const SWord8 s533 = s36 ? s424 : s532;+  const SWord8 s534 = s21 ? s297 : s533;+  const SWord8 s535 = s1 + s40;+  const SBool  s536 = (SBool) ((s535 >> 0) & 1);+  const SBool  s537 = false != s536;+  const SWord8 s538 = s537 ? s44 : s45;+  const SBool  s539 = (SBool) ((s538 >> 0) & 1);+  const SBool  s540 = false != s539;+  const SWord8 s541 = s540 ? s50 : s51;+  const SBool  s542 = (SBool) ((s541 >> 0) & 1);+  const SBool  s543 = false != s542;+  const SBool  s544 = false == s543;+  const SBool  s545 = s535 < s1;+  const SBool  s546 = s535 < s40;+  const SBool  s547 = s545 || s546;+  const SWord8 s548 = (s535 >> 1) | (s535 << 7);+  const SWord8 s549 = 128 | s548;+  const SWord8 s550 = 127 & s548;+  const SWord8 s551 = s547 ? s549 : s550;+  const SBool  s552 = (SBool) ((s551 >> 0) & 1);+  const SBool  s553 = false != s552;+  const SWord8 s554 = (s538 >> 1) | (s538 << 7);+  const SWord8 s555 = 128 | s554;+  const SWord8 s556 = 127 & s554;+  const SWord8 s557 = s553 ? s555 : s556;+  const SBool  s558 = (SBool) ((s557 >> 0) & 1);+  const SBool  s559 = false != s558;+  const SWord8 s560 = (s541 >> 1) | (s541 << 7);+  const SWord8 s561 = 128 | s560;+  const SWord8 s562 = 127 & s560;+  const SWord8 s563 = s559 ? s561 : s562;+  const SBool  s564 = (SBool) ((s563 >> 0) & 1);+  const SBool  s565 = false != s564;+  const SBool  s566 = false == s565;+  const SWord8 s567 = (s551 >> 1) | (s551 << 7);+  const SWord8 s568 = 128 | s567;+  const SWord8 s569 = 127 & s567;+  const SWord8 s570 = s20 ? s568 : s569;+  const SBool  s571 = (SBool) ((s570 >> 0) & 1);+  const SBool  s572 = false != s571;+  const SWord8 s573 = (s557 >> 1) | (s557 << 7);+  const SWord8 s574 = 128 | s573;+  const SWord8 s575 = 127 & s573;+  const SWord8 s576 = s572 ? s574 : s575;+  const SBool  s577 = (SBool) ((s576 >> 0) & 1);+  const SBool  s578 = false != s577;+  const SWord8 s579 = (s563 >> 1) | (s563 << 7);+  const SWord8 s580 = 128 | s579;+  const SWord8 s581 = 127 & s579;+  const SWord8 s582 = s578 ? s580 : s581;+  const SBool  s583 = (SBool) ((s582 >> 0) & 1);+  const SBool  s584 = false != s583;+  const SBool  s585 = false == s584;+  const SWord8 s586 = (s570 >> 1) | (s570 << 7);+  const SWord8 s587 = 128 | s586;+  const SWord8 s588 = 127 & s586;+  const SWord8 s589 = s35 ? s587 : s588;+  const SWord8 s590 = (s589 >> 1) | (s589 << 7);+  const SWord8 s591 = 128 | s590;+  const SWord8 s592 = 127 & s590;+  const SWord8 s593 = s543 ? s591 : s592;+  const SWord8 s594 = (s593 >> 1) | (s593 << 7);+  const SWord8 s595 = 128 | s594;+  const SWord8 s596 = 127 & s594;+  const SWord8 s597 = s565 ? s595 : s596;+  const SWord8 s598 = (s597 >> 1) | (s597 << 7);+  const SWord8 s599 = 128 | s598;+  const SWord8 s600 = 127 & s598;+  const SWord8 s601 = s584 ? s599 : s600;+  const SWord8 s602 = s1 + s597;+  const SBool  s603 = s602 < s1;+  const SBool  s604 = s602 < s597;+  const SBool  s605 = s603 || s604;+  const SWord8 s606 = (s602 >> 1) | (s602 << 7);+  const SWord8 s607 = 128 | s606;+  const SWord8 s608 = 127 & s606;+  const SWord8 s609 = s605 ? s607 : s608;+  const SWord8 s610 = s585 ? s601 : s609;+  const SWord8 s611 = s1 + s593;+  const SBool  s612 = s611 < s1;+  const SBool  s613 = s611 < s593;+  const SBool  s614 = s612 || s613;+  const SWord8 s615 = (s611 >> 1) | (s611 << 7);+  const SWord8 s616 = 128 | s615;+  const SWord8 s617 = 127 & s615;+  const SWord8 s618 = s614 ? s616 : s617;+  const SWord8 s619 = (s618 >> 1) | (s618 << 7);+  const SWord8 s620 = 128 | s619;+  const SWord8 s621 = 127 & s619;+  const SWord8 s622 = s584 ? s620 : s621;+  const SWord8 s623 = s1 + s618;+  const SBool  s624 = s623 < s1;+  const SBool  s625 = s623 < s618;+  const SBool  s626 = s624 || s625;+  const SWord8 s627 = (s623 >> 1) | (s623 << 7);+  const SWord8 s628 = 128 | s627;+  const SWord8 s629 = 127 & s627;+  const SWord8 s630 = s626 ? s628 : s629;+  const SWord8 s631 = s585 ? s622 : s630;+  const SWord8 s632 = s566 ? s610 : s631;+  const SWord8 s633 = s1 + s589;+  const SBool  s634 = s633 < s1;+  const SBool  s635 = s633 < s589;+  const SBool  s636 = s634 || s635;+  const SWord8 s637 = (s633 >> 1) | (s633 << 7);+  const SWord8 s638 = 128 | s637;+  const SWord8 s639 = 127 & s637;+  const SWord8 s640 = s636 ? s638 : s639;+  const SWord8 s641 = (s640 >> 1) | (s640 << 7);+  const SWord8 s642 = 128 | s641;+  const SWord8 s643 = 127 & s641;+  const SWord8 s644 = s565 ? s642 : s643;+  const SWord8 s645 = (s644 >> 1) | (s644 << 7);+  const SWord8 s646 = 128 | s645;+  const SWord8 s647 = 127 & s645;+  const SWord8 s648 = s584 ? s646 : s647;+  const SWord8 s649 = s1 + s644;+  const SBool  s650 = s649 < s1;+  const SBool  s651 = s649 < s644;+  const SBool  s652 = s650 || s651;+  const SWord8 s653 = (s649 >> 1) | (s649 << 7);+  const SWord8 s654 = 128 | s653;+  const SWord8 s655 = 127 & s653;+  const SWord8 s656 = s652 ? s654 : s655;+  const SWord8 s657 = s585 ? s648 : s656;+  const SWord8 s658 = s1 + s640;+  const SBool  s659 = s658 < s1;+  const SBool  s660 = s658 < s640;+  const SBool  s661 = s659 || s660;+  const SWord8 s662 = (s658 >> 1) | (s658 << 7);+  const SWord8 s663 = 128 | s662;+  const SWord8 s664 = 127 & s662;+  const SWord8 s665 = s661 ? s663 : s664;+  const SWord8 s666 = (s665 >> 1) | (s665 << 7);+  const SWord8 s667 = 128 | s666;+  const SWord8 s668 = 127 & s666;+  const SWord8 s669 = s584 ? s667 : s668;+  const SWord8 s670 = s1 + s665;+  const SBool  s671 = s670 < s1;+  const SBool  s672 = s670 < s665;+  const SBool  s673 = s671 || s672;+  const SWord8 s674 = (s670 >> 1) | (s670 << 7);+  const SWord8 s675 = 128 | s674;+  const SWord8 s676 = 127 & s674;+  const SWord8 s677 = s673 ? s675 : s676;+  const SWord8 s678 = s585 ? s669 : s677;+  const SWord8 s679 = s566 ? s657 : s678;+  const SWord8 s680 = s544 ? s632 : s679;+  const SWord8 s681 = s1 + s570;+  const SBool  s682 = (SBool) ((s681 >> 0) & 1);+  const SBool  s683 = false != s682;+  const SWord8 s684 = s683 ? s574 : s575;+  const SBool  s685 = (SBool) ((s684 >> 0) & 1);+  const SBool  s686 = false != s685;+  const SWord8 s687 = s686 ? s580 : s581;+  const SBool  s688 = (SBool) ((s687 >> 0) & 1);+  const SBool  s689 = false != s688;+  const SBool  s690 = false == s689;+  const SBool  s691 = s681 < s1;+  const SBool  s692 = s681 < s570;+  const SBool  s693 = s691 || s692;+  const SWord8 s694 = (s681 >> 1) | (s681 << 7);+  const SWord8 s695 = 128 | s694;+  const SWord8 s696 = 127 & s694;+  const SWord8 s697 = s693 ? s695 : s696;+  const SWord8 s698 = (s697 >> 1) | (s697 << 7);+  const SWord8 s699 = 128 | s698;+  const SWord8 s700 = 127 & s698;+  const SWord8 s701 = s543 ? s699 : s700;+  const SWord8 s702 = (s701 >> 1) | (s701 << 7);+  const SWord8 s703 = 128 | s702;+  const SWord8 s704 = 127 & s702;+  const SWord8 s705 = s565 ? s703 : s704;+  const SWord8 s706 = (s705 >> 1) | (s705 << 7);+  const SWord8 s707 = 128 | s706;+  const SWord8 s708 = 127 & s706;+  const SWord8 s709 = s689 ? s707 : s708;+  const SWord8 s710 = s1 + s705;+  const SBool  s711 = s710 < s1;+  const SBool  s712 = s710 < s705;+  const SBool  s713 = s711 || s712;+  const SWord8 s714 = (s710 >> 1) | (s710 << 7);+  const SWord8 s715 = 128 | s714;+  const SWord8 s716 = 127 & s714;+  const SWord8 s717 = s713 ? s715 : s716;+  const SWord8 s718 = s690 ? s709 : s717;+  const SWord8 s719 = s1 + s701;+  const SBool  s720 = s719 < s1;+  const SBool  s721 = s719 < s701;+  const SBool  s722 = s720 || s721;+  const SWord8 s723 = (s719 >> 1) | (s719 << 7);+  const SWord8 s724 = 128 | s723;+  const SWord8 s725 = 127 & s723;+  const SWord8 s726 = s722 ? s724 : s725;+  const SWord8 s727 = (s726 >> 1) | (s726 << 7);+  const SWord8 s728 = 128 | s727;+  const SWord8 s729 = 127 & s727;+  const SWord8 s730 = s689 ? s728 : s729;+  const SWord8 s731 = s1 + s726;+  const SBool  s732 = s731 < s1;+  const SBool  s733 = s731 < s726;+  const SBool  s734 = s732 || s733;+  const SWord8 s735 = (s731 >> 1) | (s731 << 7);+  const SWord8 s736 = 128 | s735;+  const SWord8 s737 = 127 & s735;+  const SWord8 s738 = s734 ? s736 : s737;+  const SWord8 s739 = s690 ? s730 : s738;+  const SWord8 s740 = s566 ? s718 : s739;+  const SWord8 s741 = s1 + s697;+  const SBool  s742 = s741 < s1;+  const SBool  s743 = s741 < s697;+  const SBool  s744 = s742 || s743;+  const SWord8 s745 = (s741 >> 1) | (s741 << 7);+  const SWord8 s746 = 128 | s745;+  const SWord8 s747 = 127 & s745;+  const SWord8 s748 = s744 ? s746 : s747;+  const SWord8 s749 = (s748 >> 1) | (s748 << 7);+  const SWord8 s750 = 128 | s749;+  const SWord8 s751 = 127 & s749;+  const SWord8 s752 = s565 ? s750 : s751;+  const SWord8 s753 = (s752 >> 1) | (s752 << 7);+  const SWord8 s754 = 128 | s753;+  const SWord8 s755 = 127 & s753;+  const SWord8 s756 = s689 ? s754 : s755;+  const SWord8 s757 = s1 + s752;+  const SBool  s758 = s757 < s1;+  const SBool  s759 = s757 < s752;+  const SBool  s760 = s758 || s759;+  const SWord8 s761 = (s757 >> 1) | (s757 << 7);+  const SWord8 s762 = 128 | s761;+  const SWord8 s763 = 127 & s761;+  const SWord8 s764 = s760 ? s762 : s763;+  const SWord8 s765 = s690 ? s756 : s764;+  const SWord8 s766 = s1 + s748;+  const SBool  s767 = s766 < s1;+  const SBool  s768 = s766 < s748;+  const SBool  s769 = s767 || s768;+  const SWord8 s770 = (s766 >> 1) | (s766 << 7);+  const SWord8 s771 = 128 | s770;+  const SWord8 s772 = 127 & s770;+  const SWord8 s773 = s769 ? s771 : s772;+  const SWord8 s774 = (s773 >> 1) | (s773 << 7);+  const SWord8 s775 = 128 | s774;+  const SWord8 s776 = 127 & s774;+  const SWord8 s777 = s689 ? s775 : s776;+  const SWord8 s778 = s1 + s773;+  const SBool  s779 = s778 < s1;+  const SBool  s780 = s778 < s773;+  const SBool  s781 = s779 || s780;+  const SWord8 s782 = (s778 >> 1) | (s778 << 7);+  const SWord8 s783 = 128 | s782;+  const SWord8 s784 = 127 & s782;+  const SWord8 s785 = s781 ? s783 : s784;+  const SWord8 s786 = s690 ? s777 : s785;+  const SWord8 s787 = s566 ? s765 : s786;+  const SWord8 s788 = s544 ? s740 : s787;+  const SWord8 s789 = s36 ? s680 : s788;+  const SWord8 s790 = s1 + s551;+  const SBool  s791 = (SBool) ((s790 >> 0) & 1);+  const SBool  s792 = false != s791;+  const SWord8 s793 = s792 ? s555 : s556;+  const SBool  s794 = (SBool) ((s793 >> 0) & 1);+  const SBool  s795 = false != s794;+  const SWord8 s796 = s795 ? s561 : s562;+  const SBool  s797 = (SBool) ((s796 >> 0) & 1);+  const SBool  s798 = false != s797;+  const SBool  s799 = false == s798;+  const SBool  s800 = s790 < s1;+  const SBool  s801 = s790 < s551;+  const SBool  s802 = s800 || s801;+  const SWord8 s803 = (s790 >> 1) | (s790 << 7);+  const SWord8 s804 = 128 | s803;+  const SWord8 s805 = 127 & s803;+  const SWord8 s806 = s802 ? s804 : s805;+  const SBool  s807 = (SBool) ((s806 >> 0) & 1);+  const SBool  s808 = false != s807;+  const SWord8 s809 = (s793 >> 1) | (s793 << 7);+  const SWord8 s810 = 128 | s809;+  const SWord8 s811 = 127 & s809;+  const SWord8 s812 = s808 ? s810 : s811;+  const SBool  s813 = (SBool) ((s812 >> 0) & 1);+  const SBool  s814 = false != s813;+  const SWord8 s815 = (s796 >> 1) | (s796 << 7);+  const SWord8 s816 = 128 | s815;+  const SWord8 s817 = 127 & s815;+  const SWord8 s818 = s814 ? s816 : s817;+  const SBool  s819 = (SBool) ((s818 >> 0) & 1);+  const SBool  s820 = false != s819;+  const SBool  s821 = false == s820;+  const SWord8 s822 = (s806 >> 1) | (s806 << 7);+  const SWord8 s823 = 128 | s822;+  const SWord8 s824 = 127 & s822;+  const SWord8 s825 = s35 ? s823 : s824;+  const SWord8 s826 = (s825 >> 1) | (s825 << 7);+  const SWord8 s827 = 128 | s826;+  const SWord8 s828 = 127 & s826;+  const SWord8 s829 = s543 ? s827 : s828;+  const SWord8 s830 = (s829 >> 1) | (s829 << 7);+  const SWord8 s831 = 128 | s830;+  const SWord8 s832 = 127 & s830;+  const SWord8 s833 = s798 ? s831 : s832;+  const SWord8 s834 = (s833 >> 1) | (s833 << 7);+  const SWord8 s835 = 128 | s834;+  const SWord8 s836 = 127 & s834;+  const SWord8 s837 = s820 ? s835 : s836;+  const SWord8 s838 = s1 + s833;+  const SBool  s839 = s838 < s1;+  const SBool  s840 = s838 < s833;+  const SBool  s841 = s839 || s840;+  const SWord8 s842 = (s838 >> 1) | (s838 << 7);+  const SWord8 s843 = 128 | s842;+  const SWord8 s844 = 127 & s842;+  const SWord8 s845 = s841 ? s843 : s844;+  const SWord8 s846 = s821 ? s837 : s845;+  const SWord8 s847 = s1 + s829;+  const SBool  s848 = s847 < s1;+  const SBool  s849 = s847 < s829;+  const SBool  s850 = s848 || s849;+  const SWord8 s851 = (s847 >> 1) | (s847 << 7);+  const SWord8 s852 = 128 | s851;+  const SWord8 s853 = 127 & s851;+  const SWord8 s854 = s850 ? s852 : s853;+  const SWord8 s855 = (s854 >> 1) | (s854 << 7);+  const SWord8 s856 = 128 | s855;+  const SWord8 s857 = 127 & s855;+  const SWord8 s858 = s820 ? s856 : s857;+  const SWord8 s859 = s1 + s854;+  const SBool  s860 = s859 < s1;+  const SBool  s861 = s859 < s854;+  const SBool  s862 = s860 || s861;+  const SWord8 s863 = (s859 >> 1) | (s859 << 7);+  const SWord8 s864 = 128 | s863;+  const SWord8 s865 = 127 & s863;+  const SWord8 s866 = s862 ? s864 : s865;+  const SWord8 s867 = s821 ? s858 : s866;+  const SWord8 s868 = s799 ? s846 : s867;+  const SWord8 s869 = s1 + s825;+  const SBool  s870 = s869 < s1;+  const SBool  s871 = s869 < s825;+  const SBool  s872 = s870 || s871;+  const SWord8 s873 = (s869 >> 1) | (s869 << 7);+  const SWord8 s874 = 128 | s873;+  const SWord8 s875 = 127 & s873;+  const SWord8 s876 = s872 ? s874 : s875;+  const SWord8 s877 = (s876 >> 1) | (s876 << 7);+  const SWord8 s878 = 128 | s877;+  const SWord8 s879 = 127 & s877;+  const SWord8 s880 = s798 ? s878 : s879;+  const SWord8 s881 = (s880 >> 1) | (s880 << 7);+  const SWord8 s882 = 128 | s881;+  const SWord8 s883 = 127 & s881;+  const SWord8 s884 = s820 ? s882 : s883;+  const SWord8 s885 = s1 + s880;+  const SBool  s886 = s885 < s1;+  const SBool  s887 = s885 < s880;+  const SBool  s888 = s886 || s887;+  const SWord8 s889 = (s885 >> 1) | (s885 << 7);+  const SWord8 s890 = 128 | s889;+  const SWord8 s891 = 127 & s889;+  const SWord8 s892 = s888 ? s890 : s891;+  const SWord8 s893 = s821 ? s884 : s892;+  const SWord8 s894 = s1 + s876;+  const SBool  s895 = s894 < s1;+  const SBool  s896 = s894 < s876;+  const SBool  s897 = s895 || s896;+  const SWord8 s898 = (s894 >> 1) | (s894 << 7);+  const SWord8 s899 = 128 | s898;+  const SWord8 s900 = 127 & s898;+  const SWord8 s901 = s897 ? s899 : s900;+  const SWord8 s902 = (s901 >> 1) | (s901 << 7);+  const SWord8 s903 = 128 | s902;+  const SWord8 s904 = 127 & s902;+  const SWord8 s905 = s820 ? s903 : s904;+  const SWord8 s906 = s1 + s901;+  const SBool  s907 = s906 < s1;+  const SBool  s908 = s906 < s901;+  const SBool  s909 = s907 || s908;+  const SWord8 s910 = (s906 >> 1) | (s906 << 7);+  const SWord8 s911 = 128 | s910;+  const SWord8 s912 = 127 & s910;+  const SWord8 s913 = s909 ? s911 : s912;+  const SWord8 s914 = s821 ? s905 : s913;+  const SWord8 s915 = s799 ? s893 : s914;+  const SWord8 s916 = s544 ? s868 : s915;+  const SWord8 s917 = s1 + s806;+  const SBool  s918 = (SBool) ((s917 >> 0) & 1);+  const SBool  s919 = false != s918;+  const SWord8 s920 = s919 ? s810 : s811;+  const SBool  s921 = (SBool) ((s920 >> 0) & 1);+  const SBool  s922 = false != s921;+  const SWord8 s923 = s922 ? s816 : s817;+  const SBool  s924 = (SBool) ((s923 >> 0) & 1);+  const SBool  s925 = false != s924;+  const SBool  s926 = false == s925;+  const SBool  s927 = s917 < s1;+  const SBool  s928 = s917 < s806;+  const SBool  s929 = s927 || s928;+  const SWord8 s930 = (s917 >> 1) | (s917 << 7);+  const SWord8 s931 = 128 | s930;+  const SWord8 s932 = 127 & s930;+  const SWord8 s933 = s929 ? s931 : s932;+  const SWord8 s934 = (s933 >> 1) | (s933 << 7);+  const SWord8 s935 = 128 | s934;+  const SWord8 s936 = 127 & s934;+  const SWord8 s937 = s543 ? s935 : s936;+  const SWord8 s938 = (s937 >> 1) | (s937 << 7);+  const SWord8 s939 = 128 | s938;+  const SWord8 s940 = 127 & s938;+  const SWord8 s941 = s798 ? s939 : s940;+  const SWord8 s942 = (s941 >> 1) | (s941 << 7);+  const SWord8 s943 = 128 | s942;+  const SWord8 s944 = 127 & s942;+  const SWord8 s945 = s925 ? s943 : s944;+  const SWord8 s946 = s1 + s941;+  const SBool  s947 = s946 < s1;+  const SBool  s948 = s946 < s941;+  const SBool  s949 = s947 || s948;+  const SWord8 s950 = (s946 >> 1) | (s946 << 7);+  const SWord8 s951 = 128 | s950;+  const SWord8 s952 = 127 & s950;+  const SWord8 s953 = s949 ? s951 : s952;+  const SWord8 s954 = s926 ? s945 : s953;+  const SWord8 s955 = s1 + s937;+  const SBool  s956 = s955 < s1;+  const SBool  s957 = s955 < s937;+  const SBool  s958 = s956 || s957;+  const SWord8 s959 = (s955 >> 1) | (s955 << 7);+  const SWord8 s960 = 128 | s959;+  const SWord8 s961 = 127 & s959;+  const SWord8 s962 = s958 ? s960 : s961;+  const SWord8 s963 = (s962 >> 1) | (s962 << 7);+  const SWord8 s964 = 128 | s963;+  const SWord8 s965 = 127 & s963;+  const SWord8 s966 = s925 ? s964 : s965;+  const SWord8 s967 = s1 + s962;+  const SBool  s968 = s967 < s1;+  const SBool  s969 = s967 < s962;+  const SBool  s970 = s968 || s969;+  const SWord8 s971 = (s967 >> 1) | (s967 << 7);+  const SWord8 s972 = 128 | s971;+  const SWord8 s973 = 127 & s971;+  const SWord8 s974 = s970 ? s972 : s973;+  const SWord8 s975 = s926 ? s966 : s974;+  const SWord8 s976 = s799 ? s954 : s975;+  const SWord8 s977 = s1 + s933;+  const SBool  s978 = s977 < s1;+  const SBool  s979 = s977 < s933;+  const SBool  s980 = s978 || s979;+  const SWord8 s981 = (s977 >> 1) | (s977 << 7);+  const SWord8 s982 = 128 | s981;+  const SWord8 s983 = 127 & s981;+  const SWord8 s984 = s980 ? s982 : s983;+  const SWord8 s985 = (s984 >> 1) | (s984 << 7);+  const SWord8 s986 = 128 | s985;+  const SWord8 s987 = 127 & s985;+  const SWord8 s988 = s798 ? s986 : s987;+  const SWord8 s989 = (s988 >> 1) | (s988 << 7);+  const SWord8 s990 = 128 | s989;+  const SWord8 s991 = 127 & s989;+  const SWord8 s992 = s925 ? s990 : s991;+  const SWord8 s993 = s1 + s988;+  const SBool  s994 = s993 < s1;+  const SBool  s995 = s993 < s988;+  const SBool  s996 = s994 || s995;+  const SWord8 s997 = (s993 >> 1) | (s993 << 7);+  const SWord8 s998 = 128 | s997;+  const SWord8 s999 = 127 & s997;+  const SWord8 s1000 = s996 ? s998 : s999;+  const SWord8 s1001 = s926 ? s992 : s1000;+  const SWord8 s1002 = s1 + s984;+  const SBool  s1003 = s1002 < s1;+  const SBool  s1004 = s1002 < s984;+  const SBool  s1005 = s1003 || s1004;+  const SWord8 s1006 = (s1002 >> 1) | (s1002 << 7);+  const SWord8 s1007 = 128 | s1006;+  const SWord8 s1008 = 127 & s1006;+  const SWord8 s1009 = s1005 ? s1007 : s1008;+  const SWord8 s1010 = (s1009 >> 1) | (s1009 << 7);+  const SWord8 s1011 = 128 | s1010;+  const SWord8 s1012 = 127 & s1010;+  const SWord8 s1013 = s925 ? s1011 : s1012;+  const SWord8 s1014 = s1 + s1009;+  const SBool  s1015 = s1014 < s1;+  const SBool  s1016 = s1014 < s1009;+  const SBool  s1017 = s1015 || s1016;+  const SWord8 s1018 = (s1014 >> 1) | (s1014 << 7);+  const SWord8 s1019 = 128 | s1018;+  const SWord8 s1020 = 127 & s1018;+  const SWord8 s1021 = s1017 ? s1019 : s1020;+  const SWord8 s1022 = s926 ? s1013 : s1021;+  const SWord8 s1023 = s799 ? s1001 : s1022;+  const SWord8 s1024 = s544 ? s976 : s1023;+  const SWord8 s1025 = s36 ? s916 : s1024;+  const SWord8 s1026 = s21 ? s789 : s1025;+  const SWord8 s1027 = s16 ? s534 : s1026;+  const SWord8 s1028 = s1 + s24;+  const SBool  s1029 = (SBool) ((s1028 >> 0) & 1);+  const SBool  s1030 = false != s1029;+  const SWord8 s1031 = s1030 ? 128 : 0;+  const SBool  s1032 = (SBool) ((s1031 >> 0) & 1);+  const SBool  s1033 = false != s1032;+  const SWord8 s1034 = s1033 ? s31 : s32;+  const SBool  s1035 = (SBool) ((s1034 >> 0) & 1);+  const SBool  s1036 = false != s1035;+  const SBool  s1037 = false == s1036;+  const SBool  s1038 = s1028 < s1;+  const SBool  s1039 = s1028 < s24;+  const SBool  s1040 = s1038 || s1039;+  const SWord8 s1041 = (s1028 >> 1) | (s1028 << 7);+  const SWord8 s1042 = 128 | s1041;+  const SWord8 s1043 = 127 & s1041;+  const SWord8 s1044 = s1040 ? s1042 : s1043;+  const SBool  s1045 = (SBool) ((s1044 >> 0) & 1);+  const SBool  s1046 = false != s1045;+  const SWord8 s1047 = (s1031 >> 1) | (s1031 << 7);+  const SWord8 s1048 = 128 | s1047;+  const SWord8 s1049 = 127 & s1047;+  const SWord8 s1050 = s1046 ? s1048 : s1049;+  const SBool  s1051 = (SBool) ((s1050 >> 0) & 1);+  const SBool  s1052 = false != s1051;+  const SWord8 s1053 = (s1034 >> 1) | (s1034 << 7);+  const SWord8 s1054 = 128 | s1053;+  const SWord8 s1055 = 127 & s1053;+  const SWord8 s1056 = s1052 ? s1054 : s1055;+  const SBool  s1057 = (SBool) ((s1056 >> 0) & 1);+  const SBool  s1058 = false != s1057;+  const SBool  s1059 = false == s1058;+  const SWord8 s1060 = (s1044 >> 1) | (s1044 << 7);+  const SWord8 s1061 = 128 | s1060;+  const SWord8 s1062 = 127 & s1060;+  const SWord8 s1063 = s15 ? s1061 : s1062;+  const SBool  s1064 = (SBool) ((s1063 >> 0) & 1);+  const SBool  s1065 = false != s1064;+  const SWord8 s1066 = (s1050 >> 1) | (s1050 << 7);+  const SWord8 s1067 = 128 | s1066;+  const SWord8 s1068 = 127 & s1066;+  const SWord8 s1069 = s1065 ? s1067 : s1068;+  const SBool  s1070 = (SBool) ((s1069 >> 0) & 1);+  const SBool  s1071 = false != s1070;+  const SWord8 s1072 = (s1056 >> 1) | (s1056 << 7);+  const SWord8 s1073 = 128 | s1072;+  const SWord8 s1074 = 127 & s1072;+  const SWord8 s1075 = s1071 ? s1073 : s1074;+  const SBool  s1076 = (SBool) ((s1075 >> 0) & 1);+  const SBool  s1077 = false != s1076;+  const SBool  s1078 = false == s1077;+  const SWord8 s1079 = (s1063 >> 1) | (s1063 << 7);+  const SWord8 s1080 = 128 | s1079;+  const SWord8 s1081 = 127 & s1079;+  const SWord8 s1082 = s20 ? s1080 : s1081;+  const SBool  s1083 = (SBool) ((s1082 >> 0) & 1);+  const SBool  s1084 = false != s1083;+  const SWord8 s1085 = (s1069 >> 1) | (s1069 << 7);+  const SWord8 s1086 = 128 | s1085;+  const SWord8 s1087 = 127 & s1085;+  const SWord8 s1088 = s1084 ? s1086 : s1087;+  const SBool  s1089 = (SBool) ((s1088 >> 0) & 1);+  const SBool  s1090 = false != s1089;+  const SWord8 s1091 = (s1075 >> 1) | (s1075 << 7);+  const SWord8 s1092 = 128 | s1091;+  const SWord8 s1093 = 127 & s1091;+  const SWord8 s1094 = s1090 ? s1092 : s1093;+  const SBool  s1095 = (SBool) ((s1094 >> 0) & 1);+  const SBool  s1096 = false != s1095;+  const SBool  s1097 = false == s1096;+  const SWord8 s1098 = (s1082 >> 1) | (s1082 << 7);+  const SWord8 s1099 = 128 | s1098;+  const SWord8 s1100 = 127 & s1098;+  const SWord8 s1101 = s1036 ? s1099 : s1100;+  const SWord8 s1102 = (s1101 >> 1) | (s1101 << 7);+  const SWord8 s1103 = 128 | s1102;+  const SWord8 s1104 = 127 & s1102;+  const SWord8 s1105 = s1058 ? s1103 : s1104;+  const SWord8 s1106 = (s1105 >> 1) | (s1105 << 7);+  const SWord8 s1107 = 128 | s1106;+  const SWord8 s1108 = 127 & s1106;+  const SWord8 s1109 = s1077 ? s1107 : s1108;+  const SWord8 s1110 = (s1109 >> 1) | (s1109 << 7);+  const SWord8 s1111 = 128 | s1110;+  const SWord8 s1112 = 127 & s1110;+  const SWord8 s1113 = s1096 ? s1111 : s1112;+  const SWord8 s1114 = s1 + s1109;+  const SBool  s1115 = s1114 < s1;+  const SBool  s1116 = s1114 < s1109;+  const SBool  s1117 = s1115 || s1116;+  const SWord8 s1118 = (s1114 >> 1) | (s1114 << 7);+  const SWord8 s1119 = 128 | s1118;+  const SWord8 s1120 = 127 & s1118;+  const SWord8 s1121 = s1117 ? s1119 : s1120;+  const SWord8 s1122 = s1097 ? s1113 : s1121;+  const SWord8 s1123 = s1 + s1105;+  const SBool  s1124 = s1123 < s1;+  const SBool  s1125 = s1123 < s1105;+  const SBool  s1126 = s1124 || s1125;+  const SWord8 s1127 = (s1123 >> 1) | (s1123 << 7);+  const SWord8 s1128 = 128 | s1127;+  const SWord8 s1129 = 127 & s1127;+  const SWord8 s1130 = s1126 ? s1128 : s1129;+  const SWord8 s1131 = (s1130 >> 1) | (s1130 << 7);+  const SWord8 s1132 = 128 | s1131;+  const SWord8 s1133 = 127 & s1131;+  const SWord8 s1134 = s1096 ? s1132 : s1133;+  const SWord8 s1135 = s1 + s1130;+  const SBool  s1136 = s1135 < s1;+  const SBool  s1137 = s1135 < s1130;+  const SBool  s1138 = s1136 || s1137;+  const SWord8 s1139 = (s1135 >> 1) | (s1135 << 7);+  const SWord8 s1140 = 128 | s1139;+  const SWord8 s1141 = 127 & s1139;+  const SWord8 s1142 = s1138 ? s1140 : s1141;+  const SWord8 s1143 = s1097 ? s1134 : s1142;+  const SWord8 s1144 = s1078 ? s1122 : s1143;+  const SWord8 s1145 = s1 + s1101;+  const SBool  s1146 = s1145 < s1;+  const SBool  s1147 = s1145 < s1101;+  const SBool  s1148 = s1146 || s1147;+  const SWord8 s1149 = (s1145 >> 1) | (s1145 << 7);+  const SWord8 s1150 = 128 | s1149;+  const SWord8 s1151 = 127 & s1149;+  const SWord8 s1152 = s1148 ? s1150 : s1151;+  const SWord8 s1153 = (s1152 >> 1) | (s1152 << 7);+  const SWord8 s1154 = 128 | s1153;+  const SWord8 s1155 = 127 & s1153;+  const SWord8 s1156 = s1077 ? s1154 : s1155;+  const SWord8 s1157 = (s1156 >> 1) | (s1156 << 7);+  const SWord8 s1158 = 128 | s1157;+  const SWord8 s1159 = 127 & s1157;+  const SWord8 s1160 = s1096 ? s1158 : s1159;+  const SWord8 s1161 = s1 + s1156;+  const SBool  s1162 = s1161 < s1;+  const SBool  s1163 = s1161 < s1156;+  const SBool  s1164 = s1162 || s1163;+  const SWord8 s1165 = (s1161 >> 1) | (s1161 << 7);+  const SWord8 s1166 = 128 | s1165;+  const SWord8 s1167 = 127 & s1165;+  const SWord8 s1168 = s1164 ? s1166 : s1167;+  const SWord8 s1169 = s1097 ? s1160 : s1168;+  const SWord8 s1170 = s1 + s1152;+  const SBool  s1171 = s1170 < s1;+  const SBool  s1172 = s1170 < s1152;+  const SBool  s1173 = s1171 || s1172;+  const SWord8 s1174 = (s1170 >> 1) | (s1170 << 7);+  const SWord8 s1175 = 128 | s1174;+  const SWord8 s1176 = 127 & s1174;+  const SWord8 s1177 = s1173 ? s1175 : s1176;+  const SWord8 s1178 = (s1177 >> 1) | (s1177 << 7);+  const SWord8 s1179 = 128 | s1178;+  const SWord8 s1180 = 127 & s1178;+  const SWord8 s1181 = s1096 ? s1179 : s1180;+  const SWord8 s1182 = s1 + s1177;+  const SBool  s1183 = s1182 < s1;+  const SBool  s1184 = s1182 < s1177;+  const SBool  s1185 = s1183 || s1184;+  const SWord8 s1186 = (s1182 >> 1) | (s1182 << 7);+  const SWord8 s1187 = 128 | s1186;+  const SWord8 s1188 = 127 & s1186;+  const SWord8 s1189 = s1185 ? s1187 : s1188;+  const SWord8 s1190 = s1097 ? s1181 : s1189;+  const SWord8 s1191 = s1078 ? s1169 : s1190;+  const SWord8 s1192 = s1059 ? s1144 : s1191;+  const SWord8 s1193 = s1 + s1082;+  const SBool  s1194 = (SBool) ((s1193 >> 0) & 1);+  const SBool  s1195 = false != s1194;+  const SWord8 s1196 = s1195 ? s1086 : s1087;+  const SBool  s1197 = (SBool) ((s1196 >> 0) & 1);+  const SBool  s1198 = false != s1197;+  const SWord8 s1199 = s1198 ? s1092 : s1093;+  const SBool  s1200 = (SBool) ((s1199 >> 0) & 1);+  const SBool  s1201 = false != s1200;+  const SBool  s1202 = false == s1201;+  const SBool  s1203 = s1193 < s1;+  const SBool  s1204 = s1193 < s1082;+  const SBool  s1205 = s1203 || s1204;+  const SWord8 s1206 = (s1193 >> 1) | (s1193 << 7);+  const SWord8 s1207 = 128 | s1206;+  const SWord8 s1208 = 127 & s1206;+  const SWord8 s1209 = s1205 ? s1207 : s1208;+  const SWord8 s1210 = (s1209 >> 1) | (s1209 << 7);+  const SWord8 s1211 = 128 | s1210;+  const SWord8 s1212 = 127 & s1210;+  const SWord8 s1213 = s1058 ? s1211 : s1212;+  const SWord8 s1214 = (s1213 >> 1) | (s1213 << 7);+  const SWord8 s1215 = 128 | s1214;+  const SWord8 s1216 = 127 & s1214;+  const SWord8 s1217 = s1077 ? s1215 : s1216;+  const SWord8 s1218 = (s1217 >> 1) | (s1217 << 7);+  const SWord8 s1219 = 128 | s1218;+  const SWord8 s1220 = 127 & s1218;+  const SWord8 s1221 = s1201 ? s1219 : s1220;+  const SWord8 s1222 = s1 + s1217;+  const SBool  s1223 = s1222 < s1;+  const SBool  s1224 = s1222 < s1217;+  const SBool  s1225 = s1223 || s1224;+  const SWord8 s1226 = (s1222 >> 1) | (s1222 << 7);+  const SWord8 s1227 = 128 | s1226;+  const SWord8 s1228 = 127 & s1226;+  const SWord8 s1229 = s1225 ? s1227 : s1228;+  const SWord8 s1230 = s1202 ? s1221 : s1229;+  const SWord8 s1231 = s1 + s1213;+  const SBool  s1232 = s1231 < s1;+  const SBool  s1233 = s1231 < s1213;+  const SBool  s1234 = s1232 || s1233;+  const SWord8 s1235 = (s1231 >> 1) | (s1231 << 7);+  const SWord8 s1236 = 128 | s1235;+  const SWord8 s1237 = 127 & s1235;+  const SWord8 s1238 = s1234 ? s1236 : s1237;+  const SWord8 s1239 = (s1238 >> 1) | (s1238 << 7);+  const SWord8 s1240 = 128 | s1239;+  const SWord8 s1241 = 127 & s1239;+  const SWord8 s1242 = s1201 ? s1240 : s1241;+  const SWord8 s1243 = s1 + s1238;+  const SBool  s1244 = s1243 < s1;+  const SBool  s1245 = s1243 < s1238;+  const SBool  s1246 = s1244 || s1245;+  const SWord8 s1247 = (s1243 >> 1) | (s1243 << 7);+  const SWord8 s1248 = 128 | s1247;+  const SWord8 s1249 = 127 & s1247;+  const SWord8 s1250 = s1246 ? s1248 : s1249;+  const SWord8 s1251 = s1202 ? s1242 : s1250;+  const SWord8 s1252 = s1078 ? s1230 : s1251;+  const SWord8 s1253 = s1 + s1209;+  const SBool  s1254 = s1253 < s1;+  const SBool  s1255 = s1253 < s1209;+  const SBool  s1256 = s1254 || s1255;+  const SWord8 s1257 = (s1253 >> 1) | (s1253 << 7);+  const SWord8 s1258 = 128 | s1257;+  const SWord8 s1259 = 127 & s1257;+  const SWord8 s1260 = s1256 ? s1258 : s1259;+  const SWord8 s1261 = (s1260 >> 1) | (s1260 << 7);+  const SWord8 s1262 = 128 | s1261;+  const SWord8 s1263 = 127 & s1261;+  const SWord8 s1264 = s1077 ? s1262 : s1263;+  const SWord8 s1265 = (s1264 >> 1) | (s1264 << 7);+  const SWord8 s1266 = 128 | s1265;+  const SWord8 s1267 = 127 & s1265;+  const SWord8 s1268 = s1201 ? s1266 : s1267;+  const SWord8 s1269 = s1 + s1264;+  const SBool  s1270 = s1269 < s1;+  const SBool  s1271 = s1269 < s1264;+  const SBool  s1272 = s1270 || s1271;+  const SWord8 s1273 = (s1269 >> 1) | (s1269 << 7);+  const SWord8 s1274 = 128 | s1273;+  const SWord8 s1275 = 127 & s1273;+  const SWord8 s1276 = s1272 ? s1274 : s1275;+  const SWord8 s1277 = s1202 ? s1268 : s1276;+  const SWord8 s1278 = s1 + s1260;+  const SBool  s1279 = s1278 < s1;+  const SBool  s1280 = s1278 < s1260;+  const SBool  s1281 = s1279 || s1280;+  const SWord8 s1282 = (s1278 >> 1) | (s1278 << 7);+  const SWord8 s1283 = 128 | s1282;+  const SWord8 s1284 = 127 & s1282;+  const SWord8 s1285 = s1281 ? s1283 : s1284;+  const SWord8 s1286 = (s1285 >> 1) | (s1285 << 7);+  const SWord8 s1287 = 128 | s1286;+  const SWord8 s1288 = 127 & s1286;+  const SWord8 s1289 = s1201 ? s1287 : s1288;+  const SWord8 s1290 = s1 + s1285;+  const SBool  s1291 = s1290 < s1;+  const SBool  s1292 = s1290 < s1285;+  const SBool  s1293 = s1291 || s1292;+  const SWord8 s1294 = (s1290 >> 1) | (s1290 << 7);+  const SWord8 s1295 = 128 | s1294;+  const SWord8 s1296 = 127 & s1294;+  const SWord8 s1297 = s1293 ? s1295 : s1296;+  const SWord8 s1298 = s1202 ? s1289 : s1297;+  const SWord8 s1299 = s1078 ? s1277 : s1298;+  const SWord8 s1300 = s1059 ? s1252 : s1299;+  const SWord8 s1301 = s1037 ? s1192 : s1300;+  const SWord8 s1302 = s1 + s1063;+  const SBool  s1303 = (SBool) ((s1302 >> 0) & 1);+  const SBool  s1304 = false != s1303;+  const SWord8 s1305 = s1304 ? s1067 : s1068;+  const SBool  s1306 = (SBool) ((s1305 >> 0) & 1);+  const SBool  s1307 = false != s1306;+  const SWord8 s1308 = s1307 ? s1073 : s1074;+  const SBool  s1309 = (SBool) ((s1308 >> 0) & 1);+  const SBool  s1310 = false != s1309;+  const SBool  s1311 = false == s1310;+  const SBool  s1312 = s1302 < s1;+  const SBool  s1313 = s1302 < s1063;+  const SBool  s1314 = s1312 || s1313;+  const SWord8 s1315 = (s1302 >> 1) | (s1302 << 7);+  const SWord8 s1316 = 128 | s1315;+  const SWord8 s1317 = 127 & s1315;+  const SWord8 s1318 = s1314 ? s1316 : s1317;+  const SBool  s1319 = (SBool) ((s1318 >> 0) & 1);+  const SBool  s1320 = false != s1319;+  const SWord8 s1321 = (s1305 >> 1) | (s1305 << 7);+  const SWord8 s1322 = 128 | s1321;+  const SWord8 s1323 = 127 & s1321;+  const SWord8 s1324 = s1320 ? s1322 : s1323;+  const SBool  s1325 = (SBool) ((s1324 >> 0) & 1);+  const SBool  s1326 = false != s1325;+  const SWord8 s1327 = (s1308 >> 1) | (s1308 << 7);+  const SWord8 s1328 = 128 | s1327;+  const SWord8 s1329 = 127 & s1327;+  const SWord8 s1330 = s1326 ? s1328 : s1329;+  const SBool  s1331 = (SBool) ((s1330 >> 0) & 1);+  const SBool  s1332 = false != s1331;+  const SBool  s1333 = false == s1332;+  const SWord8 s1334 = (s1318 >> 1) | (s1318 << 7);+  const SWord8 s1335 = 128 | s1334;+  const SWord8 s1336 = 127 & s1334;+  const SWord8 s1337 = s1036 ? s1335 : s1336;+  const SWord8 s1338 = (s1337 >> 1) | (s1337 << 7);+  const SWord8 s1339 = 128 | s1338;+  const SWord8 s1340 = 127 & s1338;+  const SWord8 s1341 = s1058 ? s1339 : s1340;+  const SWord8 s1342 = (s1341 >> 1) | (s1341 << 7);+  const SWord8 s1343 = 128 | s1342;+  const SWord8 s1344 = 127 & s1342;+  const SWord8 s1345 = s1310 ? s1343 : s1344;+  const SWord8 s1346 = (s1345 >> 1) | (s1345 << 7);+  const SWord8 s1347 = 128 | s1346;+  const SWord8 s1348 = 127 & s1346;+  const SWord8 s1349 = s1332 ? s1347 : s1348;+  const SWord8 s1350 = s1 + s1345;+  const SBool  s1351 = s1350 < s1;+  const SBool  s1352 = s1350 < s1345;+  const SBool  s1353 = s1351 || s1352;+  const SWord8 s1354 = (s1350 >> 1) | (s1350 << 7);+  const SWord8 s1355 = 128 | s1354;+  const SWord8 s1356 = 127 & s1354;+  const SWord8 s1357 = s1353 ? s1355 : s1356;+  const SWord8 s1358 = s1333 ? s1349 : s1357;+  const SWord8 s1359 = s1 + s1341;+  const SBool  s1360 = s1359 < s1;+  const SBool  s1361 = s1359 < s1341;+  const SBool  s1362 = s1360 || s1361;+  const SWord8 s1363 = (s1359 >> 1) | (s1359 << 7);+  const SWord8 s1364 = 128 | s1363;+  const SWord8 s1365 = 127 & s1363;+  const SWord8 s1366 = s1362 ? s1364 : s1365;+  const SWord8 s1367 = (s1366 >> 1) | (s1366 << 7);+  const SWord8 s1368 = 128 | s1367;+  const SWord8 s1369 = 127 & s1367;+  const SWord8 s1370 = s1332 ? s1368 : s1369;+  const SWord8 s1371 = s1 + s1366;+  const SBool  s1372 = s1371 < s1;+  const SBool  s1373 = s1371 < s1366;+  const SBool  s1374 = s1372 || s1373;+  const SWord8 s1375 = (s1371 >> 1) | (s1371 << 7);+  const SWord8 s1376 = 128 | s1375;+  const SWord8 s1377 = 127 & s1375;+  const SWord8 s1378 = s1374 ? s1376 : s1377;+  const SWord8 s1379 = s1333 ? s1370 : s1378;+  const SWord8 s1380 = s1311 ? s1358 : s1379;+  const SWord8 s1381 = s1 + s1337;+  const SBool  s1382 = s1381 < s1;+  const SBool  s1383 = s1381 < s1337;+  const SBool  s1384 = s1382 || s1383;+  const SWord8 s1385 = (s1381 >> 1) | (s1381 << 7);+  const SWord8 s1386 = 128 | s1385;+  const SWord8 s1387 = 127 & s1385;+  const SWord8 s1388 = s1384 ? s1386 : s1387;+  const SWord8 s1389 = (s1388 >> 1) | (s1388 << 7);+  const SWord8 s1390 = 128 | s1389;+  const SWord8 s1391 = 127 & s1389;+  const SWord8 s1392 = s1310 ? s1390 : s1391;+  const SWord8 s1393 = (s1392 >> 1) | (s1392 << 7);+  const SWord8 s1394 = 128 | s1393;+  const SWord8 s1395 = 127 & s1393;+  const SWord8 s1396 = s1332 ? s1394 : s1395;+  const SWord8 s1397 = s1 + s1392;+  const SBool  s1398 = s1397 < s1;+  const SBool  s1399 = s1397 < s1392;+  const SBool  s1400 = s1398 || s1399;+  const SWord8 s1401 = (s1397 >> 1) | (s1397 << 7);+  const SWord8 s1402 = 128 | s1401;+  const SWord8 s1403 = 127 & s1401;+  const SWord8 s1404 = s1400 ? s1402 : s1403;+  const SWord8 s1405 = s1333 ? s1396 : s1404;+  const SWord8 s1406 = s1 + s1388;+  const SBool  s1407 = s1406 < s1;+  const SBool  s1408 = s1406 < s1388;+  const SBool  s1409 = s1407 || s1408;+  const SWord8 s1410 = (s1406 >> 1) | (s1406 << 7);+  const SWord8 s1411 = 128 | s1410;+  const SWord8 s1412 = 127 & s1410;+  const SWord8 s1413 = s1409 ? s1411 : s1412;+  const SWord8 s1414 = (s1413 >> 1) | (s1413 << 7);+  const SWord8 s1415 = 128 | s1414;+  const SWord8 s1416 = 127 & s1414;+  const SWord8 s1417 = s1332 ? s1415 : s1416;+  const SWord8 s1418 = s1 + s1413;+  const SBool  s1419 = s1418 < s1;+  const SBool  s1420 = s1418 < s1413;+  const SBool  s1421 = s1419 || s1420;+  const SWord8 s1422 = (s1418 >> 1) | (s1418 << 7);+  const SWord8 s1423 = 128 | s1422;+  const SWord8 s1424 = 127 & s1422;+  const SWord8 s1425 = s1421 ? s1423 : s1424;+  const SWord8 s1426 = s1333 ? s1417 : s1425;+  const SWord8 s1427 = s1311 ? s1405 : s1426;+  const SWord8 s1428 = s1059 ? s1380 : s1427;+  const SWord8 s1429 = s1 + s1318;+  const SBool  s1430 = (SBool) ((s1429 >> 0) & 1);+  const SBool  s1431 = false != s1430;+  const SWord8 s1432 = s1431 ? s1322 : s1323;+  const SBool  s1433 = (SBool) ((s1432 >> 0) & 1);+  const SBool  s1434 = false != s1433;+  const SWord8 s1435 = s1434 ? s1328 : s1329;+  const SBool  s1436 = (SBool) ((s1435 >> 0) & 1);+  const SBool  s1437 = false != s1436;+  const SBool  s1438 = false == s1437;+  const SBool  s1439 = s1429 < s1;+  const SBool  s1440 = s1429 < s1318;+  const SBool  s1441 = s1439 || s1440;+  const SWord8 s1442 = (s1429 >> 1) | (s1429 << 7);+  const SWord8 s1443 = 128 | s1442;+  const SWord8 s1444 = 127 & s1442;+  const SWord8 s1445 = s1441 ? s1443 : s1444;+  const SWord8 s1446 = (s1445 >> 1) | (s1445 << 7);+  const SWord8 s1447 = 128 | s1446;+  const SWord8 s1448 = 127 & s1446;+  const SWord8 s1449 = s1058 ? s1447 : s1448;+  const SWord8 s1450 = (s1449 >> 1) | (s1449 << 7);+  const SWord8 s1451 = 128 | s1450;+  const SWord8 s1452 = 127 & s1450;+  const SWord8 s1453 = s1310 ? s1451 : s1452;+  const SWord8 s1454 = (s1453 >> 1) | (s1453 << 7);+  const SWord8 s1455 = 128 | s1454;+  const SWord8 s1456 = 127 & s1454;+  const SWord8 s1457 = s1437 ? s1455 : s1456;+  const SWord8 s1458 = s1 + s1453;+  const SBool  s1459 = s1458 < s1;+  const SBool  s1460 = s1458 < s1453;+  const SBool  s1461 = s1459 || s1460;+  const SWord8 s1462 = (s1458 >> 1) | (s1458 << 7);+  const SWord8 s1463 = 128 | s1462;+  const SWord8 s1464 = 127 & s1462;+  const SWord8 s1465 = s1461 ? s1463 : s1464;+  const SWord8 s1466 = s1438 ? s1457 : s1465;+  const SWord8 s1467 = s1 + s1449;+  const SBool  s1468 = s1467 < s1;+  const SBool  s1469 = s1467 < s1449;+  const SBool  s1470 = s1468 || s1469;+  const SWord8 s1471 = (s1467 >> 1) | (s1467 << 7);+  const SWord8 s1472 = 128 | s1471;+  const SWord8 s1473 = 127 & s1471;+  const SWord8 s1474 = s1470 ? s1472 : s1473;+  const SWord8 s1475 = (s1474 >> 1) | (s1474 << 7);+  const SWord8 s1476 = 128 | s1475;+  const SWord8 s1477 = 127 & s1475;+  const SWord8 s1478 = s1437 ? s1476 : s1477;+  const SWord8 s1479 = s1 + s1474;+  const SBool  s1480 = s1479 < s1;+  const SBool  s1481 = s1479 < s1474;+  const SBool  s1482 = s1480 || s1481;+  const SWord8 s1483 = (s1479 >> 1) | (s1479 << 7);+  const SWord8 s1484 = 128 | s1483;+  const SWord8 s1485 = 127 & s1483;+  const SWord8 s1486 = s1482 ? s1484 : s1485;+  const SWord8 s1487 = s1438 ? s1478 : s1486;+  const SWord8 s1488 = s1311 ? s1466 : s1487;+  const SWord8 s1489 = s1 + s1445;+  const SBool  s1490 = s1489 < s1;+  const SBool  s1491 = s1489 < s1445;+  const SBool  s1492 = s1490 || s1491;+  const SWord8 s1493 = (s1489 >> 1) | (s1489 << 7);+  const SWord8 s1494 = 128 | s1493;+  const SWord8 s1495 = 127 & s1493;+  const SWord8 s1496 = s1492 ? s1494 : s1495;+  const SWord8 s1497 = (s1496 >> 1) | (s1496 << 7);+  const SWord8 s1498 = 128 | s1497;+  const SWord8 s1499 = 127 & s1497;+  const SWord8 s1500 = s1310 ? s1498 : s1499;+  const SWord8 s1501 = (s1500 >> 1) | (s1500 << 7);+  const SWord8 s1502 = 128 | s1501;+  const SWord8 s1503 = 127 & s1501;+  const SWord8 s1504 = s1437 ? s1502 : s1503;+  const SWord8 s1505 = s1 + s1500;+  const SBool  s1506 = s1505 < s1;+  const SBool  s1507 = s1505 < s1500;+  const SBool  s1508 = s1506 || s1507;+  const SWord8 s1509 = (s1505 >> 1) | (s1505 << 7);+  const SWord8 s1510 = 128 | s1509;+  const SWord8 s1511 = 127 & s1509;+  const SWord8 s1512 = s1508 ? s1510 : s1511;+  const SWord8 s1513 = s1438 ? s1504 : s1512;+  const SWord8 s1514 = s1 + s1496;+  const SBool  s1515 = s1514 < s1;+  const SBool  s1516 = s1514 < s1496;+  const SBool  s1517 = s1515 || s1516;+  const SWord8 s1518 = (s1514 >> 1) | (s1514 << 7);+  const SWord8 s1519 = 128 | s1518;+  const SWord8 s1520 = 127 & s1518;+  const SWord8 s1521 = s1517 ? s1519 : s1520;+  const SWord8 s1522 = (s1521 >> 1) | (s1521 << 7);+  const SWord8 s1523 = 128 | s1522;+  const SWord8 s1524 = 127 & s1522;+  const SWord8 s1525 = s1437 ? s1523 : s1524;+  const SWord8 s1526 = s1 + s1521;+  const SBool  s1527 = s1526 < s1;+  const SBool  s1528 = s1526 < s1521;+  const SBool  s1529 = s1527 || s1528;+  const SWord8 s1530 = (s1526 >> 1) | (s1526 << 7);+  const SWord8 s1531 = 128 | s1530;+  const SWord8 s1532 = 127 & s1530;+  const SWord8 s1533 = s1529 ? s1531 : s1532;+  const SWord8 s1534 = s1438 ? s1525 : s1533;+  const SWord8 s1535 = s1311 ? s1513 : s1534;+  const SWord8 s1536 = s1059 ? s1488 : s1535;+  const SWord8 s1537 = s1037 ? s1428 : s1536;+  const SWord8 s1538 = s21 ? s1301 : s1537;+  const SWord8 s1539 = s1 + s1044;+  const SBool  s1540 = (SBool) ((s1539 >> 0) & 1);+  const SBool  s1541 = false != s1540;+  const SWord8 s1542 = s1541 ? s1048 : s1049;+  const SBool  s1543 = (SBool) ((s1542 >> 0) & 1);+  const SBool  s1544 = false != s1543;+  const SWord8 s1545 = s1544 ? s1054 : s1055;+  const SBool  s1546 = (SBool) ((s1545 >> 0) & 1);+  const SBool  s1547 = false != s1546;+  const SBool  s1548 = false == s1547;+  const SBool  s1549 = s1539 < s1;+  const SBool  s1550 = s1539 < s1044;+  const SBool  s1551 = s1549 || s1550;+  const SWord8 s1552 = (s1539 >> 1) | (s1539 << 7);+  const SWord8 s1553 = 128 | s1552;+  const SWord8 s1554 = 127 & s1552;+  const SWord8 s1555 = s1551 ? s1553 : s1554;+  const SBool  s1556 = (SBool) ((s1555 >> 0) & 1);+  const SBool  s1557 = false != s1556;+  const SWord8 s1558 = (s1542 >> 1) | (s1542 << 7);+  const SWord8 s1559 = 128 | s1558;+  const SWord8 s1560 = 127 & s1558;+  const SWord8 s1561 = s1557 ? s1559 : s1560;+  const SBool  s1562 = (SBool) ((s1561 >> 0) & 1);+  const SBool  s1563 = false != s1562;+  const SWord8 s1564 = (s1545 >> 1) | (s1545 << 7);+  const SWord8 s1565 = 128 | s1564;+  const SWord8 s1566 = 127 & s1564;+  const SWord8 s1567 = s1563 ? s1565 : s1566;+  const SBool  s1568 = (SBool) ((s1567 >> 0) & 1);+  const SBool  s1569 = false != s1568;+  const SBool  s1570 = false == s1569;+  const SWord8 s1571 = (s1555 >> 1) | (s1555 << 7);+  const SWord8 s1572 = 128 | s1571;+  const SWord8 s1573 = 127 & s1571;+  const SWord8 s1574 = s20 ? s1572 : s1573;+  const SBool  s1575 = (SBool) ((s1574 >> 0) & 1);+  const SBool  s1576 = false != s1575;+  const SWord8 s1577 = (s1561 >> 1) | (s1561 << 7);+  const SWord8 s1578 = 128 | s1577;+  const SWord8 s1579 = 127 & s1577;+  const SWord8 s1580 = s1576 ? s1578 : s1579;+  const SBool  s1581 = (SBool) ((s1580 >> 0) & 1);+  const SBool  s1582 = false != s1581;+  const SWord8 s1583 = (s1567 >> 1) | (s1567 << 7);+  const SWord8 s1584 = 128 | s1583;+  const SWord8 s1585 = 127 & s1583;+  const SWord8 s1586 = s1582 ? s1584 : s1585;+  const SBool  s1587 = (SBool) ((s1586 >> 0) & 1);+  const SBool  s1588 = false != s1587;+  const SBool  s1589 = false == s1588;+  const SWord8 s1590 = (s1574 >> 1) | (s1574 << 7);+  const SWord8 s1591 = 128 | s1590;+  const SWord8 s1592 = 127 & s1590;+  const SWord8 s1593 = s1036 ? s1591 : s1592;+  const SWord8 s1594 = (s1593 >> 1) | (s1593 << 7);+  const SWord8 s1595 = 128 | s1594;+  const SWord8 s1596 = 127 & s1594;+  const SWord8 s1597 = s1547 ? s1595 : s1596;+  const SWord8 s1598 = (s1597 >> 1) | (s1597 << 7);+  const SWord8 s1599 = 128 | s1598;+  const SWord8 s1600 = 127 & s1598;+  const SWord8 s1601 = s1569 ? s1599 : s1600;+  const SWord8 s1602 = (s1601 >> 1) | (s1601 << 7);+  const SWord8 s1603 = 128 | s1602;+  const SWord8 s1604 = 127 & s1602;+  const SWord8 s1605 = s1588 ? s1603 : s1604;+  const SWord8 s1606 = s1 + s1601;+  const SBool  s1607 = s1606 < s1;+  const SBool  s1608 = s1606 < s1601;+  const SBool  s1609 = s1607 || s1608;+  const SWord8 s1610 = (s1606 >> 1) | (s1606 << 7);+  const SWord8 s1611 = 128 | s1610;+  const SWord8 s1612 = 127 & s1610;+  const SWord8 s1613 = s1609 ? s1611 : s1612;+  const SWord8 s1614 = s1589 ? s1605 : s1613;+  const SWord8 s1615 = s1 + s1597;+  const SBool  s1616 = s1615 < s1;+  const SBool  s1617 = s1615 < s1597;+  const SBool  s1618 = s1616 || s1617;+  const SWord8 s1619 = (s1615 >> 1) | (s1615 << 7);+  const SWord8 s1620 = 128 | s1619;+  const SWord8 s1621 = 127 & s1619;+  const SWord8 s1622 = s1618 ? s1620 : s1621;+  const SWord8 s1623 = (s1622 >> 1) | (s1622 << 7);+  const SWord8 s1624 = 128 | s1623;+  const SWord8 s1625 = 127 & s1623;+  const SWord8 s1626 = s1588 ? s1624 : s1625;+  const SWord8 s1627 = s1 + s1622;+  const SBool  s1628 = s1627 < s1;+  const SBool  s1629 = s1627 < s1622;+  const SBool  s1630 = s1628 || s1629;+  const SWord8 s1631 = (s1627 >> 1) | (s1627 << 7);+  const SWord8 s1632 = 128 | s1631;+  const SWord8 s1633 = 127 & s1631;+  const SWord8 s1634 = s1630 ? s1632 : s1633;+  const SWord8 s1635 = s1589 ? s1626 : s1634;+  const SWord8 s1636 = s1570 ? s1614 : s1635;+  const SWord8 s1637 = s1 + s1593;+  const SBool  s1638 = s1637 < s1;+  const SBool  s1639 = s1637 < s1593;+  const SBool  s1640 = s1638 || s1639;+  const SWord8 s1641 = (s1637 >> 1) | (s1637 << 7);+  const SWord8 s1642 = 128 | s1641;+  const SWord8 s1643 = 127 & s1641;+  const SWord8 s1644 = s1640 ? s1642 : s1643;+  const SWord8 s1645 = (s1644 >> 1) | (s1644 << 7);+  const SWord8 s1646 = 128 | s1645;+  const SWord8 s1647 = 127 & s1645;+  const SWord8 s1648 = s1569 ? s1646 : s1647;+  const SWord8 s1649 = (s1648 >> 1) | (s1648 << 7);+  const SWord8 s1650 = 128 | s1649;+  const SWord8 s1651 = 127 & s1649;+  const SWord8 s1652 = s1588 ? s1650 : s1651;+  const SWord8 s1653 = s1 + s1648;+  const SBool  s1654 = s1653 < s1;+  const SBool  s1655 = s1653 < s1648;+  const SBool  s1656 = s1654 || s1655;+  const SWord8 s1657 = (s1653 >> 1) | (s1653 << 7);+  const SWord8 s1658 = 128 | s1657;+  const SWord8 s1659 = 127 & s1657;+  const SWord8 s1660 = s1656 ? s1658 : s1659;+  const SWord8 s1661 = s1589 ? s1652 : s1660;+  const SWord8 s1662 = s1 + s1644;+  const SBool  s1663 = s1662 < s1;+  const SBool  s1664 = s1662 < s1644;+  const SBool  s1665 = s1663 || s1664;+  const SWord8 s1666 = (s1662 >> 1) | (s1662 << 7);+  const SWord8 s1667 = 128 | s1666;+  const SWord8 s1668 = 127 & s1666;+  const SWord8 s1669 = s1665 ? s1667 : s1668;+  const SWord8 s1670 = (s1669 >> 1) | (s1669 << 7);+  const SWord8 s1671 = 128 | s1670;+  const SWord8 s1672 = 127 & s1670;+  const SWord8 s1673 = s1588 ? s1671 : s1672;+  const SWord8 s1674 = s1 + s1669;+  const SBool  s1675 = s1674 < s1;+  const SBool  s1676 = s1674 < s1669;+  const SBool  s1677 = s1675 || s1676;+  const SWord8 s1678 = (s1674 >> 1) | (s1674 << 7);+  const SWord8 s1679 = 128 | s1678;+  const SWord8 s1680 = 127 & s1678;+  const SWord8 s1681 = s1677 ? s1679 : s1680;+  const SWord8 s1682 = s1589 ? s1673 : s1681;+  const SWord8 s1683 = s1570 ? s1661 : s1682;+  const SWord8 s1684 = s1548 ? s1636 : s1683;+  const SWord8 s1685 = s1 + s1574;+  const SBool  s1686 = (SBool) ((s1685 >> 0) & 1);+  const SBool  s1687 = false != s1686;+  const SWord8 s1688 = s1687 ? s1578 : s1579;+  const SBool  s1689 = (SBool) ((s1688 >> 0) & 1);+  const SBool  s1690 = false != s1689;+  const SWord8 s1691 = s1690 ? s1584 : s1585;+  const SBool  s1692 = (SBool) ((s1691 >> 0) & 1);+  const SBool  s1693 = false != s1692;+  const SBool  s1694 = false == s1693;+  const SBool  s1695 = s1685 < s1;+  const SBool  s1696 = s1685 < s1574;+  const SBool  s1697 = s1695 || s1696;+  const SWord8 s1698 = (s1685 >> 1) | (s1685 << 7);+  const SWord8 s1699 = 128 | s1698;+  const SWord8 s1700 = 127 & s1698;+  const SWord8 s1701 = s1697 ? s1699 : s1700;+  const SWord8 s1702 = (s1701 >> 1) | (s1701 << 7);+  const SWord8 s1703 = 128 | s1702;+  const SWord8 s1704 = 127 & s1702;+  const SWord8 s1705 = s1547 ? s1703 : s1704;+  const SWord8 s1706 = (s1705 >> 1) | (s1705 << 7);+  const SWord8 s1707 = 128 | s1706;+  const SWord8 s1708 = 127 & s1706;+  const SWord8 s1709 = s1569 ? s1707 : s1708;+  const SWord8 s1710 = (s1709 >> 1) | (s1709 << 7);+  const SWord8 s1711 = 128 | s1710;+  const SWord8 s1712 = 127 & s1710;+  const SWord8 s1713 = s1693 ? s1711 : s1712;+  const SWord8 s1714 = s1 + s1709;+  const SBool  s1715 = s1714 < s1;+  const SBool  s1716 = s1714 < s1709;+  const SBool  s1717 = s1715 || s1716;+  const SWord8 s1718 = (s1714 >> 1) | (s1714 << 7);+  const SWord8 s1719 = 128 | s1718;+  const SWord8 s1720 = 127 & s1718;+  const SWord8 s1721 = s1717 ? s1719 : s1720;+  const SWord8 s1722 = s1694 ? s1713 : s1721;+  const SWord8 s1723 = s1 + s1705;+  const SBool  s1724 = s1723 < s1;+  const SBool  s1725 = s1723 < s1705;+  const SBool  s1726 = s1724 || s1725;+  const SWord8 s1727 = (s1723 >> 1) | (s1723 << 7);+  const SWord8 s1728 = 128 | s1727;+  const SWord8 s1729 = 127 & s1727;+  const SWord8 s1730 = s1726 ? s1728 : s1729;+  const SWord8 s1731 = (s1730 >> 1) | (s1730 << 7);+  const SWord8 s1732 = 128 | s1731;+  const SWord8 s1733 = 127 & s1731;+  const SWord8 s1734 = s1693 ? s1732 : s1733;+  const SWord8 s1735 = s1 + s1730;+  const SBool  s1736 = s1735 < s1;+  const SBool  s1737 = s1735 < s1730;+  const SBool  s1738 = s1736 || s1737;+  const SWord8 s1739 = (s1735 >> 1) | (s1735 << 7);+  const SWord8 s1740 = 128 | s1739;+  const SWord8 s1741 = 127 & s1739;+  const SWord8 s1742 = s1738 ? s1740 : s1741;+  const SWord8 s1743 = s1694 ? s1734 : s1742;+  const SWord8 s1744 = s1570 ? s1722 : s1743;+  const SWord8 s1745 = s1 + s1701;+  const SBool  s1746 = s1745 < s1;+  const SBool  s1747 = s1745 < s1701;+  const SBool  s1748 = s1746 || s1747;+  const SWord8 s1749 = (s1745 >> 1) | (s1745 << 7);+  const SWord8 s1750 = 128 | s1749;+  const SWord8 s1751 = 127 & s1749;+  const SWord8 s1752 = s1748 ? s1750 : s1751;+  const SWord8 s1753 = (s1752 >> 1) | (s1752 << 7);+  const SWord8 s1754 = 128 | s1753;+  const SWord8 s1755 = 127 & s1753;+  const SWord8 s1756 = s1569 ? s1754 : s1755;+  const SWord8 s1757 = (s1756 >> 1) | (s1756 << 7);+  const SWord8 s1758 = 128 | s1757;+  const SWord8 s1759 = 127 & s1757;+  const SWord8 s1760 = s1693 ? s1758 : s1759;+  const SWord8 s1761 = s1 + s1756;+  const SBool  s1762 = s1761 < s1;+  const SBool  s1763 = s1761 < s1756;+  const SBool  s1764 = s1762 || s1763;+  const SWord8 s1765 = (s1761 >> 1) | (s1761 << 7);+  const SWord8 s1766 = 128 | s1765;+  const SWord8 s1767 = 127 & s1765;+  const SWord8 s1768 = s1764 ? s1766 : s1767;+  const SWord8 s1769 = s1694 ? s1760 : s1768;+  const SWord8 s1770 = s1 + s1752;+  const SBool  s1771 = s1770 < s1;+  const SBool  s1772 = s1770 < s1752;+  const SBool  s1773 = s1771 || s1772;+  const SWord8 s1774 = (s1770 >> 1) | (s1770 << 7);+  const SWord8 s1775 = 128 | s1774;+  const SWord8 s1776 = 127 & s1774;+  const SWord8 s1777 = s1773 ? s1775 : s1776;+  const SWord8 s1778 = (s1777 >> 1) | (s1777 << 7);+  const SWord8 s1779 = 128 | s1778;+  const SWord8 s1780 = 127 & s1778;+  const SWord8 s1781 = s1693 ? s1779 : s1780;+  const SWord8 s1782 = s1 + s1777;+  const SBool  s1783 = s1782 < s1;+  const SBool  s1784 = s1782 < s1777;+  const SBool  s1785 = s1783 || s1784;+  const SWord8 s1786 = (s1782 >> 1) | (s1782 << 7);+  const SWord8 s1787 = 128 | s1786;+  const SWord8 s1788 = 127 & s1786;+  const SWord8 s1789 = s1785 ? s1787 : s1788;+  const SWord8 s1790 = s1694 ? s1781 : s1789;+  const SWord8 s1791 = s1570 ? s1769 : s1790;+  const SWord8 s1792 = s1548 ? s1744 : s1791;+  const SWord8 s1793 = s1037 ? s1684 : s1792;+  const SWord8 s1794 = s1 + s1555;+  const SBool  s1795 = (SBool) ((s1794 >> 0) & 1);+  const SBool  s1796 = false != s1795;+  const SWord8 s1797 = s1796 ? s1559 : s1560;+  const SBool  s1798 = (SBool) ((s1797 >> 0) & 1);+  const SBool  s1799 = false != s1798;+  const SWord8 s1800 = s1799 ? s1565 : s1566;+  const SBool  s1801 = (SBool) ((s1800 >> 0) & 1);+  const SBool  s1802 = false != s1801;+  const SBool  s1803 = false == s1802;+  const SBool  s1804 = s1794 < s1;+  const SBool  s1805 = s1794 < s1555;+  const SBool  s1806 = s1804 || s1805;+  const SWord8 s1807 = (s1794 >> 1) | (s1794 << 7);+  const SWord8 s1808 = 128 | s1807;+  const SWord8 s1809 = 127 & s1807;+  const SWord8 s1810 = s1806 ? s1808 : s1809;+  const SBool  s1811 = (SBool) ((s1810 >> 0) & 1);+  const SBool  s1812 = false != s1811;+  const SWord8 s1813 = (s1797 >> 1) | (s1797 << 7);+  const SWord8 s1814 = 128 | s1813;+  const SWord8 s1815 = 127 & s1813;+  const SWord8 s1816 = s1812 ? s1814 : s1815;+  const SBool  s1817 = (SBool) ((s1816 >> 0) & 1);+  const SBool  s1818 = false != s1817;+  const SWord8 s1819 = (s1800 >> 1) | (s1800 << 7);+  const SWord8 s1820 = 128 | s1819;+  const SWord8 s1821 = 127 & s1819;+  const SWord8 s1822 = s1818 ? s1820 : s1821;+  const SBool  s1823 = (SBool) ((s1822 >> 0) & 1);+  const SBool  s1824 = false != s1823;+  const SBool  s1825 = false == s1824;+  const SWord8 s1826 = (s1810 >> 1) | (s1810 << 7);+  const SWord8 s1827 = 128 | s1826;+  const SWord8 s1828 = 127 & s1826;+  const SWord8 s1829 = s1036 ? s1827 : s1828;+  const SWord8 s1830 = (s1829 >> 1) | (s1829 << 7);+  const SWord8 s1831 = 128 | s1830;+  const SWord8 s1832 = 127 & s1830;+  const SWord8 s1833 = s1547 ? s1831 : s1832;+  const SWord8 s1834 = (s1833 >> 1) | (s1833 << 7);+  const SWord8 s1835 = 128 | s1834;+  const SWord8 s1836 = 127 & s1834;+  const SWord8 s1837 = s1802 ? s1835 : s1836;+  const SWord8 s1838 = (s1837 >> 1) | (s1837 << 7);+  const SWord8 s1839 = 128 | s1838;+  const SWord8 s1840 = 127 & s1838;+  const SWord8 s1841 = s1824 ? s1839 : s1840;+  const SWord8 s1842 = s1 + s1837;+  const SBool  s1843 = s1842 < s1;+  const SBool  s1844 = s1842 < s1837;+  const SBool  s1845 = s1843 || s1844;+  const SWord8 s1846 = (s1842 >> 1) | (s1842 << 7);+  const SWord8 s1847 = 128 | s1846;+  const SWord8 s1848 = 127 & s1846;+  const SWord8 s1849 = s1845 ? s1847 : s1848;+  const SWord8 s1850 = s1825 ? s1841 : s1849;+  const SWord8 s1851 = s1 + s1833;+  const SBool  s1852 = s1851 < s1;+  const SBool  s1853 = s1851 < s1833;+  const SBool  s1854 = s1852 || s1853;+  const SWord8 s1855 = (s1851 >> 1) | (s1851 << 7);+  const SWord8 s1856 = 128 | s1855;+  const SWord8 s1857 = 127 & s1855;+  const SWord8 s1858 = s1854 ? s1856 : s1857;+  const SWord8 s1859 = (s1858 >> 1) | (s1858 << 7);+  const SWord8 s1860 = 128 | s1859;+  const SWord8 s1861 = 127 & s1859;+  const SWord8 s1862 = s1824 ? s1860 : s1861;+  const SWord8 s1863 = s1 + s1858;+  const SBool  s1864 = s1863 < s1;+  const SBool  s1865 = s1863 < s1858;+  const SBool  s1866 = s1864 || s1865;+  const SWord8 s1867 = (s1863 >> 1) | (s1863 << 7);+  const SWord8 s1868 = 128 | s1867;+  const SWord8 s1869 = 127 & s1867;+  const SWord8 s1870 = s1866 ? s1868 : s1869;+  const SWord8 s1871 = s1825 ? s1862 : s1870;+  const SWord8 s1872 = s1803 ? s1850 : s1871;+  const SWord8 s1873 = s1 + s1829;+  const SBool  s1874 = s1873 < s1;+  const SBool  s1875 = s1873 < s1829;+  const SBool  s1876 = s1874 || s1875;+  const SWord8 s1877 = (s1873 >> 1) | (s1873 << 7);+  const SWord8 s1878 = 128 | s1877;+  const SWord8 s1879 = 127 & s1877;+  const SWord8 s1880 = s1876 ? s1878 : s1879;+  const SWord8 s1881 = (s1880 >> 1) | (s1880 << 7);+  const SWord8 s1882 = 128 | s1881;+  const SWord8 s1883 = 127 & s1881;+  const SWord8 s1884 = s1802 ? s1882 : s1883;+  const SWord8 s1885 = (s1884 >> 1) | (s1884 << 7);+  const SWord8 s1886 = 128 | s1885;+  const SWord8 s1887 = 127 & s1885;+  const SWord8 s1888 = s1824 ? s1886 : s1887;+  const SWord8 s1889 = s1 + s1884;+  const SBool  s1890 = s1889 < s1;+  const SBool  s1891 = s1889 < s1884;+  const SBool  s1892 = s1890 || s1891;+  const SWord8 s1893 = (s1889 >> 1) | (s1889 << 7);+  const SWord8 s1894 = 128 | s1893;+  const SWord8 s1895 = 127 & s1893;+  const SWord8 s1896 = s1892 ? s1894 : s1895;+  const SWord8 s1897 = s1825 ? s1888 : s1896;+  const SWord8 s1898 = s1 + s1880;+  const SBool  s1899 = s1898 < s1;+  const SBool  s1900 = s1898 < s1880;+  const SBool  s1901 = s1899 || s1900;+  const SWord8 s1902 = (s1898 >> 1) | (s1898 << 7);+  const SWord8 s1903 = 128 | s1902;+  const SWord8 s1904 = 127 & s1902;+  const SWord8 s1905 = s1901 ? s1903 : s1904;+  const SWord8 s1906 = (s1905 >> 1) | (s1905 << 7);+  const SWord8 s1907 = 128 | s1906;+  const SWord8 s1908 = 127 & s1906;+  const SWord8 s1909 = s1824 ? s1907 : s1908;+  const SWord8 s1910 = s1 + s1905;+  const SBool  s1911 = s1910 < s1;+  const SBool  s1912 = s1910 < s1905;+  const SBool  s1913 = s1911 || s1912;+  const SWord8 s1914 = (s1910 >> 1) | (s1910 << 7);+  const SWord8 s1915 = 128 | s1914;+  const SWord8 s1916 = 127 & s1914;+  const SWord8 s1917 = s1913 ? s1915 : s1916;+  const SWord8 s1918 = s1825 ? s1909 : s1917;+  const SWord8 s1919 = s1803 ? s1897 : s1918;+  const SWord8 s1920 = s1548 ? s1872 : s1919;+  const SWord8 s1921 = s1 + s1810;+  const SBool  s1922 = (SBool) ((s1921 >> 0) & 1);+  const SBool  s1923 = false != s1922;+  const SWord8 s1924 = s1923 ? s1814 : s1815;+  const SBool  s1925 = (SBool) ((s1924 >> 0) & 1);+  const SBool  s1926 = false != s1925;+  const SWord8 s1927 = s1926 ? s1820 : s1821;+  const SBool  s1928 = (SBool) ((s1927 >> 0) & 1);+  const SBool  s1929 = false != s1928;+  const SBool  s1930 = false == s1929;+  const SBool  s1931 = s1921 < s1;+  const SBool  s1932 = s1921 < s1810;+  const SBool  s1933 = s1931 || s1932;+  const SWord8 s1934 = (s1921 >> 1) | (s1921 << 7);+  const SWord8 s1935 = 128 | s1934;+  const SWord8 s1936 = 127 & s1934;+  const SWord8 s1937 = s1933 ? s1935 : s1936;+  const SWord8 s1938 = (s1937 >> 1) | (s1937 << 7);+  const SWord8 s1939 = 128 | s1938;+  const SWord8 s1940 = 127 & s1938;+  const SWord8 s1941 = s1547 ? s1939 : s1940;+  const SWord8 s1942 = (s1941 >> 1) | (s1941 << 7);+  const SWord8 s1943 = 128 | s1942;+  const SWord8 s1944 = 127 & s1942;+  const SWord8 s1945 = s1802 ? s1943 : s1944;+  const SWord8 s1946 = (s1945 >> 1) | (s1945 << 7);+  const SWord8 s1947 = 128 | s1946;+  const SWord8 s1948 = 127 & s1946;+  const SWord8 s1949 = s1929 ? s1947 : s1948;+  const SWord8 s1950 = s1 + s1945;+  const SBool  s1951 = s1950 < s1;+  const SBool  s1952 = s1950 < s1945;+  const SBool  s1953 = s1951 || s1952;+  const SWord8 s1954 = (s1950 >> 1) | (s1950 << 7);+  const SWord8 s1955 = 128 | s1954;+  const SWord8 s1956 = 127 & s1954;+  const SWord8 s1957 = s1953 ? s1955 : s1956;+  const SWord8 s1958 = s1930 ? s1949 : s1957;+  const SWord8 s1959 = s1 + s1941;+  const SBool  s1960 = s1959 < s1;+  const SBool  s1961 = s1959 < s1941;+  const SBool  s1962 = s1960 || s1961;+  const SWord8 s1963 = (s1959 >> 1) | (s1959 << 7);+  const SWord8 s1964 = 128 | s1963;+  const SWord8 s1965 = 127 & s1963;+  const SWord8 s1966 = s1962 ? s1964 : s1965;+  const SWord8 s1967 = (s1966 >> 1) | (s1966 << 7);+  const SWord8 s1968 = 128 | s1967;+  const SWord8 s1969 = 127 & s1967;+  const SWord8 s1970 = s1929 ? s1968 : s1969;+  const SWord8 s1971 = s1 + s1966;+  const SBool  s1972 = s1971 < s1;+  const SBool  s1973 = s1971 < s1966;+  const SBool  s1974 = s1972 || s1973;+  const SWord8 s1975 = (s1971 >> 1) | (s1971 << 7);+  const SWord8 s1976 = 128 | s1975;+  const SWord8 s1977 = 127 & s1975;+  const SWord8 s1978 = s1974 ? s1976 : s1977;+  const SWord8 s1979 = s1930 ? s1970 : s1978;+  const SWord8 s1980 = s1803 ? s1958 : s1979;+  const SWord8 s1981 = s1 + s1937;+  const SBool  s1982 = s1981 < s1;+  const SBool  s1983 = s1981 < s1937;+  const SBool  s1984 = s1982 || s1983;+  const SWord8 s1985 = (s1981 >> 1) | (s1981 << 7);+  const SWord8 s1986 = 128 | s1985;+  const SWord8 s1987 = 127 & s1985;+  const SWord8 s1988 = s1984 ? s1986 : s1987;+  const SWord8 s1989 = (s1988 >> 1) | (s1988 << 7);+  const SWord8 s1990 = 128 | s1989;+  const SWord8 s1991 = 127 & s1989;+  const SWord8 s1992 = s1802 ? s1990 : s1991;+  const SWord8 s1993 = (s1992 >> 1) | (s1992 << 7);+  const SWord8 s1994 = 128 | s1993;+  const SWord8 s1995 = 127 & s1993;+  const SWord8 s1996 = s1929 ? s1994 : s1995;+  const SWord8 s1997 = s1 + s1992;+  const SBool  s1998 = s1997 < s1;+  const SBool  s1999 = s1997 < s1992;+  const SBool  s2000 = s1998 || s1999;+  const SWord8 s2001 = (s1997 >> 1) | (s1997 << 7);+  const SWord8 s2002 = 128 | s2001;+  const SWord8 s2003 = 127 & s2001;+  const SWord8 s2004 = s2000 ? s2002 : s2003;+  const SWord8 s2005 = s1930 ? s1996 : s2004;+  const SWord8 s2006 = s1 + s1988;+  const SBool  s2007 = s2006 < s1;+  const SBool  s2008 = s2006 < s1988;+  const SBool  s2009 = s2007 || s2008;+  const SWord8 s2010 = (s2006 >> 1) | (s2006 << 7);+  const SWord8 s2011 = 128 | s2010;+  const SWord8 s2012 = 127 & s2010;+  const SWord8 s2013 = s2009 ? s2011 : s2012;+  const SWord8 s2014 = (s2013 >> 1) | (s2013 << 7);+  const SWord8 s2015 = 128 | s2014;+  const SWord8 s2016 = 127 & s2014;+  const SWord8 s2017 = s1929 ? s2015 : s2016;+  const SWord8 s2018 = s1 + s2013;+  const SBool  s2019 = s2018 < s1;+  const SBool  s2020 = s2018 < s2013;+  const SBool  s2021 = s2019 || s2020;+  const SWord8 s2022 = (s2018 >> 1) | (s2018 << 7);+  const SWord8 s2023 = 128 | s2022;+  const SWord8 s2024 = 127 & s2022;+  const SWord8 s2025 = s2021 ? s2023 : s2024;+  const SWord8 s2026 = s1930 ? s2017 : s2025;+  const SWord8 s2027 = s1803 ? s2005 : s2026;+  const SWord8 s2028 = s1548 ? s1980 : s2027;+  const SWord8 s2029 = s1037 ? s1920 : s2028;+  const SWord8 s2030 = s21 ? s1793 : s2029;+  const SWord8 s2031 = s16 ? s1538 : s2030;+  const SWord8 s2032 = s11 ? s1027 : s2031;+  const SBool  s2033 = (SBool) ((s1 >> 0) & 1);+  const SBool  s2034 = false != s2033;+  const SWord8 s2035 = s2034 ? 128 : 0;+  const SBool  s2036 = (SBool) ((s2035 >> 0) & 1);+  const SBool  s2037 = false != s2036;+  const SWord8 s2038 = s17 | 128;+  const SWord8 s2039 = s2037 ? s2038 : s18;+  const SBool  s2040 = (SBool) ((s2039 >> 0) & 1);+  const SBool  s2041 = false != s2040;+  const SBool  s2042 = false == s2041;+  const SWord8 s2043 = (s1 >> 1) | (s1 << 7);+  const SWord8 s2044 = 127 & s2043;+  const SBool  s2045 = (SBool) ((s2044 >> 0) & 1);+  const SBool  s2046 = false != s2045;+  const SWord8 s2047 = (s2035 >> 1) | (s2035 << 7);+  const SWord8 s2048 = 128 | s2047;+  const SWord8 s2049 = 127 & s2047;+  const SWord8 s2050 = s2046 ? s2048 : s2049;+  const SBool  s2051 = (SBool) ((s2050 >> 0) & 1);+  const SBool  s2052 = false != s2051;+  const SWord8 s2053 = (s2039 >> 1) | (s2039 << 7);+  const SWord8 s2054 = 128 | s2053;+  const SWord8 s2055 = 127 & s2053;+  const SWord8 s2056 = s2052 ? s2054 : s2055;+  const SBool  s2057 = (SBool) ((s2056 >> 0) & 1);+  const SBool  s2058 = false != s2057;+  const SBool  s2059 = false == s2058;+  const SWord8 s2060 = (s2044 >> 1) | (s2044 << 7);+  const SWord8 s2061 = 128 | s2060;+  const SWord8 s2062 = 127 & s2060;+  const SWord8 s2063 = s10 ? s2061 : s2062;+  const SBool  s2064 = (SBool) ((s2063 >> 0) & 1);+  const SBool  s2065 = false != s2064;+  const SWord8 s2066 = (s2050 >> 1) | (s2050 << 7);+  const SWord8 s2067 = 128 | s2066;+  const SWord8 s2068 = 127 & s2066;+  const SWord8 s2069 = s2065 ? s2067 : s2068;+  const SBool  s2070 = (SBool) ((s2069 >> 0) & 1);+  const SBool  s2071 = false != s2070;+  const SWord8 s2072 = (s2056 >> 1) | (s2056 << 7);+  const SWord8 s2073 = 128 | s2072;+  const SWord8 s2074 = 127 & s2072;+  const SWord8 s2075 = s2071 ? s2073 : s2074;+  const SBool  s2076 = (SBool) ((s2075 >> 0) & 1);+  const SBool  s2077 = false != s2076;+  const SBool  s2078 = false == s2077;+  const SWord8 s2079 = (s2063 >> 1) | (s2063 << 7);+  const SWord8 s2080 = 128 | s2079;+  const SWord8 s2081 = 127 & s2079;+  const SWord8 s2082 = s15 ? s2080 : s2081;+  const SBool  s2083 = (SBool) ((s2082 >> 0) & 1);+  const SBool  s2084 = false != s2083;+  const SWord8 s2085 = (s2069 >> 1) | (s2069 << 7);+  const SWord8 s2086 = 128 | s2085;+  const SWord8 s2087 = 127 & s2085;+  const SWord8 s2088 = s2084 ? s2086 : s2087;+  const SBool  s2089 = (SBool) ((s2088 >> 0) & 1);+  const SBool  s2090 = false != s2089;+  const SWord8 s2091 = (s2075 >> 1) | (s2075 << 7);+  const SWord8 s2092 = 128 | s2091;+  const SWord8 s2093 = 127 & s2091;+  const SWord8 s2094 = s2090 ? s2092 : s2093;+  const SBool  s2095 = (SBool) ((s2094 >> 0) & 1);+  const SBool  s2096 = false != s2095;+  const SBool  s2097 = false == s2096;+  const SWord8 s2098 = (s2082 >> 1) | (s2082 << 7);+  const SWord8 s2099 = 128 | s2098;+  const SWord8 s2100 = 127 & s2098;+  const SWord8 s2101 = s2041 ? s2099 : s2100;+  const SBool  s2102 = (SBool) ((s2101 >> 0) & 1);+  const SBool  s2103 = false != s2102;+  const SWord8 s2104 = (s2088 >> 1) | (s2088 << 7);+  const SWord8 s2105 = 128 | s2104;+  const SWord8 s2106 = 127 & s2104;+  const SWord8 s2107 = s2103 ? s2105 : s2106;+  const SBool  s2108 = (SBool) ((s2107 >> 0) & 1);+  const SBool  s2109 = false != s2108;+  const SWord8 s2110 = (s2094 >> 1) | (s2094 << 7);+  const SWord8 s2111 = 128 | s2110;+  const SWord8 s2112 = 127 & s2110;+  const SWord8 s2113 = s2109 ? s2111 : s2112;+  const SBool  s2114 = (SBool) ((s2113 >> 0) & 1);+  const SBool  s2115 = false != s2114;+  const SBool  s2116 = false == s2115;+  const SWord8 s2117 = (s2101 >> 1) | (s2101 << 7);+  const SWord8 s2118 = 128 | s2117;+  const SWord8 s2119 = 127 & s2117;+  const SWord8 s2120 = s2058 ? s2118 : s2119;+  const SWord8 s2121 = (s2120 >> 1) | (s2120 << 7);+  const SWord8 s2122 = 128 | s2121;+  const SWord8 s2123 = 127 & s2121;+  const SWord8 s2124 = s2077 ? s2122 : s2123;+  const SWord8 s2125 = (s2124 >> 1) | (s2124 << 7);+  const SWord8 s2126 = 128 | s2125;+  const SWord8 s2127 = 127 & s2125;+  const SWord8 s2128 = s2096 ? s2126 : s2127;+  const SWord8 s2129 = (s2128 >> 1) | (s2128 << 7);+  const SWord8 s2130 = 128 | s2129;+  const SWord8 s2131 = 127 & s2129;+  const SWord8 s2132 = s2115 ? s2130 : s2131;+  const SWord8 s2133 = s1 + s2128;+  const SBool  s2134 = s2133 < s1;+  const SBool  s2135 = s2133 < s2128;+  const SBool  s2136 = s2134 || s2135;+  const SWord8 s2137 = (s2133 >> 1) | (s2133 << 7);+  const SWord8 s2138 = 128 | s2137;+  const SWord8 s2139 = 127 & s2137;+  const SWord8 s2140 = s2136 ? s2138 : s2139;+  const SWord8 s2141 = s2116 ? s2132 : s2140;+  const SWord8 s2142 = s1 + s2124;+  const SBool  s2143 = s2142 < s1;+  const SBool  s2144 = s2142 < s2124;+  const SBool  s2145 = s2143 || s2144;+  const SWord8 s2146 = (s2142 >> 1) | (s2142 << 7);+  const SWord8 s2147 = 128 | s2146;+  const SWord8 s2148 = 127 & s2146;+  const SWord8 s2149 = s2145 ? s2147 : s2148;+  const SWord8 s2150 = (s2149 >> 1) | (s2149 << 7);+  const SWord8 s2151 = 128 | s2150;+  const SWord8 s2152 = 127 & s2150;+  const SWord8 s2153 = s2115 ? s2151 : s2152;+  const SWord8 s2154 = s1 + s2149;+  const SBool  s2155 = s2154 < s1;+  const SBool  s2156 = s2154 < s2149;+  const SBool  s2157 = s2155 || s2156;+  const SWord8 s2158 = (s2154 >> 1) | (s2154 << 7);+  const SWord8 s2159 = 128 | s2158;+  const SWord8 s2160 = 127 & s2158;+  const SWord8 s2161 = s2157 ? s2159 : s2160;+  const SWord8 s2162 = s2116 ? s2153 : s2161;+  const SWord8 s2163 = s2097 ? s2141 : s2162;+  const SWord8 s2164 = s1 + s2120;+  const SBool  s2165 = s2164 < s1;+  const SBool  s2166 = s2164 < s2120;+  const SBool  s2167 = s2165 || s2166;+  const SWord8 s2168 = (s2164 >> 1) | (s2164 << 7);+  const SWord8 s2169 = 128 | s2168;+  const SWord8 s2170 = 127 & s2168;+  const SWord8 s2171 = s2167 ? s2169 : s2170;+  const SWord8 s2172 = (s2171 >> 1) | (s2171 << 7);+  const SWord8 s2173 = 128 | s2172;+  const SWord8 s2174 = 127 & s2172;+  const SWord8 s2175 = s2096 ? s2173 : s2174;+  const SWord8 s2176 = (s2175 >> 1) | (s2175 << 7);+  const SWord8 s2177 = 128 | s2176;+  const SWord8 s2178 = 127 & s2176;+  const SWord8 s2179 = s2115 ? s2177 : s2178;+  const SWord8 s2180 = s1 + s2175;+  const SBool  s2181 = s2180 < s1;+  const SBool  s2182 = s2180 < s2175;+  const SBool  s2183 = s2181 || s2182;+  const SWord8 s2184 = (s2180 >> 1) | (s2180 << 7);+  const SWord8 s2185 = 128 | s2184;+  const SWord8 s2186 = 127 & s2184;+  const SWord8 s2187 = s2183 ? s2185 : s2186;+  const SWord8 s2188 = s2116 ? s2179 : s2187;+  const SWord8 s2189 = s1 + s2171;+  const SBool  s2190 = s2189 < s1;+  const SBool  s2191 = s2189 < s2171;+  const SBool  s2192 = s2190 || s2191;+  const SWord8 s2193 = (s2189 >> 1) | (s2189 << 7);+  const SWord8 s2194 = 128 | s2193;+  const SWord8 s2195 = 127 & s2193;+  const SWord8 s2196 = s2192 ? s2194 : s2195;+  const SWord8 s2197 = (s2196 >> 1) | (s2196 << 7);+  const SWord8 s2198 = 128 | s2197;+  const SWord8 s2199 = 127 & s2197;+  const SWord8 s2200 = s2115 ? s2198 : s2199;+  const SWord8 s2201 = s1 + s2196;+  const SBool  s2202 = s2201 < s1;+  const SBool  s2203 = s2201 < s2196;+  const SBool  s2204 = s2202 || s2203;+  const SWord8 s2205 = (s2201 >> 1) | (s2201 << 7);+  const SWord8 s2206 = 128 | s2205;+  const SWord8 s2207 = 127 & s2205;+  const SWord8 s2208 = s2204 ? s2206 : s2207;+  const SWord8 s2209 = s2116 ? s2200 : s2208;+  const SWord8 s2210 = s2097 ? s2188 : s2209;+  const SWord8 s2211 = s2078 ? s2163 : s2210;+  const SWord8 s2212 = s1 + s2101;+  const SBool  s2213 = (SBool) ((s2212 >> 0) & 1);+  const SBool  s2214 = false != s2213;+  const SWord8 s2215 = s2214 ? s2105 : s2106;+  const SBool  s2216 = (SBool) ((s2215 >> 0) & 1);+  const SBool  s2217 = false != s2216;+  const SWord8 s2218 = s2217 ? s2111 : s2112;+  const SBool  s2219 = (SBool) ((s2218 >> 0) & 1);+  const SBool  s2220 = false != s2219;+  const SBool  s2221 = false == s2220;+  const SBool  s2222 = s2212 < s1;+  const SBool  s2223 = s2212 < s2101;+  const SBool  s2224 = s2222 || s2223;+  const SWord8 s2225 = (s2212 >> 1) | (s2212 << 7);+  const SWord8 s2226 = 128 | s2225;+  const SWord8 s2227 = 127 & s2225;+  const SWord8 s2228 = s2224 ? s2226 : s2227;+  const SWord8 s2229 = (s2228 >> 1) | (s2228 << 7);+  const SWord8 s2230 = 128 | s2229;+  const SWord8 s2231 = 127 & s2229;+  const SWord8 s2232 = s2077 ? s2230 : s2231;+  const SWord8 s2233 = (s2232 >> 1) | (s2232 << 7);+  const SWord8 s2234 = 128 | s2233;+  const SWord8 s2235 = 127 & s2233;+  const SWord8 s2236 = s2096 ? s2234 : s2235;+  const SWord8 s2237 = (s2236 >> 1) | (s2236 << 7);+  const SWord8 s2238 = 128 | s2237;+  const SWord8 s2239 = 127 & s2237;+  const SWord8 s2240 = s2220 ? s2238 : s2239;+  const SWord8 s2241 = s1 + s2236;+  const SBool  s2242 = s2241 < s1;+  const SBool  s2243 = s2241 < s2236;+  const SBool  s2244 = s2242 || s2243;+  const SWord8 s2245 = (s2241 >> 1) | (s2241 << 7);+  const SWord8 s2246 = 128 | s2245;+  const SWord8 s2247 = 127 & s2245;+  const SWord8 s2248 = s2244 ? s2246 : s2247;+  const SWord8 s2249 = s2221 ? s2240 : s2248;+  const SWord8 s2250 = s1 + s2232;+  const SBool  s2251 = s2250 < s1;+  const SBool  s2252 = s2250 < s2232;+  const SBool  s2253 = s2251 || s2252;+  const SWord8 s2254 = (s2250 >> 1) | (s2250 << 7);+  const SWord8 s2255 = 128 | s2254;+  const SWord8 s2256 = 127 & s2254;+  const SWord8 s2257 = s2253 ? s2255 : s2256;+  const SWord8 s2258 = (s2257 >> 1) | (s2257 << 7);+  const SWord8 s2259 = 128 | s2258;+  const SWord8 s2260 = 127 & s2258;+  const SWord8 s2261 = s2220 ? s2259 : s2260;+  const SWord8 s2262 = s1 + s2257;+  const SBool  s2263 = s2262 < s1;+  const SBool  s2264 = s2262 < s2257;+  const SBool  s2265 = s2263 || s2264;+  const SWord8 s2266 = (s2262 >> 1) | (s2262 << 7);+  const SWord8 s2267 = 128 | s2266;+  const SWord8 s2268 = 127 & s2266;+  const SWord8 s2269 = s2265 ? s2267 : s2268;+  const SWord8 s2270 = s2221 ? s2261 : s2269;+  const SWord8 s2271 = s2097 ? s2249 : s2270;+  const SWord8 s2272 = s1 + s2228;+  const SBool  s2273 = s2272 < s1;+  const SBool  s2274 = s2272 < s2228;+  const SBool  s2275 = s2273 || s2274;+  const SWord8 s2276 = (s2272 >> 1) | (s2272 << 7);+  const SWord8 s2277 = 128 | s2276;+  const SWord8 s2278 = 127 & s2276;+  const SWord8 s2279 = s2275 ? s2277 : s2278;+  const SWord8 s2280 = (s2279 >> 1) | (s2279 << 7);+  const SWord8 s2281 = 128 | s2280;+  const SWord8 s2282 = 127 & s2280;+  const SWord8 s2283 = s2096 ? s2281 : s2282;+  const SWord8 s2284 = (s2283 >> 1) | (s2283 << 7);+  const SWord8 s2285 = 128 | s2284;+  const SWord8 s2286 = 127 & s2284;+  const SWord8 s2287 = s2220 ? s2285 : s2286;+  const SWord8 s2288 = s1 + s2283;+  const SBool  s2289 = s2288 < s1;+  const SBool  s2290 = s2288 < s2283;+  const SBool  s2291 = s2289 || s2290;+  const SWord8 s2292 = (s2288 >> 1) | (s2288 << 7);+  const SWord8 s2293 = 128 | s2292;+  const SWord8 s2294 = 127 & s2292;+  const SWord8 s2295 = s2291 ? s2293 : s2294;+  const SWord8 s2296 = s2221 ? s2287 : s2295;+  const SWord8 s2297 = s1 + s2279;+  const SBool  s2298 = s2297 < s1;+  const SBool  s2299 = s2297 < s2279;+  const SBool  s2300 = s2298 || s2299;+  const SWord8 s2301 = (s2297 >> 1) | (s2297 << 7);+  const SWord8 s2302 = 128 | s2301;+  const SWord8 s2303 = 127 & s2301;+  const SWord8 s2304 = s2300 ? s2302 : s2303;+  const SWord8 s2305 = (s2304 >> 1) | (s2304 << 7);+  const SWord8 s2306 = 128 | s2305;+  const SWord8 s2307 = 127 & s2305;+  const SWord8 s2308 = s2220 ? s2306 : s2307;+  const SWord8 s2309 = s1 + s2304;+  const SBool  s2310 = s2309 < s1;+  const SBool  s2311 = s2309 < s2304;+  const SBool  s2312 = s2310 || s2311;+  const SWord8 s2313 = (s2309 >> 1) | (s2309 << 7);+  const SWord8 s2314 = 128 | s2313;+  const SWord8 s2315 = 127 & s2313;+  const SWord8 s2316 = s2312 ? s2314 : s2315;+  const SWord8 s2317 = s2221 ? s2308 : s2316;+  const SWord8 s2318 = s2097 ? s2296 : s2317;+  const SWord8 s2319 = s2078 ? s2271 : s2318;+  const SWord8 s2320 = s2059 ? s2211 : s2319;+  const SWord8 s2321 = s1 + s2082;+  const SBool  s2322 = (SBool) ((s2321 >> 0) & 1);+  const SBool  s2323 = false != s2322;+  const SWord8 s2324 = s2323 ? s2086 : s2087;+  const SBool  s2325 = (SBool) ((s2324 >> 0) & 1);+  const SBool  s2326 = false != s2325;+  const SWord8 s2327 = s2326 ? s2092 : s2093;+  const SBool  s2328 = (SBool) ((s2327 >> 0) & 1);+  const SBool  s2329 = false != s2328;+  const SBool  s2330 = false == s2329;+  const SBool  s2331 = s2321 < s1;+  const SBool  s2332 = s2321 < s2082;+  const SBool  s2333 = s2331 || s2332;+  const SWord8 s2334 = (s2321 >> 1) | (s2321 << 7);+  const SWord8 s2335 = 128 | s2334;+  const SWord8 s2336 = 127 & s2334;+  const SWord8 s2337 = s2333 ? s2335 : s2336;+  const SBool  s2338 = (SBool) ((s2337 >> 0) & 1);+  const SBool  s2339 = false != s2338;+  const SWord8 s2340 = (s2324 >> 1) | (s2324 << 7);+  const SWord8 s2341 = 128 | s2340;+  const SWord8 s2342 = 127 & s2340;+  const SWord8 s2343 = s2339 ? s2341 : s2342;+  const SBool  s2344 = (SBool) ((s2343 >> 0) & 1);+  const SBool  s2345 = false != s2344;+  const SWord8 s2346 = (s2327 >> 1) | (s2327 << 7);+  const SWord8 s2347 = 128 | s2346;+  const SWord8 s2348 = 127 & s2346;+  const SWord8 s2349 = s2345 ? s2347 : s2348;+  const SBool  s2350 = (SBool) ((s2349 >> 0) & 1);+  const SBool  s2351 = false != s2350;+  const SBool  s2352 = false == s2351;+  const SWord8 s2353 = (s2337 >> 1) | (s2337 << 7);+  const SWord8 s2354 = 128 | s2353;+  const SWord8 s2355 = 127 & s2353;+  const SWord8 s2356 = s2058 ? s2354 : s2355;+  const SWord8 s2357 = (s2356 >> 1) | (s2356 << 7);+  const SWord8 s2358 = 128 | s2357;+  const SWord8 s2359 = 127 & s2357;+  const SWord8 s2360 = s2077 ? s2358 : s2359;+  const SWord8 s2361 = (s2360 >> 1) | (s2360 << 7);+  const SWord8 s2362 = 128 | s2361;+  const SWord8 s2363 = 127 & s2361;+  const SWord8 s2364 = s2329 ? s2362 : s2363;+  const SWord8 s2365 = (s2364 >> 1) | (s2364 << 7);+  const SWord8 s2366 = 128 | s2365;+  const SWord8 s2367 = 127 & s2365;+  const SWord8 s2368 = s2351 ? s2366 : s2367;+  const SWord8 s2369 = s1 + s2364;+  const SBool  s2370 = s2369 < s1;+  const SBool  s2371 = s2369 < s2364;+  const SBool  s2372 = s2370 || s2371;+  const SWord8 s2373 = (s2369 >> 1) | (s2369 << 7);+  const SWord8 s2374 = 128 | s2373;+  const SWord8 s2375 = 127 & s2373;+  const SWord8 s2376 = s2372 ? s2374 : s2375;+  const SWord8 s2377 = s2352 ? s2368 : s2376;+  const SWord8 s2378 = s1 + s2360;+  const SBool  s2379 = s2378 < s1;+  const SBool  s2380 = s2378 < s2360;+  const SBool  s2381 = s2379 || s2380;+  const SWord8 s2382 = (s2378 >> 1) | (s2378 << 7);+  const SWord8 s2383 = 128 | s2382;+  const SWord8 s2384 = 127 & s2382;+  const SWord8 s2385 = s2381 ? s2383 : s2384;+  const SWord8 s2386 = (s2385 >> 1) | (s2385 << 7);+  const SWord8 s2387 = 128 | s2386;+  const SWord8 s2388 = 127 & s2386;+  const SWord8 s2389 = s2351 ? s2387 : s2388;+  const SWord8 s2390 = s1 + s2385;+  const SBool  s2391 = s2390 < s1;+  const SBool  s2392 = s2390 < s2385;+  const SBool  s2393 = s2391 || s2392;+  const SWord8 s2394 = (s2390 >> 1) | (s2390 << 7);+  const SWord8 s2395 = 128 | s2394;+  const SWord8 s2396 = 127 & s2394;+  const SWord8 s2397 = s2393 ? s2395 : s2396;+  const SWord8 s2398 = s2352 ? s2389 : s2397;+  const SWord8 s2399 = s2330 ? s2377 : s2398;+  const SWord8 s2400 = s1 + s2356;+  const SBool  s2401 = s2400 < s1;+  const SBool  s2402 = s2400 < s2356;+  const SBool  s2403 = s2401 || s2402;+  const SWord8 s2404 = (s2400 >> 1) | (s2400 << 7);+  const SWord8 s2405 = 128 | s2404;+  const SWord8 s2406 = 127 & s2404;+  const SWord8 s2407 = s2403 ? s2405 : s2406;+  const SWord8 s2408 = (s2407 >> 1) | (s2407 << 7);+  const SWord8 s2409 = 128 | s2408;+  const SWord8 s2410 = 127 & s2408;+  const SWord8 s2411 = s2329 ? s2409 : s2410;+  const SWord8 s2412 = (s2411 >> 1) | (s2411 << 7);+  const SWord8 s2413 = 128 | s2412;+  const SWord8 s2414 = 127 & s2412;+  const SWord8 s2415 = s2351 ? s2413 : s2414;+  const SWord8 s2416 = s1 + s2411;+  const SBool  s2417 = s2416 < s1;+  const SBool  s2418 = s2416 < s2411;+  const SBool  s2419 = s2417 || s2418;+  const SWord8 s2420 = (s2416 >> 1) | (s2416 << 7);+  const SWord8 s2421 = 128 | s2420;+  const SWord8 s2422 = 127 & s2420;+  const SWord8 s2423 = s2419 ? s2421 : s2422;+  const SWord8 s2424 = s2352 ? s2415 : s2423;+  const SWord8 s2425 = s1 + s2407;+  const SBool  s2426 = s2425 < s1;+  const SBool  s2427 = s2425 < s2407;+  const SBool  s2428 = s2426 || s2427;+  const SWord8 s2429 = (s2425 >> 1) | (s2425 << 7);+  const SWord8 s2430 = 128 | s2429;+  const SWord8 s2431 = 127 & s2429;+  const SWord8 s2432 = s2428 ? s2430 : s2431;+  const SWord8 s2433 = (s2432 >> 1) | (s2432 << 7);+  const SWord8 s2434 = 128 | s2433;+  const SWord8 s2435 = 127 & s2433;+  const SWord8 s2436 = s2351 ? s2434 : s2435;+  const SWord8 s2437 = s1 + s2432;+  const SBool  s2438 = s2437 < s1;+  const SBool  s2439 = s2437 < s2432;+  const SBool  s2440 = s2438 || s2439;+  const SWord8 s2441 = (s2437 >> 1) | (s2437 << 7);+  const SWord8 s2442 = 128 | s2441;+  const SWord8 s2443 = 127 & s2441;+  const SWord8 s2444 = s2440 ? s2442 : s2443;+  const SWord8 s2445 = s2352 ? s2436 : s2444;+  const SWord8 s2446 = s2330 ? s2424 : s2445;+  const SWord8 s2447 = s2078 ? s2399 : s2446;+  const SWord8 s2448 = s1 + s2337;+  const SBool  s2449 = (SBool) ((s2448 >> 0) & 1);+  const SBool  s2450 = false != s2449;+  const SWord8 s2451 = s2450 ? s2341 : s2342;+  const SBool  s2452 = (SBool) ((s2451 >> 0) & 1);+  const SBool  s2453 = false != s2452;+  const SWord8 s2454 = s2453 ? s2347 : s2348;+  const SBool  s2455 = (SBool) ((s2454 >> 0) & 1);+  const SBool  s2456 = false != s2455;+  const SBool  s2457 = false == s2456;+  const SBool  s2458 = s2448 < s1;+  const SBool  s2459 = s2448 < s2337;+  const SBool  s2460 = s2458 || s2459;+  const SWord8 s2461 = (s2448 >> 1) | (s2448 << 7);+  const SWord8 s2462 = 128 | s2461;+  const SWord8 s2463 = 127 & s2461;+  const SWord8 s2464 = s2460 ? s2462 : s2463;+  const SWord8 s2465 = (s2464 >> 1) | (s2464 << 7);+  const SWord8 s2466 = 128 | s2465;+  const SWord8 s2467 = 127 & s2465;+  const SWord8 s2468 = s2077 ? s2466 : s2467;+  const SWord8 s2469 = (s2468 >> 1) | (s2468 << 7);+  const SWord8 s2470 = 128 | s2469;+  const SWord8 s2471 = 127 & s2469;+  const SWord8 s2472 = s2329 ? s2470 : s2471;+  const SWord8 s2473 = (s2472 >> 1) | (s2472 << 7);+  const SWord8 s2474 = 128 | s2473;+  const SWord8 s2475 = 127 & s2473;+  const SWord8 s2476 = s2456 ? s2474 : s2475;+  const SWord8 s2477 = s1 + s2472;+  const SBool  s2478 = s2477 < s1;+  const SBool  s2479 = s2477 < s2472;+  const SBool  s2480 = s2478 || s2479;+  const SWord8 s2481 = (s2477 >> 1) | (s2477 << 7);+  const SWord8 s2482 = 128 | s2481;+  const SWord8 s2483 = 127 & s2481;+  const SWord8 s2484 = s2480 ? s2482 : s2483;+  const SWord8 s2485 = s2457 ? s2476 : s2484;+  const SWord8 s2486 = s1 + s2468;+  const SBool  s2487 = s2486 < s1;+  const SBool  s2488 = s2486 < s2468;+  const SBool  s2489 = s2487 || s2488;+  const SWord8 s2490 = (s2486 >> 1) | (s2486 << 7);+  const SWord8 s2491 = 128 | s2490;+  const SWord8 s2492 = 127 & s2490;+  const SWord8 s2493 = s2489 ? s2491 : s2492;+  const SWord8 s2494 = (s2493 >> 1) | (s2493 << 7);+  const SWord8 s2495 = 128 | s2494;+  const SWord8 s2496 = 127 & s2494;+  const SWord8 s2497 = s2456 ? s2495 : s2496;+  const SWord8 s2498 = s1 + s2493;+  const SBool  s2499 = s2498 < s1;+  const SBool  s2500 = s2498 < s2493;+  const SBool  s2501 = s2499 || s2500;+  const SWord8 s2502 = (s2498 >> 1) | (s2498 << 7);+  const SWord8 s2503 = 128 | s2502;+  const SWord8 s2504 = 127 & s2502;+  const SWord8 s2505 = s2501 ? s2503 : s2504;+  const SWord8 s2506 = s2457 ? s2497 : s2505;+  const SWord8 s2507 = s2330 ? s2485 : s2506;+  const SWord8 s2508 = s1 + s2464;+  const SBool  s2509 = s2508 < s1;+  const SBool  s2510 = s2508 < s2464;+  const SBool  s2511 = s2509 || s2510;+  const SWord8 s2512 = (s2508 >> 1) | (s2508 << 7);+  const SWord8 s2513 = 128 | s2512;+  const SWord8 s2514 = 127 & s2512;+  const SWord8 s2515 = s2511 ? s2513 : s2514;+  const SWord8 s2516 = (s2515 >> 1) | (s2515 << 7);+  const SWord8 s2517 = 128 | s2516;+  const SWord8 s2518 = 127 & s2516;+  const SWord8 s2519 = s2329 ? s2517 : s2518;+  const SWord8 s2520 = (s2519 >> 1) | (s2519 << 7);+  const SWord8 s2521 = 128 | s2520;+  const SWord8 s2522 = 127 & s2520;+  const SWord8 s2523 = s2456 ? s2521 : s2522;+  const SWord8 s2524 = s1 + s2519;+  const SBool  s2525 = s2524 < s1;+  const SBool  s2526 = s2524 < s2519;+  const SBool  s2527 = s2525 || s2526;+  const SWord8 s2528 = (s2524 >> 1) | (s2524 << 7);+  const SWord8 s2529 = 128 | s2528;+  const SWord8 s2530 = 127 & s2528;+  const SWord8 s2531 = s2527 ? s2529 : s2530;+  const SWord8 s2532 = s2457 ? s2523 : s2531;+  const SWord8 s2533 = s1 + s2515;+  const SBool  s2534 = s2533 < s1;+  const SBool  s2535 = s2533 < s2515;+  const SBool  s2536 = s2534 || s2535;+  const SWord8 s2537 = (s2533 >> 1) | (s2533 << 7);+  const SWord8 s2538 = 128 | s2537;+  const SWord8 s2539 = 127 & s2537;+  const SWord8 s2540 = s2536 ? s2538 : s2539;+  const SWord8 s2541 = (s2540 >> 1) | (s2540 << 7);+  const SWord8 s2542 = 128 | s2541;+  const SWord8 s2543 = 127 & s2541;+  const SWord8 s2544 = s2456 ? s2542 : s2543;+  const SWord8 s2545 = s1 + s2540;+  const SBool  s2546 = s2545 < s1;+  const SBool  s2547 = s2545 < s2540;+  const SBool  s2548 = s2546 || s2547;+  const SWord8 s2549 = (s2545 >> 1) | (s2545 << 7);+  const SWord8 s2550 = 128 | s2549;+  const SWord8 s2551 = 127 & s2549;+  const SWord8 s2552 = s2548 ? s2550 : s2551;+  const SWord8 s2553 = s2457 ? s2544 : s2552;+  const SWord8 s2554 = s2330 ? s2532 : s2553;+  const SWord8 s2555 = s2078 ? s2507 : s2554;+  const SWord8 s2556 = s2059 ? s2447 : s2555;+  const SWord8 s2557 = s2042 ? s2320 : s2556;+  const SWord8 s2558 = s1 + s2063;+  const SBool  s2559 = (SBool) ((s2558 >> 0) & 1);+  const SBool  s2560 = false != s2559;+  const SWord8 s2561 = s2560 ? s2067 : s2068;+  const SBool  s2562 = (SBool) ((s2561 >> 0) & 1);+  const SBool  s2563 = false != s2562;+  const SWord8 s2564 = s2563 ? s2073 : s2074;+  const SBool  s2565 = (SBool) ((s2564 >> 0) & 1);+  const SBool  s2566 = false != s2565;+  const SBool  s2567 = false == s2566;+  const SBool  s2568 = s2558 < s1;+  const SBool  s2569 = s2558 < s2063;+  const SBool  s2570 = s2568 || s2569;+  const SWord8 s2571 = (s2558 >> 1) | (s2558 << 7);+  const SWord8 s2572 = 128 | s2571;+  const SWord8 s2573 = 127 & s2571;+  const SWord8 s2574 = s2570 ? s2572 : s2573;+  const SBool  s2575 = (SBool) ((s2574 >> 0) & 1);+  const SBool  s2576 = false != s2575;+  const SWord8 s2577 = (s2561 >> 1) | (s2561 << 7);+  const SWord8 s2578 = 128 | s2577;+  const SWord8 s2579 = 127 & s2577;+  const SWord8 s2580 = s2576 ? s2578 : s2579;+  const SBool  s2581 = (SBool) ((s2580 >> 0) & 1);+  const SBool  s2582 = false != s2581;+  const SWord8 s2583 = (s2564 >> 1) | (s2564 << 7);+  const SWord8 s2584 = 128 | s2583;+  const SWord8 s2585 = 127 & s2583;+  const SWord8 s2586 = s2582 ? s2584 : s2585;+  const SBool  s2587 = (SBool) ((s2586 >> 0) & 1);+  const SBool  s2588 = false != s2587;+  const SBool  s2589 = false == s2588;+  const SWord8 s2590 = (s2574 >> 1) | (s2574 << 7);+  const SWord8 s2591 = 128 | s2590;+  const SWord8 s2592 = 127 & s2590;+  const SWord8 s2593 = s2041 ? s2591 : s2592;+  const SBool  s2594 = (SBool) ((s2593 >> 0) & 1);+  const SBool  s2595 = false != s2594;+  const SWord8 s2596 = (s2580 >> 1) | (s2580 << 7);+  const SWord8 s2597 = 128 | s2596;+  const SWord8 s2598 = 127 & s2596;+  const SWord8 s2599 = s2595 ? s2597 : s2598;+  const SBool  s2600 = (SBool) ((s2599 >> 0) & 1);+  const SBool  s2601 = false != s2600;+  const SWord8 s2602 = (s2586 >> 1) | (s2586 << 7);+  const SWord8 s2603 = 128 | s2602;+  const SWord8 s2604 = 127 & s2602;+  const SWord8 s2605 = s2601 ? s2603 : s2604;+  const SBool  s2606 = (SBool) ((s2605 >> 0) & 1);+  const SBool  s2607 = false != s2606;+  const SBool  s2608 = false == s2607;+  const SWord8 s2609 = (s2593 >> 1) | (s2593 << 7);+  const SWord8 s2610 = 128 | s2609;+  const SWord8 s2611 = 127 & s2609;+  const SWord8 s2612 = s2058 ? s2610 : s2611;+  const SWord8 s2613 = (s2612 >> 1) | (s2612 << 7);+  const SWord8 s2614 = 128 | s2613;+  const SWord8 s2615 = 127 & s2613;+  const SWord8 s2616 = s2566 ? s2614 : s2615;+  const SWord8 s2617 = (s2616 >> 1) | (s2616 << 7);+  const SWord8 s2618 = 128 | s2617;+  const SWord8 s2619 = 127 & s2617;+  const SWord8 s2620 = s2588 ? s2618 : s2619;+  const SWord8 s2621 = (s2620 >> 1) | (s2620 << 7);+  const SWord8 s2622 = 128 | s2621;+  const SWord8 s2623 = 127 & s2621;+  const SWord8 s2624 = s2607 ? s2622 : s2623;+  const SWord8 s2625 = s1 + s2620;+  const SBool  s2626 = s2625 < s1;+  const SBool  s2627 = s2625 < s2620;+  const SBool  s2628 = s2626 || s2627;+  const SWord8 s2629 = (s2625 >> 1) | (s2625 << 7);+  const SWord8 s2630 = 128 | s2629;+  const SWord8 s2631 = 127 & s2629;+  const SWord8 s2632 = s2628 ? s2630 : s2631;+  const SWord8 s2633 = s2608 ? s2624 : s2632;+  const SWord8 s2634 = s1 + s2616;+  const SBool  s2635 = s2634 < s1;+  const SBool  s2636 = s2634 < s2616;+  const SBool  s2637 = s2635 || s2636;+  const SWord8 s2638 = (s2634 >> 1) | (s2634 << 7);+  const SWord8 s2639 = 128 | s2638;+  const SWord8 s2640 = 127 & s2638;+  const SWord8 s2641 = s2637 ? s2639 : s2640;+  const SWord8 s2642 = (s2641 >> 1) | (s2641 << 7);+  const SWord8 s2643 = 128 | s2642;+  const SWord8 s2644 = 127 & s2642;+  const SWord8 s2645 = s2607 ? s2643 : s2644;+  const SWord8 s2646 = s1 + s2641;+  const SBool  s2647 = s2646 < s1;+  const SBool  s2648 = s2646 < s2641;+  const SBool  s2649 = s2647 || s2648;+  const SWord8 s2650 = (s2646 >> 1) | (s2646 << 7);+  const SWord8 s2651 = 128 | s2650;+  const SWord8 s2652 = 127 & s2650;+  const SWord8 s2653 = s2649 ? s2651 : s2652;+  const SWord8 s2654 = s2608 ? s2645 : s2653;+  const SWord8 s2655 = s2589 ? s2633 : s2654;+  const SWord8 s2656 = s1 + s2612;+  const SBool  s2657 = s2656 < s1;+  const SBool  s2658 = s2656 < s2612;+  const SBool  s2659 = s2657 || s2658;+  const SWord8 s2660 = (s2656 >> 1) | (s2656 << 7);+  const SWord8 s2661 = 128 | s2660;+  const SWord8 s2662 = 127 & s2660;+  const SWord8 s2663 = s2659 ? s2661 : s2662;+  const SWord8 s2664 = (s2663 >> 1) | (s2663 << 7);+  const SWord8 s2665 = 128 | s2664;+  const SWord8 s2666 = 127 & s2664;+  const SWord8 s2667 = s2588 ? s2665 : s2666;+  const SWord8 s2668 = (s2667 >> 1) | (s2667 << 7);+  const SWord8 s2669 = 128 | s2668;+  const SWord8 s2670 = 127 & s2668;+  const SWord8 s2671 = s2607 ? s2669 : s2670;+  const SWord8 s2672 = s1 + s2667;+  const SBool  s2673 = s2672 < s1;+  const SBool  s2674 = s2672 < s2667;+  const SBool  s2675 = s2673 || s2674;+  const SWord8 s2676 = (s2672 >> 1) | (s2672 << 7);+  const SWord8 s2677 = 128 | s2676;+  const SWord8 s2678 = 127 & s2676;+  const SWord8 s2679 = s2675 ? s2677 : s2678;+  const SWord8 s2680 = s2608 ? s2671 : s2679;+  const SWord8 s2681 = s1 + s2663;+  const SBool  s2682 = s2681 < s1;+  const SBool  s2683 = s2681 < s2663;+  const SBool  s2684 = s2682 || s2683;+  const SWord8 s2685 = (s2681 >> 1) | (s2681 << 7);+  const SWord8 s2686 = 128 | s2685;+  const SWord8 s2687 = 127 & s2685;+  const SWord8 s2688 = s2684 ? s2686 : s2687;+  const SWord8 s2689 = (s2688 >> 1) | (s2688 << 7);+  const SWord8 s2690 = 128 | s2689;+  const SWord8 s2691 = 127 & s2689;+  const SWord8 s2692 = s2607 ? s2690 : s2691;+  const SWord8 s2693 = s1 + s2688;+  const SBool  s2694 = s2693 < s1;+  const SBool  s2695 = s2693 < s2688;+  const SBool  s2696 = s2694 || s2695;+  const SWord8 s2697 = (s2693 >> 1) | (s2693 << 7);+  const SWord8 s2698 = 128 | s2697;+  const SWord8 s2699 = 127 & s2697;+  const SWord8 s2700 = s2696 ? s2698 : s2699;+  const SWord8 s2701 = s2608 ? s2692 : s2700;+  const SWord8 s2702 = s2589 ? s2680 : s2701;+  const SWord8 s2703 = s2567 ? s2655 : s2702;+  const SWord8 s2704 = s1 + s2593;+  const SBool  s2705 = (SBool) ((s2704 >> 0) & 1);+  const SBool  s2706 = false != s2705;+  const SWord8 s2707 = s2706 ? s2597 : s2598;+  const SBool  s2708 = (SBool) ((s2707 >> 0) & 1);+  const SBool  s2709 = false != s2708;+  const SWord8 s2710 = s2709 ? s2603 : s2604;+  const SBool  s2711 = (SBool) ((s2710 >> 0) & 1);+  const SBool  s2712 = false != s2711;+  const SBool  s2713 = false == s2712;+  const SBool  s2714 = s2704 < s1;+  const SBool  s2715 = s2704 < s2593;+  const SBool  s2716 = s2714 || s2715;+  const SWord8 s2717 = (s2704 >> 1) | (s2704 << 7);+  const SWord8 s2718 = 128 | s2717;+  const SWord8 s2719 = 127 & s2717;+  const SWord8 s2720 = s2716 ? s2718 : s2719;+  const SWord8 s2721 = (s2720 >> 1) | (s2720 << 7);+  const SWord8 s2722 = 128 | s2721;+  const SWord8 s2723 = 127 & s2721;+  const SWord8 s2724 = s2566 ? s2722 : s2723;+  const SWord8 s2725 = (s2724 >> 1) | (s2724 << 7);+  const SWord8 s2726 = 128 | s2725;+  const SWord8 s2727 = 127 & s2725;+  const SWord8 s2728 = s2588 ? s2726 : s2727;+  const SWord8 s2729 = (s2728 >> 1) | (s2728 << 7);+  const SWord8 s2730 = 128 | s2729;+  const SWord8 s2731 = 127 & s2729;+  const SWord8 s2732 = s2712 ? s2730 : s2731;+  const SWord8 s2733 = s1 + s2728;+  const SBool  s2734 = s2733 < s1;+  const SBool  s2735 = s2733 < s2728;+  const SBool  s2736 = s2734 || s2735;+  const SWord8 s2737 = (s2733 >> 1) | (s2733 << 7);+  const SWord8 s2738 = 128 | s2737;+  const SWord8 s2739 = 127 & s2737;+  const SWord8 s2740 = s2736 ? s2738 : s2739;+  const SWord8 s2741 = s2713 ? s2732 : s2740;+  const SWord8 s2742 = s1 + s2724;+  const SBool  s2743 = s2742 < s1;+  const SBool  s2744 = s2742 < s2724;+  const SBool  s2745 = s2743 || s2744;+  const SWord8 s2746 = (s2742 >> 1) | (s2742 << 7);+  const SWord8 s2747 = 128 | s2746;+  const SWord8 s2748 = 127 & s2746;+  const SWord8 s2749 = s2745 ? s2747 : s2748;+  const SWord8 s2750 = (s2749 >> 1) | (s2749 << 7);+  const SWord8 s2751 = 128 | s2750;+  const SWord8 s2752 = 127 & s2750;+  const SWord8 s2753 = s2712 ? s2751 : s2752;+  const SWord8 s2754 = s1 + s2749;+  const SBool  s2755 = s2754 < s1;+  const SBool  s2756 = s2754 < s2749;+  const SBool  s2757 = s2755 || s2756;+  const SWord8 s2758 = (s2754 >> 1) | (s2754 << 7);+  const SWord8 s2759 = 128 | s2758;+  const SWord8 s2760 = 127 & s2758;+  const SWord8 s2761 = s2757 ? s2759 : s2760;+  const SWord8 s2762 = s2713 ? s2753 : s2761;+  const SWord8 s2763 = s2589 ? s2741 : s2762;+  const SWord8 s2764 = s1 + s2720;+  const SBool  s2765 = s2764 < s1;+  const SBool  s2766 = s2764 < s2720;+  const SBool  s2767 = s2765 || s2766;+  const SWord8 s2768 = (s2764 >> 1) | (s2764 << 7);+  const SWord8 s2769 = 128 | s2768;+  const SWord8 s2770 = 127 & s2768;+  const SWord8 s2771 = s2767 ? s2769 : s2770;+  const SWord8 s2772 = (s2771 >> 1) | (s2771 << 7);+  const SWord8 s2773 = 128 | s2772;+  const SWord8 s2774 = 127 & s2772;+  const SWord8 s2775 = s2588 ? s2773 : s2774;+  const SWord8 s2776 = (s2775 >> 1) | (s2775 << 7);+  const SWord8 s2777 = 128 | s2776;+  const SWord8 s2778 = 127 & s2776;+  const SWord8 s2779 = s2712 ? s2777 : s2778;+  const SWord8 s2780 = s1 + s2775;+  const SBool  s2781 = s2780 < s1;+  const SBool  s2782 = s2780 < s2775;+  const SBool  s2783 = s2781 || s2782;+  const SWord8 s2784 = (s2780 >> 1) | (s2780 << 7);+  const SWord8 s2785 = 128 | s2784;+  const SWord8 s2786 = 127 & s2784;+  const SWord8 s2787 = s2783 ? s2785 : s2786;+  const SWord8 s2788 = s2713 ? s2779 : s2787;+  const SWord8 s2789 = s1 + s2771;+  const SBool  s2790 = s2789 < s1;+  const SBool  s2791 = s2789 < s2771;+  const SBool  s2792 = s2790 || s2791;+  const SWord8 s2793 = (s2789 >> 1) | (s2789 << 7);+  const SWord8 s2794 = 128 | s2793;+  const SWord8 s2795 = 127 & s2793;+  const SWord8 s2796 = s2792 ? s2794 : s2795;+  const SWord8 s2797 = (s2796 >> 1) | (s2796 << 7);+  const SWord8 s2798 = 128 | s2797;+  const SWord8 s2799 = 127 & s2797;+  const SWord8 s2800 = s2712 ? s2798 : s2799;+  const SWord8 s2801 = s1 + s2796;+  const SBool  s2802 = s2801 < s1;+  const SBool  s2803 = s2801 < s2796;+  const SBool  s2804 = s2802 || s2803;+  const SWord8 s2805 = (s2801 >> 1) | (s2801 << 7);+  const SWord8 s2806 = 128 | s2805;+  const SWord8 s2807 = 127 & s2805;+  const SWord8 s2808 = s2804 ? s2806 : s2807;+  const SWord8 s2809 = s2713 ? s2800 : s2808;+  const SWord8 s2810 = s2589 ? s2788 : s2809;+  const SWord8 s2811 = s2567 ? s2763 : s2810;+  const SWord8 s2812 = s2059 ? s2703 : s2811;+  const SWord8 s2813 = s1 + s2574;+  const SBool  s2814 = (SBool) ((s2813 >> 0) & 1);+  const SBool  s2815 = false != s2814;+  const SWord8 s2816 = s2815 ? s2578 : s2579;+  const SBool  s2817 = (SBool) ((s2816 >> 0) & 1);+  const SBool  s2818 = false != s2817;+  const SWord8 s2819 = s2818 ? s2584 : s2585;+  const SBool  s2820 = (SBool) ((s2819 >> 0) & 1);+  const SBool  s2821 = false != s2820;+  const SBool  s2822 = false == s2821;+  const SBool  s2823 = s2813 < s1;+  const SBool  s2824 = s2813 < s2574;+  const SBool  s2825 = s2823 || s2824;+  const SWord8 s2826 = (s2813 >> 1) | (s2813 << 7);+  const SWord8 s2827 = 128 | s2826;+  const SWord8 s2828 = 127 & s2826;+  const SWord8 s2829 = s2825 ? s2827 : s2828;+  const SBool  s2830 = (SBool) ((s2829 >> 0) & 1);+  const SBool  s2831 = false != s2830;+  const SWord8 s2832 = (s2816 >> 1) | (s2816 << 7);+  const SWord8 s2833 = 128 | s2832;+  const SWord8 s2834 = 127 & s2832;+  const SWord8 s2835 = s2831 ? s2833 : s2834;+  const SBool  s2836 = (SBool) ((s2835 >> 0) & 1);+  const SBool  s2837 = false != s2836;+  const SWord8 s2838 = (s2819 >> 1) | (s2819 << 7);+  const SWord8 s2839 = 128 | s2838;+  const SWord8 s2840 = 127 & s2838;+  const SWord8 s2841 = s2837 ? s2839 : s2840;+  const SBool  s2842 = (SBool) ((s2841 >> 0) & 1);+  const SBool  s2843 = false != s2842;+  const SBool  s2844 = false == s2843;+  const SWord8 s2845 = (s2829 >> 1) | (s2829 << 7);+  const SWord8 s2846 = 128 | s2845;+  const SWord8 s2847 = 127 & s2845;+  const SWord8 s2848 = s2058 ? s2846 : s2847;+  const SWord8 s2849 = (s2848 >> 1) | (s2848 << 7);+  const SWord8 s2850 = 128 | s2849;+  const SWord8 s2851 = 127 & s2849;+  const SWord8 s2852 = s2566 ? s2850 : s2851;+  const SWord8 s2853 = (s2852 >> 1) | (s2852 << 7);+  const SWord8 s2854 = 128 | s2853;+  const SWord8 s2855 = 127 & s2853;+  const SWord8 s2856 = s2821 ? s2854 : s2855;+  const SWord8 s2857 = (s2856 >> 1) | (s2856 << 7);+  const SWord8 s2858 = 128 | s2857;+  const SWord8 s2859 = 127 & s2857;+  const SWord8 s2860 = s2843 ? s2858 : s2859;+  const SWord8 s2861 = s1 + s2856;+  const SBool  s2862 = s2861 < s1;+  const SBool  s2863 = s2861 < s2856;+  const SBool  s2864 = s2862 || s2863;+  const SWord8 s2865 = (s2861 >> 1) | (s2861 << 7);+  const SWord8 s2866 = 128 | s2865;+  const SWord8 s2867 = 127 & s2865;+  const SWord8 s2868 = s2864 ? s2866 : s2867;+  const SWord8 s2869 = s2844 ? s2860 : s2868;+  const SWord8 s2870 = s1 + s2852;+  const SBool  s2871 = s2870 < s1;+  const SBool  s2872 = s2870 < s2852;+  const SBool  s2873 = s2871 || s2872;+  const SWord8 s2874 = (s2870 >> 1) | (s2870 << 7);+  const SWord8 s2875 = 128 | s2874;+  const SWord8 s2876 = 127 & s2874;+  const SWord8 s2877 = s2873 ? s2875 : s2876;+  const SWord8 s2878 = (s2877 >> 1) | (s2877 << 7);+  const SWord8 s2879 = 128 | s2878;+  const SWord8 s2880 = 127 & s2878;+  const SWord8 s2881 = s2843 ? s2879 : s2880;+  const SWord8 s2882 = s1 + s2877;+  const SBool  s2883 = s2882 < s1;+  const SBool  s2884 = s2882 < s2877;+  const SBool  s2885 = s2883 || s2884;+  const SWord8 s2886 = (s2882 >> 1) | (s2882 << 7);+  const SWord8 s2887 = 128 | s2886;+  const SWord8 s2888 = 127 & s2886;+  const SWord8 s2889 = s2885 ? s2887 : s2888;+  const SWord8 s2890 = s2844 ? s2881 : s2889;+  const SWord8 s2891 = s2822 ? s2869 : s2890;+  const SWord8 s2892 = s1 + s2848;+  const SBool  s2893 = s2892 < s1;+  const SBool  s2894 = s2892 < s2848;+  const SBool  s2895 = s2893 || s2894;+  const SWord8 s2896 = (s2892 >> 1) | (s2892 << 7);+  const SWord8 s2897 = 128 | s2896;+  const SWord8 s2898 = 127 & s2896;+  const SWord8 s2899 = s2895 ? s2897 : s2898;+  const SWord8 s2900 = (s2899 >> 1) | (s2899 << 7);+  const SWord8 s2901 = 128 | s2900;+  const SWord8 s2902 = 127 & s2900;+  const SWord8 s2903 = s2821 ? s2901 : s2902;+  const SWord8 s2904 = (s2903 >> 1) | (s2903 << 7);+  const SWord8 s2905 = 128 | s2904;+  const SWord8 s2906 = 127 & s2904;+  const SWord8 s2907 = s2843 ? s2905 : s2906;+  const SWord8 s2908 = s1 + s2903;+  const SBool  s2909 = s2908 < s1;+  const SBool  s2910 = s2908 < s2903;+  const SBool  s2911 = s2909 || s2910;+  const SWord8 s2912 = (s2908 >> 1) | (s2908 << 7);+  const SWord8 s2913 = 128 | s2912;+  const SWord8 s2914 = 127 & s2912;+  const SWord8 s2915 = s2911 ? s2913 : s2914;+  const SWord8 s2916 = s2844 ? s2907 : s2915;+  const SWord8 s2917 = s1 + s2899;+  const SBool  s2918 = s2917 < s1;+  const SBool  s2919 = s2917 < s2899;+  const SBool  s2920 = s2918 || s2919;+  const SWord8 s2921 = (s2917 >> 1) | (s2917 << 7);+  const SWord8 s2922 = 128 | s2921;+  const SWord8 s2923 = 127 & s2921;+  const SWord8 s2924 = s2920 ? s2922 : s2923;+  const SWord8 s2925 = (s2924 >> 1) | (s2924 << 7);+  const SWord8 s2926 = 128 | s2925;+  const SWord8 s2927 = 127 & s2925;+  const SWord8 s2928 = s2843 ? s2926 : s2927;+  const SWord8 s2929 = s1 + s2924;+  const SBool  s2930 = s2929 < s1;+  const SBool  s2931 = s2929 < s2924;+  const SBool  s2932 = s2930 || s2931;+  const SWord8 s2933 = (s2929 >> 1) | (s2929 << 7);+  const SWord8 s2934 = 128 | s2933;+  const SWord8 s2935 = 127 & s2933;+  const SWord8 s2936 = s2932 ? s2934 : s2935;+  const SWord8 s2937 = s2844 ? s2928 : s2936;+  const SWord8 s2938 = s2822 ? s2916 : s2937;+  const SWord8 s2939 = s2567 ? s2891 : s2938;+  const SWord8 s2940 = s1 + s2829;+  const SBool  s2941 = (SBool) ((s2940 >> 0) & 1);+  const SBool  s2942 = false != s2941;+  const SWord8 s2943 = s2942 ? s2833 : s2834;+  const SBool  s2944 = (SBool) ((s2943 >> 0) & 1);+  const SBool  s2945 = false != s2944;+  const SWord8 s2946 = s2945 ? s2839 : s2840;+  const SBool  s2947 = (SBool) ((s2946 >> 0) & 1);+  const SBool  s2948 = false != s2947;+  const SBool  s2949 = false == s2948;+  const SBool  s2950 = s2940 < s1;+  const SBool  s2951 = s2940 < s2829;+  const SBool  s2952 = s2950 || s2951;+  const SWord8 s2953 = (s2940 >> 1) | (s2940 << 7);+  const SWord8 s2954 = 128 | s2953;+  const SWord8 s2955 = 127 & s2953;+  const SWord8 s2956 = s2952 ? s2954 : s2955;+  const SWord8 s2957 = (s2956 >> 1) | (s2956 << 7);+  const SWord8 s2958 = 128 | s2957;+  const SWord8 s2959 = 127 & s2957;+  const SWord8 s2960 = s2566 ? s2958 : s2959;+  const SWord8 s2961 = (s2960 >> 1) | (s2960 << 7);+  const SWord8 s2962 = 128 | s2961;+  const SWord8 s2963 = 127 & s2961;+  const SWord8 s2964 = s2821 ? s2962 : s2963;+  const SWord8 s2965 = (s2964 >> 1) | (s2964 << 7);+  const SWord8 s2966 = 128 | s2965;+  const SWord8 s2967 = 127 & s2965;+  const SWord8 s2968 = s2948 ? s2966 : s2967;+  const SWord8 s2969 = s1 + s2964;+  const SBool  s2970 = s2969 < s1;+  const SBool  s2971 = s2969 < s2964;+  const SBool  s2972 = s2970 || s2971;+  const SWord8 s2973 = (s2969 >> 1) | (s2969 << 7);+  const SWord8 s2974 = 128 | s2973;+  const SWord8 s2975 = 127 & s2973;+  const SWord8 s2976 = s2972 ? s2974 : s2975;+  const SWord8 s2977 = s2949 ? s2968 : s2976;+  const SWord8 s2978 = s1 + s2960;+  const SBool  s2979 = s2978 < s1;+  const SBool  s2980 = s2978 < s2960;+  const SBool  s2981 = s2979 || s2980;+  const SWord8 s2982 = (s2978 >> 1) | (s2978 << 7);+  const SWord8 s2983 = 128 | s2982;+  const SWord8 s2984 = 127 & s2982;+  const SWord8 s2985 = s2981 ? s2983 : s2984;+  const SWord8 s2986 = (s2985 >> 1) | (s2985 << 7);+  const SWord8 s2987 = 128 | s2986;+  const SWord8 s2988 = 127 & s2986;+  const SWord8 s2989 = s2948 ? s2987 : s2988;+  const SWord8 s2990 = s1 + s2985;+  const SBool  s2991 = s2990 < s1;+  const SBool  s2992 = s2990 < s2985;+  const SBool  s2993 = s2991 || s2992;+  const SWord8 s2994 = (s2990 >> 1) | (s2990 << 7);+  const SWord8 s2995 = 128 | s2994;+  const SWord8 s2996 = 127 & s2994;+  const SWord8 s2997 = s2993 ? s2995 : s2996;+  const SWord8 s2998 = s2949 ? s2989 : s2997;+  const SWord8 s2999 = s2822 ? s2977 : s2998;+  const SWord8 s3000 = s1 + s2956;+  const SBool  s3001 = s3000 < s1;+  const SBool  s3002 = s3000 < s2956;+  const SBool  s3003 = s3001 || s3002;+  const SWord8 s3004 = (s3000 >> 1) | (s3000 << 7);+  const SWord8 s3005 = 128 | s3004;+  const SWord8 s3006 = 127 & s3004;+  const SWord8 s3007 = s3003 ? s3005 : s3006;+  const SWord8 s3008 = (s3007 >> 1) | (s3007 << 7);+  const SWord8 s3009 = 128 | s3008;+  const SWord8 s3010 = 127 & s3008;+  const SWord8 s3011 = s2821 ? s3009 : s3010;+  const SWord8 s3012 = (s3011 >> 1) | (s3011 << 7);+  const SWord8 s3013 = 128 | s3012;+  const SWord8 s3014 = 127 & s3012;+  const SWord8 s3015 = s2948 ? s3013 : s3014;+  const SWord8 s3016 = s1 + s3011;+  const SBool  s3017 = s3016 < s1;+  const SBool  s3018 = s3016 < s3011;+  const SBool  s3019 = s3017 || s3018;+  const SWord8 s3020 = (s3016 >> 1) | (s3016 << 7);+  const SWord8 s3021 = 128 | s3020;+  const SWord8 s3022 = 127 & s3020;+  const SWord8 s3023 = s3019 ? s3021 : s3022;+  const SWord8 s3024 = s2949 ? s3015 : s3023;+  const SWord8 s3025 = s1 + s3007;+  const SBool  s3026 = s3025 < s1;+  const SBool  s3027 = s3025 < s3007;+  const SBool  s3028 = s3026 || s3027;+  const SWord8 s3029 = (s3025 >> 1) | (s3025 << 7);+  const SWord8 s3030 = 128 | s3029;+  const SWord8 s3031 = 127 & s3029;+  const SWord8 s3032 = s3028 ? s3030 : s3031;+  const SWord8 s3033 = (s3032 >> 1) | (s3032 << 7);+  const SWord8 s3034 = 128 | s3033;+  const SWord8 s3035 = 127 & s3033;+  const SWord8 s3036 = s2948 ? s3034 : s3035;+  const SWord8 s3037 = s1 + s3032;+  const SBool  s3038 = s3037 < s1;+  const SBool  s3039 = s3037 < s3032;+  const SBool  s3040 = s3038 || s3039;+  const SWord8 s3041 = (s3037 >> 1) | (s3037 << 7);+  const SWord8 s3042 = 128 | s3041;+  const SWord8 s3043 = 127 & s3041;+  const SWord8 s3044 = s3040 ? s3042 : s3043;+  const SWord8 s3045 = s2949 ? s3036 : s3044;+  const SWord8 s3046 = s2822 ? s3024 : s3045;+  const SWord8 s3047 = s2567 ? s2999 : s3046;+  const SWord8 s3048 = s2059 ? s2939 : s3047;+  const SWord8 s3049 = s2042 ? s2812 : s3048;+  const SWord8 s3050 = s16 ? s2557 : s3049;+  const SWord8 s3051 = s1 + s2044;+  const SBool  s3052 = (SBool) ((s3051 >> 0) & 1);+  const SBool  s3053 = false != s3052;+  const SWord8 s3054 = s3053 ? s2048 : s2049;+  const SBool  s3055 = (SBool) ((s3054 >> 0) & 1);+  const SBool  s3056 = false != s3055;+  const SWord8 s3057 = s3056 ? s2054 : s2055;+  const SBool  s3058 = (SBool) ((s3057 >> 0) & 1);+  const SBool  s3059 = false != s3058;+  const SBool  s3060 = false == s3059;+  const SBool  s3061 = s3051 < s1;+  const SBool  s3062 = s3051 < s2044;+  const SBool  s3063 = s3061 || s3062;+  const SWord8 s3064 = (s3051 >> 1) | (s3051 << 7);+  const SWord8 s3065 = 128 | s3064;+  const SWord8 s3066 = 127 & s3064;+  const SWord8 s3067 = s3063 ? s3065 : s3066;+  const SBool  s3068 = (SBool) ((s3067 >> 0) & 1);+  const SBool  s3069 = false != s3068;+  const SWord8 s3070 = (s3054 >> 1) | (s3054 << 7);+  const SWord8 s3071 = 128 | s3070;+  const SWord8 s3072 = 127 & s3070;+  const SWord8 s3073 = s3069 ? s3071 : s3072;+  const SBool  s3074 = (SBool) ((s3073 >> 0) & 1);+  const SBool  s3075 = false != s3074;+  const SWord8 s3076 = (s3057 >> 1) | (s3057 << 7);+  const SWord8 s3077 = 128 | s3076;+  const SWord8 s3078 = 127 & s3076;+  const SWord8 s3079 = s3075 ? s3077 : s3078;+  const SBool  s3080 = (SBool) ((s3079 >> 0) & 1);+  const SBool  s3081 = false != s3080;+  const SBool  s3082 = false == s3081;+  const SWord8 s3083 = (s3067 >> 1) | (s3067 << 7);+  const SWord8 s3084 = 128 | s3083;+  const SWord8 s3085 = 127 & s3083;+  const SWord8 s3086 = s15 ? s3084 : s3085;+  const SBool  s3087 = (SBool) ((s3086 >> 0) & 1);+  const SBool  s3088 = false != s3087;+  const SWord8 s3089 = (s3073 >> 1) | (s3073 << 7);+  const SWord8 s3090 = 128 | s3089;+  const SWord8 s3091 = 127 & s3089;+  const SWord8 s3092 = s3088 ? s3090 : s3091;+  const SBool  s3093 = (SBool) ((s3092 >> 0) & 1);+  const SBool  s3094 = false != s3093;+  const SWord8 s3095 = (s3079 >> 1) | (s3079 << 7);+  const SWord8 s3096 = 128 | s3095;+  const SWord8 s3097 = 127 & s3095;+  const SWord8 s3098 = s3094 ? s3096 : s3097;+  const SBool  s3099 = (SBool) ((s3098 >> 0) & 1);+  const SBool  s3100 = false != s3099;+  const SBool  s3101 = false == s3100;+  const SWord8 s3102 = (s3086 >> 1) | (s3086 << 7);+  const SWord8 s3103 = 128 | s3102;+  const SWord8 s3104 = 127 & s3102;+  const SWord8 s3105 = s2041 ? s3103 : s3104;+  const SBool  s3106 = (SBool) ((s3105 >> 0) & 1);+  const SBool  s3107 = false != s3106;+  const SWord8 s3108 = (s3092 >> 1) | (s3092 << 7);+  const SWord8 s3109 = 128 | s3108;+  const SWord8 s3110 = 127 & s3108;+  const SWord8 s3111 = s3107 ? s3109 : s3110;+  const SBool  s3112 = (SBool) ((s3111 >> 0) & 1);+  const SBool  s3113 = false != s3112;+  const SWord8 s3114 = (s3098 >> 1) | (s3098 << 7);+  const SWord8 s3115 = 128 | s3114;+  const SWord8 s3116 = 127 & s3114;+  const SWord8 s3117 = s3113 ? s3115 : s3116;+  const SBool  s3118 = (SBool) ((s3117 >> 0) & 1);+  const SBool  s3119 = false != s3118;+  const SBool  s3120 = false == s3119;+  const SWord8 s3121 = (s3105 >> 1) | (s3105 << 7);+  const SWord8 s3122 = 128 | s3121;+  const SWord8 s3123 = 127 & s3121;+  const SWord8 s3124 = s3059 ? s3122 : s3123;+  const SWord8 s3125 = (s3124 >> 1) | (s3124 << 7);+  const SWord8 s3126 = 128 | s3125;+  const SWord8 s3127 = 127 & s3125;+  const SWord8 s3128 = s3081 ? s3126 : s3127;+  const SWord8 s3129 = (s3128 >> 1) | (s3128 << 7);+  const SWord8 s3130 = 128 | s3129;+  const SWord8 s3131 = 127 & s3129;+  const SWord8 s3132 = s3100 ? s3130 : s3131;+  const SWord8 s3133 = (s3132 >> 1) | (s3132 << 7);+  const SWord8 s3134 = 128 | s3133;+  const SWord8 s3135 = 127 & s3133;+  const SWord8 s3136 = s3119 ? s3134 : s3135;+  const SWord8 s3137 = s1 + s3132;+  const SBool  s3138 = s3137 < s1;+  const SBool  s3139 = s3137 < s3132;+  const SBool  s3140 = s3138 || s3139;+  const SWord8 s3141 = (s3137 >> 1) | (s3137 << 7);+  const SWord8 s3142 = 128 | s3141;+  const SWord8 s3143 = 127 & s3141;+  const SWord8 s3144 = s3140 ? s3142 : s3143;+  const SWord8 s3145 = s3120 ? s3136 : s3144;+  const SWord8 s3146 = s1 + s3128;+  const SBool  s3147 = s3146 < s1;+  const SBool  s3148 = s3146 < s3128;+  const SBool  s3149 = s3147 || s3148;+  const SWord8 s3150 = (s3146 >> 1) | (s3146 << 7);+  const SWord8 s3151 = 128 | s3150;+  const SWord8 s3152 = 127 & s3150;+  const SWord8 s3153 = s3149 ? s3151 : s3152;+  const SWord8 s3154 = (s3153 >> 1) | (s3153 << 7);+  const SWord8 s3155 = 128 | s3154;+  const SWord8 s3156 = 127 & s3154;+  const SWord8 s3157 = s3119 ? s3155 : s3156;+  const SWord8 s3158 = s1 + s3153;+  const SBool  s3159 = s3158 < s1;+  const SBool  s3160 = s3158 < s3153;+  const SBool  s3161 = s3159 || s3160;+  const SWord8 s3162 = (s3158 >> 1) | (s3158 << 7);+  const SWord8 s3163 = 128 | s3162;+  const SWord8 s3164 = 127 & s3162;+  const SWord8 s3165 = s3161 ? s3163 : s3164;+  const SWord8 s3166 = s3120 ? s3157 : s3165;+  const SWord8 s3167 = s3101 ? s3145 : s3166;+  const SWord8 s3168 = s1 + s3124;+  const SBool  s3169 = s3168 < s1;+  const SBool  s3170 = s3168 < s3124;+  const SBool  s3171 = s3169 || s3170;+  const SWord8 s3172 = (s3168 >> 1) | (s3168 << 7);+  const SWord8 s3173 = 128 | s3172;+  const SWord8 s3174 = 127 & s3172;+  const SWord8 s3175 = s3171 ? s3173 : s3174;+  const SWord8 s3176 = (s3175 >> 1) | (s3175 << 7);+  const SWord8 s3177 = 128 | s3176;+  const SWord8 s3178 = 127 & s3176;+  const SWord8 s3179 = s3100 ? s3177 : s3178;+  const SWord8 s3180 = (s3179 >> 1) | (s3179 << 7);+  const SWord8 s3181 = 128 | s3180;+  const SWord8 s3182 = 127 & s3180;+  const SWord8 s3183 = s3119 ? s3181 : s3182;+  const SWord8 s3184 = s1 + s3179;+  const SBool  s3185 = s3184 < s1;+  const SBool  s3186 = s3184 < s3179;+  const SBool  s3187 = s3185 || s3186;+  const SWord8 s3188 = (s3184 >> 1) | (s3184 << 7);+  const SWord8 s3189 = 128 | s3188;+  const SWord8 s3190 = 127 & s3188;+  const SWord8 s3191 = s3187 ? s3189 : s3190;+  const SWord8 s3192 = s3120 ? s3183 : s3191;+  const SWord8 s3193 = s1 + s3175;+  const SBool  s3194 = s3193 < s1;+  const SBool  s3195 = s3193 < s3175;+  const SBool  s3196 = s3194 || s3195;+  const SWord8 s3197 = (s3193 >> 1) | (s3193 << 7);+  const SWord8 s3198 = 128 | s3197;+  const SWord8 s3199 = 127 & s3197;+  const SWord8 s3200 = s3196 ? s3198 : s3199;+  const SWord8 s3201 = (s3200 >> 1) | (s3200 << 7);+  const SWord8 s3202 = 128 | s3201;+  const SWord8 s3203 = 127 & s3201;+  const SWord8 s3204 = s3119 ? s3202 : s3203;+  const SWord8 s3205 = s1 + s3200;+  const SBool  s3206 = s3205 < s1;+  const SBool  s3207 = s3205 < s3200;+  const SBool  s3208 = s3206 || s3207;+  const SWord8 s3209 = (s3205 >> 1) | (s3205 << 7);+  const SWord8 s3210 = 128 | s3209;+  const SWord8 s3211 = 127 & s3209;+  const SWord8 s3212 = s3208 ? s3210 : s3211;+  const SWord8 s3213 = s3120 ? s3204 : s3212;+  const SWord8 s3214 = s3101 ? s3192 : s3213;+  const SWord8 s3215 = s3082 ? s3167 : s3214;+  const SWord8 s3216 = s1 + s3105;+  const SBool  s3217 = (SBool) ((s3216 >> 0) & 1);+  const SBool  s3218 = false != s3217;+  const SWord8 s3219 = s3218 ? s3109 : s3110;+  const SBool  s3220 = (SBool) ((s3219 >> 0) & 1);+  const SBool  s3221 = false != s3220;+  const SWord8 s3222 = s3221 ? s3115 : s3116;+  const SBool  s3223 = (SBool) ((s3222 >> 0) & 1);+  const SBool  s3224 = false != s3223;+  const SBool  s3225 = false == s3224;+  const SBool  s3226 = s3216 < s1;+  const SBool  s3227 = s3216 < s3105;+  const SBool  s3228 = s3226 || s3227;+  const SWord8 s3229 = (s3216 >> 1) | (s3216 << 7);+  const SWord8 s3230 = 128 | s3229;+  const SWord8 s3231 = 127 & s3229;+  const SWord8 s3232 = s3228 ? s3230 : s3231;+  const SWord8 s3233 = (s3232 >> 1) | (s3232 << 7);+  const SWord8 s3234 = 128 | s3233;+  const SWord8 s3235 = 127 & s3233;+  const SWord8 s3236 = s3081 ? s3234 : s3235;+  const SWord8 s3237 = (s3236 >> 1) | (s3236 << 7);+  const SWord8 s3238 = 128 | s3237;+  const SWord8 s3239 = 127 & s3237;+  const SWord8 s3240 = s3100 ? s3238 : s3239;+  const SWord8 s3241 = (s3240 >> 1) | (s3240 << 7);+  const SWord8 s3242 = 128 | s3241;+  const SWord8 s3243 = 127 & s3241;+  const SWord8 s3244 = s3224 ? s3242 : s3243;+  const SWord8 s3245 = s1 + s3240;+  const SBool  s3246 = s3245 < s1;+  const SBool  s3247 = s3245 < s3240;+  const SBool  s3248 = s3246 || s3247;+  const SWord8 s3249 = (s3245 >> 1) | (s3245 << 7);+  const SWord8 s3250 = 128 | s3249;+  const SWord8 s3251 = 127 & s3249;+  const SWord8 s3252 = s3248 ? s3250 : s3251;+  const SWord8 s3253 = s3225 ? s3244 : s3252;+  const SWord8 s3254 = s1 + s3236;+  const SBool  s3255 = s3254 < s1;+  const SBool  s3256 = s3254 < s3236;+  const SBool  s3257 = s3255 || s3256;+  const SWord8 s3258 = (s3254 >> 1) | (s3254 << 7);+  const SWord8 s3259 = 128 | s3258;+  const SWord8 s3260 = 127 & s3258;+  const SWord8 s3261 = s3257 ? s3259 : s3260;+  const SWord8 s3262 = (s3261 >> 1) | (s3261 << 7);+  const SWord8 s3263 = 128 | s3262;+  const SWord8 s3264 = 127 & s3262;+  const SWord8 s3265 = s3224 ? s3263 : s3264;+  const SWord8 s3266 = s1 + s3261;+  const SBool  s3267 = s3266 < s1;+  const SBool  s3268 = s3266 < s3261;+  const SBool  s3269 = s3267 || s3268;+  const SWord8 s3270 = (s3266 >> 1) | (s3266 << 7);+  const SWord8 s3271 = 128 | s3270;+  const SWord8 s3272 = 127 & s3270;+  const SWord8 s3273 = s3269 ? s3271 : s3272;+  const SWord8 s3274 = s3225 ? s3265 : s3273;+  const SWord8 s3275 = s3101 ? s3253 : s3274;+  const SWord8 s3276 = s1 + s3232;+  const SBool  s3277 = s3276 < s1;+  const SBool  s3278 = s3276 < s3232;+  const SBool  s3279 = s3277 || s3278;+  const SWord8 s3280 = (s3276 >> 1) | (s3276 << 7);+  const SWord8 s3281 = 128 | s3280;+  const SWord8 s3282 = 127 & s3280;+  const SWord8 s3283 = s3279 ? s3281 : s3282;+  const SWord8 s3284 = (s3283 >> 1) | (s3283 << 7);+  const SWord8 s3285 = 128 | s3284;+  const SWord8 s3286 = 127 & s3284;+  const SWord8 s3287 = s3100 ? s3285 : s3286;+  const SWord8 s3288 = (s3287 >> 1) | (s3287 << 7);+  const SWord8 s3289 = 128 | s3288;+  const SWord8 s3290 = 127 & s3288;+  const SWord8 s3291 = s3224 ? s3289 : s3290;+  const SWord8 s3292 = s1 + s3287;+  const SBool  s3293 = s3292 < s1;+  const SBool  s3294 = s3292 < s3287;+  const SBool  s3295 = s3293 || s3294;+  const SWord8 s3296 = (s3292 >> 1) | (s3292 << 7);+  const SWord8 s3297 = 128 | s3296;+  const SWord8 s3298 = 127 & s3296;+  const SWord8 s3299 = s3295 ? s3297 : s3298;+  const SWord8 s3300 = s3225 ? s3291 : s3299;+  const SWord8 s3301 = s1 + s3283;+  const SBool  s3302 = s3301 < s1;+  const SBool  s3303 = s3301 < s3283;+  const SBool  s3304 = s3302 || s3303;+  const SWord8 s3305 = (s3301 >> 1) | (s3301 << 7);+  const SWord8 s3306 = 128 | s3305;+  const SWord8 s3307 = 127 & s3305;+  const SWord8 s3308 = s3304 ? s3306 : s3307;+  const SWord8 s3309 = (s3308 >> 1) | (s3308 << 7);+  const SWord8 s3310 = 128 | s3309;+  const SWord8 s3311 = 127 & s3309;+  const SWord8 s3312 = s3224 ? s3310 : s3311;+  const SWord8 s3313 = s1 + s3308;+  const SBool  s3314 = s3313 < s1;+  const SBool  s3315 = s3313 < s3308;+  const SBool  s3316 = s3314 || s3315;+  const SWord8 s3317 = (s3313 >> 1) | (s3313 << 7);+  const SWord8 s3318 = 128 | s3317;+  const SWord8 s3319 = 127 & s3317;+  const SWord8 s3320 = s3316 ? s3318 : s3319;+  const SWord8 s3321 = s3225 ? s3312 : s3320;+  const SWord8 s3322 = s3101 ? s3300 : s3321;+  const SWord8 s3323 = s3082 ? s3275 : s3322;+  const SWord8 s3324 = s3060 ? s3215 : s3323;+  const SWord8 s3325 = s1 + s3086;+  const SBool  s3326 = (SBool) ((s3325 >> 0) & 1);+  const SBool  s3327 = false != s3326;+  const SWord8 s3328 = s3327 ? s3090 : s3091;+  const SBool  s3329 = (SBool) ((s3328 >> 0) & 1);+  const SBool  s3330 = false != s3329;+  const SWord8 s3331 = s3330 ? s3096 : s3097;+  const SBool  s3332 = (SBool) ((s3331 >> 0) & 1);+  const SBool  s3333 = false != s3332;+  const SBool  s3334 = false == s3333;+  const SBool  s3335 = s3325 < s1;+  const SBool  s3336 = s3325 < s3086;+  const SBool  s3337 = s3335 || s3336;+  const SWord8 s3338 = (s3325 >> 1) | (s3325 << 7);+  const SWord8 s3339 = 128 | s3338;+  const SWord8 s3340 = 127 & s3338;+  const SWord8 s3341 = s3337 ? s3339 : s3340;+  const SBool  s3342 = (SBool) ((s3341 >> 0) & 1);+  const SBool  s3343 = false != s3342;+  const SWord8 s3344 = (s3328 >> 1) | (s3328 << 7);+  const SWord8 s3345 = 128 | s3344;+  const SWord8 s3346 = 127 & s3344;+  const SWord8 s3347 = s3343 ? s3345 : s3346;+  const SBool  s3348 = (SBool) ((s3347 >> 0) & 1);+  const SBool  s3349 = false != s3348;+  const SWord8 s3350 = (s3331 >> 1) | (s3331 << 7);+  const SWord8 s3351 = 128 | s3350;+  const SWord8 s3352 = 127 & s3350;+  const SWord8 s3353 = s3349 ? s3351 : s3352;+  const SBool  s3354 = (SBool) ((s3353 >> 0) & 1);+  const SBool  s3355 = false != s3354;+  const SBool  s3356 = false == s3355;+  const SWord8 s3357 = (s3341 >> 1) | (s3341 << 7);+  const SWord8 s3358 = 128 | s3357;+  const SWord8 s3359 = 127 & s3357;+  const SWord8 s3360 = s3059 ? s3358 : s3359;+  const SWord8 s3361 = (s3360 >> 1) | (s3360 << 7);+  const SWord8 s3362 = 128 | s3361;+  const SWord8 s3363 = 127 & s3361;+  const SWord8 s3364 = s3081 ? s3362 : s3363;+  const SWord8 s3365 = (s3364 >> 1) | (s3364 << 7);+  const SWord8 s3366 = 128 | s3365;+  const SWord8 s3367 = 127 & s3365;+  const SWord8 s3368 = s3333 ? s3366 : s3367;+  const SWord8 s3369 = (s3368 >> 1) | (s3368 << 7);+  const SWord8 s3370 = 128 | s3369;+  const SWord8 s3371 = 127 & s3369;+  const SWord8 s3372 = s3355 ? s3370 : s3371;+  const SWord8 s3373 = s1 + s3368;+  const SBool  s3374 = s3373 < s1;+  const SBool  s3375 = s3373 < s3368;+  const SBool  s3376 = s3374 || s3375;+  const SWord8 s3377 = (s3373 >> 1) | (s3373 << 7);+  const SWord8 s3378 = 128 | s3377;+  const SWord8 s3379 = 127 & s3377;+  const SWord8 s3380 = s3376 ? s3378 : s3379;+  const SWord8 s3381 = s3356 ? s3372 : s3380;+  const SWord8 s3382 = s1 + s3364;+  const SBool  s3383 = s3382 < s1;+  const SBool  s3384 = s3382 < s3364;+  const SBool  s3385 = s3383 || s3384;+  const SWord8 s3386 = (s3382 >> 1) | (s3382 << 7);+  const SWord8 s3387 = 128 | s3386;+  const SWord8 s3388 = 127 & s3386;+  const SWord8 s3389 = s3385 ? s3387 : s3388;+  const SWord8 s3390 = (s3389 >> 1) | (s3389 << 7);+  const SWord8 s3391 = 128 | s3390;+  const SWord8 s3392 = 127 & s3390;+  const SWord8 s3393 = s3355 ? s3391 : s3392;+  const SWord8 s3394 = s1 + s3389;+  const SBool  s3395 = s3394 < s1;+  const SBool  s3396 = s3394 < s3389;+  const SBool  s3397 = s3395 || s3396;+  const SWord8 s3398 = (s3394 >> 1) | (s3394 << 7);+  const SWord8 s3399 = 128 | s3398;+  const SWord8 s3400 = 127 & s3398;+  const SWord8 s3401 = s3397 ? s3399 : s3400;+  const SWord8 s3402 = s3356 ? s3393 : s3401;+  const SWord8 s3403 = s3334 ? s3381 : s3402;+  const SWord8 s3404 = s1 + s3360;+  const SBool  s3405 = s3404 < s1;+  const SBool  s3406 = s3404 < s3360;+  const SBool  s3407 = s3405 || s3406;+  const SWord8 s3408 = (s3404 >> 1) | (s3404 << 7);+  const SWord8 s3409 = 128 | s3408;+  const SWord8 s3410 = 127 & s3408;+  const SWord8 s3411 = s3407 ? s3409 : s3410;+  const SWord8 s3412 = (s3411 >> 1) | (s3411 << 7);+  const SWord8 s3413 = 128 | s3412;+  const SWord8 s3414 = 127 & s3412;+  const SWord8 s3415 = s3333 ? s3413 : s3414;+  const SWord8 s3416 = (s3415 >> 1) | (s3415 << 7);+  const SWord8 s3417 = 128 | s3416;+  const SWord8 s3418 = 127 & s3416;+  const SWord8 s3419 = s3355 ? s3417 : s3418;+  const SWord8 s3420 = s1 + s3415;+  const SBool  s3421 = s3420 < s1;+  const SBool  s3422 = s3420 < s3415;+  const SBool  s3423 = s3421 || s3422;+  const SWord8 s3424 = (s3420 >> 1) | (s3420 << 7);+  const SWord8 s3425 = 128 | s3424;+  const SWord8 s3426 = 127 & s3424;+  const SWord8 s3427 = s3423 ? s3425 : s3426;+  const SWord8 s3428 = s3356 ? s3419 : s3427;+  const SWord8 s3429 = s1 + s3411;+  const SBool  s3430 = s3429 < s1;+  const SBool  s3431 = s3429 < s3411;+  const SBool  s3432 = s3430 || s3431;+  const SWord8 s3433 = (s3429 >> 1) | (s3429 << 7);+  const SWord8 s3434 = 128 | s3433;+  const SWord8 s3435 = 127 & s3433;+  const SWord8 s3436 = s3432 ? s3434 : s3435;+  const SWord8 s3437 = (s3436 >> 1) | (s3436 << 7);+  const SWord8 s3438 = 128 | s3437;+  const SWord8 s3439 = 127 & s3437;+  const SWord8 s3440 = s3355 ? s3438 : s3439;+  const SWord8 s3441 = s1 + s3436;+  const SBool  s3442 = s3441 < s1;+  const SBool  s3443 = s3441 < s3436;+  const SBool  s3444 = s3442 || s3443;+  const SWord8 s3445 = (s3441 >> 1) | (s3441 << 7);+  const SWord8 s3446 = 128 | s3445;+  const SWord8 s3447 = 127 & s3445;+  const SWord8 s3448 = s3444 ? s3446 : s3447;+  const SWord8 s3449 = s3356 ? s3440 : s3448;+  const SWord8 s3450 = s3334 ? s3428 : s3449;+  const SWord8 s3451 = s3082 ? s3403 : s3450;+  const SWord8 s3452 = s1 + s3341;+  const SBool  s3453 = (SBool) ((s3452 >> 0) & 1);+  const SBool  s3454 = false != s3453;+  const SWord8 s3455 = s3454 ? s3345 : s3346;+  const SBool  s3456 = (SBool) ((s3455 >> 0) & 1);+  const SBool  s3457 = false != s3456;+  const SWord8 s3458 = s3457 ? s3351 : s3352;+  const SBool  s3459 = (SBool) ((s3458 >> 0) & 1);+  const SBool  s3460 = false != s3459;+  const SBool  s3461 = false == s3460;+  const SBool  s3462 = s3452 < s1;+  const SBool  s3463 = s3452 < s3341;+  const SBool  s3464 = s3462 || s3463;+  const SWord8 s3465 = (s3452 >> 1) | (s3452 << 7);+  const SWord8 s3466 = 128 | s3465;+  const SWord8 s3467 = 127 & s3465;+  const SWord8 s3468 = s3464 ? s3466 : s3467;+  const SWord8 s3469 = (s3468 >> 1) | (s3468 << 7);+  const SWord8 s3470 = 128 | s3469;+  const SWord8 s3471 = 127 & s3469;+  const SWord8 s3472 = s3081 ? s3470 : s3471;+  const SWord8 s3473 = (s3472 >> 1) | (s3472 << 7);+  const SWord8 s3474 = 128 | s3473;+  const SWord8 s3475 = 127 & s3473;+  const SWord8 s3476 = s3333 ? s3474 : s3475;+  const SWord8 s3477 = (s3476 >> 1) | (s3476 << 7);+  const SWord8 s3478 = 128 | s3477;+  const SWord8 s3479 = 127 & s3477;+  const SWord8 s3480 = s3460 ? s3478 : s3479;+  const SWord8 s3481 = s1 + s3476;+  const SBool  s3482 = s3481 < s1;+  const SBool  s3483 = s3481 < s3476;+  const SBool  s3484 = s3482 || s3483;+  const SWord8 s3485 = (s3481 >> 1) | (s3481 << 7);+  const SWord8 s3486 = 128 | s3485;+  const SWord8 s3487 = 127 & s3485;+  const SWord8 s3488 = s3484 ? s3486 : s3487;+  const SWord8 s3489 = s3461 ? s3480 : s3488;+  const SWord8 s3490 = s1 + s3472;+  const SBool  s3491 = s3490 < s1;+  const SBool  s3492 = s3490 < s3472;+  const SBool  s3493 = s3491 || s3492;+  const SWord8 s3494 = (s3490 >> 1) | (s3490 << 7);+  const SWord8 s3495 = 128 | s3494;+  const SWord8 s3496 = 127 & s3494;+  const SWord8 s3497 = s3493 ? s3495 : s3496;+  const SWord8 s3498 = (s3497 >> 1) | (s3497 << 7);+  const SWord8 s3499 = 128 | s3498;+  const SWord8 s3500 = 127 & s3498;+  const SWord8 s3501 = s3460 ? s3499 : s3500;+  const SWord8 s3502 = s1 + s3497;+  const SBool  s3503 = s3502 < s1;+  const SBool  s3504 = s3502 < s3497;+  const SBool  s3505 = s3503 || s3504;+  const SWord8 s3506 = (s3502 >> 1) | (s3502 << 7);+  const SWord8 s3507 = 128 | s3506;+  const SWord8 s3508 = 127 & s3506;+  const SWord8 s3509 = s3505 ? s3507 : s3508;+  const SWord8 s3510 = s3461 ? s3501 : s3509;+  const SWord8 s3511 = s3334 ? s3489 : s3510;+  const SWord8 s3512 = s1 + s3468;+  const SBool  s3513 = s3512 < s1;+  const SBool  s3514 = s3512 < s3468;+  const SBool  s3515 = s3513 || s3514;+  const SWord8 s3516 = (s3512 >> 1) | (s3512 << 7);+  const SWord8 s3517 = 128 | s3516;+  const SWord8 s3518 = 127 & s3516;+  const SWord8 s3519 = s3515 ? s3517 : s3518;+  const SWord8 s3520 = (s3519 >> 1) | (s3519 << 7);+  const SWord8 s3521 = 128 | s3520;+  const SWord8 s3522 = 127 & s3520;+  const SWord8 s3523 = s3333 ? s3521 : s3522;+  const SWord8 s3524 = (s3523 >> 1) | (s3523 << 7);+  const SWord8 s3525 = 128 | s3524;+  const SWord8 s3526 = 127 & s3524;+  const SWord8 s3527 = s3460 ? s3525 : s3526;+  const SWord8 s3528 = s1 + s3523;+  const SBool  s3529 = s3528 < s1;+  const SBool  s3530 = s3528 < s3523;+  const SBool  s3531 = s3529 || s3530;+  const SWord8 s3532 = (s3528 >> 1) | (s3528 << 7);+  const SWord8 s3533 = 128 | s3532;+  const SWord8 s3534 = 127 & s3532;+  const SWord8 s3535 = s3531 ? s3533 : s3534;+  const SWord8 s3536 = s3461 ? s3527 : s3535;+  const SWord8 s3537 = s1 + s3519;+  const SBool  s3538 = s3537 < s1;+  const SBool  s3539 = s3537 < s3519;+  const SBool  s3540 = s3538 || s3539;+  const SWord8 s3541 = (s3537 >> 1) | (s3537 << 7);+  const SWord8 s3542 = 128 | s3541;+  const SWord8 s3543 = 127 & s3541;+  const SWord8 s3544 = s3540 ? s3542 : s3543;+  const SWord8 s3545 = (s3544 >> 1) | (s3544 << 7);+  const SWord8 s3546 = 128 | s3545;+  const SWord8 s3547 = 127 & s3545;+  const SWord8 s3548 = s3460 ? s3546 : s3547;+  const SWord8 s3549 = s1 + s3544;+  const SBool  s3550 = s3549 < s1;+  const SBool  s3551 = s3549 < s3544;+  const SBool  s3552 = s3550 || s3551;+  const SWord8 s3553 = (s3549 >> 1) | (s3549 << 7);+  const SWord8 s3554 = 128 | s3553;+  const SWord8 s3555 = 127 & s3553;+  const SWord8 s3556 = s3552 ? s3554 : s3555;+  const SWord8 s3557 = s3461 ? s3548 : s3556;+  const SWord8 s3558 = s3334 ? s3536 : s3557;+  const SWord8 s3559 = s3082 ? s3511 : s3558;+  const SWord8 s3560 = s3060 ? s3451 : s3559;+  const SWord8 s3561 = s2042 ? s3324 : s3560;+  const SWord8 s3562 = s1 + s3067;+  const SBool  s3563 = (SBool) ((s3562 >> 0) & 1);+  const SBool  s3564 = false != s3563;+  const SWord8 s3565 = s3564 ? s3071 : s3072;+  const SBool  s3566 = (SBool) ((s3565 >> 0) & 1);+  const SBool  s3567 = false != s3566;+  const SWord8 s3568 = s3567 ? s3077 : s3078;+  const SBool  s3569 = (SBool) ((s3568 >> 0) & 1);+  const SBool  s3570 = false != s3569;+  const SBool  s3571 = false == s3570;+  const SBool  s3572 = s3562 < s1;+  const SBool  s3573 = s3562 < s3067;+  const SBool  s3574 = s3572 || s3573;+  const SWord8 s3575 = (s3562 >> 1) | (s3562 << 7);+  const SWord8 s3576 = 128 | s3575;+  const SWord8 s3577 = 127 & s3575;+  const SWord8 s3578 = s3574 ? s3576 : s3577;+  const SBool  s3579 = (SBool) ((s3578 >> 0) & 1);+  const SBool  s3580 = false != s3579;+  const SWord8 s3581 = (s3565 >> 1) | (s3565 << 7);+  const SWord8 s3582 = 128 | s3581;+  const SWord8 s3583 = 127 & s3581;+  const SWord8 s3584 = s3580 ? s3582 : s3583;+  const SBool  s3585 = (SBool) ((s3584 >> 0) & 1);+  const SBool  s3586 = false != s3585;+  const SWord8 s3587 = (s3568 >> 1) | (s3568 << 7);+  const SWord8 s3588 = 128 | s3587;+  const SWord8 s3589 = 127 & s3587;+  const SWord8 s3590 = s3586 ? s3588 : s3589;+  const SBool  s3591 = (SBool) ((s3590 >> 0) & 1);+  const SBool  s3592 = false != s3591;+  const SBool  s3593 = false == s3592;+  const SWord8 s3594 = (s3578 >> 1) | (s3578 << 7);+  const SWord8 s3595 = 128 | s3594;+  const SWord8 s3596 = 127 & s3594;+  const SWord8 s3597 = s2041 ? s3595 : s3596;+  const SBool  s3598 = (SBool) ((s3597 >> 0) & 1);+  const SBool  s3599 = false != s3598;+  const SWord8 s3600 = (s3584 >> 1) | (s3584 << 7);+  const SWord8 s3601 = 128 | s3600;+  const SWord8 s3602 = 127 & s3600;+  const SWord8 s3603 = s3599 ? s3601 : s3602;+  const SBool  s3604 = (SBool) ((s3603 >> 0) & 1);+  const SBool  s3605 = false != s3604;+  const SWord8 s3606 = (s3590 >> 1) | (s3590 << 7);+  const SWord8 s3607 = 128 | s3606;+  const SWord8 s3608 = 127 & s3606;+  const SWord8 s3609 = s3605 ? s3607 : s3608;+  const SBool  s3610 = (SBool) ((s3609 >> 0) & 1);+  const SBool  s3611 = false != s3610;+  const SBool  s3612 = false == s3611;+  const SWord8 s3613 = (s3597 >> 1) | (s3597 << 7);+  const SWord8 s3614 = 128 | s3613;+  const SWord8 s3615 = 127 & s3613;+  const SWord8 s3616 = s3059 ? s3614 : s3615;+  const SWord8 s3617 = (s3616 >> 1) | (s3616 << 7);+  const SWord8 s3618 = 128 | s3617;+  const SWord8 s3619 = 127 & s3617;+  const SWord8 s3620 = s3570 ? s3618 : s3619;+  const SWord8 s3621 = (s3620 >> 1) | (s3620 << 7);+  const SWord8 s3622 = 128 | s3621;+  const SWord8 s3623 = 127 & s3621;+  const SWord8 s3624 = s3592 ? s3622 : s3623;+  const SWord8 s3625 = (s3624 >> 1) | (s3624 << 7);+  const SWord8 s3626 = 128 | s3625;+  const SWord8 s3627 = 127 & s3625;+  const SWord8 s3628 = s3611 ? s3626 : s3627;+  const SWord8 s3629 = s1 + s3624;+  const SBool  s3630 = s3629 < s1;+  const SBool  s3631 = s3629 < s3624;+  const SBool  s3632 = s3630 || s3631;+  const SWord8 s3633 = (s3629 >> 1) | (s3629 << 7);+  const SWord8 s3634 = 128 | s3633;+  const SWord8 s3635 = 127 & s3633;+  const SWord8 s3636 = s3632 ? s3634 : s3635;+  const SWord8 s3637 = s3612 ? s3628 : s3636;+  const SWord8 s3638 = s1 + s3620;+  const SBool  s3639 = s3638 < s1;+  const SBool  s3640 = s3638 < s3620;+  const SBool  s3641 = s3639 || s3640;+  const SWord8 s3642 = (s3638 >> 1) | (s3638 << 7);+  const SWord8 s3643 = 128 | s3642;+  const SWord8 s3644 = 127 & s3642;+  const SWord8 s3645 = s3641 ? s3643 : s3644;+  const SWord8 s3646 = (s3645 >> 1) | (s3645 << 7);+  const SWord8 s3647 = 128 | s3646;+  const SWord8 s3648 = 127 & s3646;+  const SWord8 s3649 = s3611 ? s3647 : s3648;+  const SWord8 s3650 = s1 + s3645;+  const SBool  s3651 = s3650 < s1;+  const SBool  s3652 = s3650 < s3645;+  const SBool  s3653 = s3651 || s3652;+  const SWord8 s3654 = (s3650 >> 1) | (s3650 << 7);+  const SWord8 s3655 = 128 | s3654;+  const SWord8 s3656 = 127 & s3654;+  const SWord8 s3657 = s3653 ? s3655 : s3656;+  const SWord8 s3658 = s3612 ? s3649 : s3657;+  const SWord8 s3659 = s3593 ? s3637 : s3658;+  const SWord8 s3660 = s1 + s3616;+  const SBool  s3661 = s3660 < s1;+  const SBool  s3662 = s3660 < s3616;+  const SBool  s3663 = s3661 || s3662;+  const SWord8 s3664 = (s3660 >> 1) | (s3660 << 7);+  const SWord8 s3665 = 128 | s3664;+  const SWord8 s3666 = 127 & s3664;+  const SWord8 s3667 = s3663 ? s3665 : s3666;+  const SWord8 s3668 = (s3667 >> 1) | (s3667 << 7);+  const SWord8 s3669 = 128 | s3668;+  const SWord8 s3670 = 127 & s3668;+  const SWord8 s3671 = s3592 ? s3669 : s3670;+  const SWord8 s3672 = (s3671 >> 1) | (s3671 << 7);+  const SWord8 s3673 = 128 | s3672;+  const SWord8 s3674 = 127 & s3672;+  const SWord8 s3675 = s3611 ? s3673 : s3674;+  const SWord8 s3676 = s1 + s3671;+  const SBool  s3677 = s3676 < s1;+  const SBool  s3678 = s3676 < s3671;+  const SBool  s3679 = s3677 || s3678;+  const SWord8 s3680 = (s3676 >> 1) | (s3676 << 7);+  const SWord8 s3681 = 128 | s3680;+  const SWord8 s3682 = 127 & s3680;+  const SWord8 s3683 = s3679 ? s3681 : s3682;+  const SWord8 s3684 = s3612 ? s3675 : s3683;+  const SWord8 s3685 = s1 + s3667;+  const SBool  s3686 = s3685 < s1;+  const SBool  s3687 = s3685 < s3667;+  const SBool  s3688 = s3686 || s3687;+  const SWord8 s3689 = (s3685 >> 1) | (s3685 << 7);+  const SWord8 s3690 = 128 | s3689;+  const SWord8 s3691 = 127 & s3689;+  const SWord8 s3692 = s3688 ? s3690 : s3691;+  const SWord8 s3693 = (s3692 >> 1) | (s3692 << 7);+  const SWord8 s3694 = 128 | s3693;+  const SWord8 s3695 = 127 & s3693;+  const SWord8 s3696 = s3611 ? s3694 : s3695;+  const SWord8 s3697 = s1 + s3692;+  const SBool  s3698 = s3697 < s1;+  const SBool  s3699 = s3697 < s3692;+  const SBool  s3700 = s3698 || s3699;+  const SWord8 s3701 = (s3697 >> 1) | (s3697 << 7);+  const SWord8 s3702 = 128 | s3701;+  const SWord8 s3703 = 127 & s3701;+  const SWord8 s3704 = s3700 ? s3702 : s3703;+  const SWord8 s3705 = s3612 ? s3696 : s3704;+  const SWord8 s3706 = s3593 ? s3684 : s3705;+  const SWord8 s3707 = s3571 ? s3659 : s3706;+  const SWord8 s3708 = s1 + s3597;+  const SBool  s3709 = (SBool) ((s3708 >> 0) & 1);+  const SBool  s3710 = false != s3709;+  const SWord8 s3711 = s3710 ? s3601 : s3602;+  const SBool  s3712 = (SBool) ((s3711 >> 0) & 1);+  const SBool  s3713 = false != s3712;+  const SWord8 s3714 = s3713 ? s3607 : s3608;+  const SBool  s3715 = (SBool) ((s3714 >> 0) & 1);+  const SBool  s3716 = false != s3715;+  const SBool  s3717 = false == s3716;+  const SBool  s3718 = s3708 < s1;+  const SBool  s3719 = s3708 < s3597;+  const SBool  s3720 = s3718 || s3719;+  const SWord8 s3721 = (s3708 >> 1) | (s3708 << 7);+  const SWord8 s3722 = 128 | s3721;+  const SWord8 s3723 = 127 & s3721;+  const SWord8 s3724 = s3720 ? s3722 : s3723;+  const SWord8 s3725 = (s3724 >> 1) | (s3724 << 7);+  const SWord8 s3726 = 128 | s3725;+  const SWord8 s3727 = 127 & s3725;+  const SWord8 s3728 = s3570 ? s3726 : s3727;+  const SWord8 s3729 = (s3728 >> 1) | (s3728 << 7);+  const SWord8 s3730 = 128 | s3729;+  const SWord8 s3731 = 127 & s3729;+  const SWord8 s3732 = s3592 ? s3730 : s3731;+  const SWord8 s3733 = (s3732 >> 1) | (s3732 << 7);+  const SWord8 s3734 = 128 | s3733;+  const SWord8 s3735 = 127 & s3733;+  const SWord8 s3736 = s3716 ? s3734 : s3735;+  const SWord8 s3737 = s1 + s3732;+  const SBool  s3738 = s3737 < s1;+  const SBool  s3739 = s3737 < s3732;+  const SBool  s3740 = s3738 || s3739;+  const SWord8 s3741 = (s3737 >> 1) | (s3737 << 7);+  const SWord8 s3742 = 128 | s3741;+  const SWord8 s3743 = 127 & s3741;+  const SWord8 s3744 = s3740 ? s3742 : s3743;+  const SWord8 s3745 = s3717 ? s3736 : s3744;+  const SWord8 s3746 = s1 + s3728;+  const SBool  s3747 = s3746 < s1;+  const SBool  s3748 = s3746 < s3728;+  const SBool  s3749 = s3747 || s3748;+  const SWord8 s3750 = (s3746 >> 1) | (s3746 << 7);+  const SWord8 s3751 = 128 | s3750;+  const SWord8 s3752 = 127 & s3750;+  const SWord8 s3753 = s3749 ? s3751 : s3752;+  const SWord8 s3754 = (s3753 >> 1) | (s3753 << 7);+  const SWord8 s3755 = 128 | s3754;+  const SWord8 s3756 = 127 & s3754;+  const SWord8 s3757 = s3716 ? s3755 : s3756;+  const SWord8 s3758 = s1 + s3753;+  const SBool  s3759 = s3758 < s1;+  const SBool  s3760 = s3758 < s3753;+  const SBool  s3761 = s3759 || s3760;+  const SWord8 s3762 = (s3758 >> 1) | (s3758 << 7);+  const SWord8 s3763 = 128 | s3762;+  const SWord8 s3764 = 127 & s3762;+  const SWord8 s3765 = s3761 ? s3763 : s3764;+  const SWord8 s3766 = s3717 ? s3757 : s3765;+  const SWord8 s3767 = s3593 ? s3745 : s3766;+  const SWord8 s3768 = s1 + s3724;+  const SBool  s3769 = s3768 < s1;+  const SBool  s3770 = s3768 < s3724;+  const SBool  s3771 = s3769 || s3770;+  const SWord8 s3772 = (s3768 >> 1) | (s3768 << 7);+  const SWord8 s3773 = 128 | s3772;+  const SWord8 s3774 = 127 & s3772;+  const SWord8 s3775 = s3771 ? s3773 : s3774;+  const SWord8 s3776 = (s3775 >> 1) | (s3775 << 7);+  const SWord8 s3777 = 128 | s3776;+  const SWord8 s3778 = 127 & s3776;+  const SWord8 s3779 = s3592 ? s3777 : s3778;+  const SWord8 s3780 = (s3779 >> 1) | (s3779 << 7);+  const SWord8 s3781 = 128 | s3780;+  const SWord8 s3782 = 127 & s3780;+  const SWord8 s3783 = s3716 ? s3781 : s3782;+  const SWord8 s3784 = s1 + s3779;+  const SBool  s3785 = s3784 < s1;+  const SBool  s3786 = s3784 < s3779;+  const SBool  s3787 = s3785 || s3786;+  const SWord8 s3788 = (s3784 >> 1) | (s3784 << 7);+  const SWord8 s3789 = 128 | s3788;+  const SWord8 s3790 = 127 & s3788;+  const SWord8 s3791 = s3787 ? s3789 : s3790;+  const SWord8 s3792 = s3717 ? s3783 : s3791;+  const SWord8 s3793 = s1 + s3775;+  const SBool  s3794 = s3793 < s1;+  const SBool  s3795 = s3793 < s3775;+  const SBool  s3796 = s3794 || s3795;+  const SWord8 s3797 = (s3793 >> 1) | (s3793 << 7);+  const SWord8 s3798 = 128 | s3797;+  const SWord8 s3799 = 127 & s3797;+  const SWord8 s3800 = s3796 ? s3798 : s3799;+  const SWord8 s3801 = (s3800 >> 1) | (s3800 << 7);+  const SWord8 s3802 = 128 | s3801;+  const SWord8 s3803 = 127 & s3801;+  const SWord8 s3804 = s3716 ? s3802 : s3803;+  const SWord8 s3805 = s1 + s3800;+  const SBool  s3806 = s3805 < s1;+  const SBool  s3807 = s3805 < s3800;+  const SBool  s3808 = s3806 || s3807;+  const SWord8 s3809 = (s3805 >> 1) | (s3805 << 7);+  const SWord8 s3810 = 128 | s3809;+  const SWord8 s3811 = 127 & s3809;+  const SWord8 s3812 = s3808 ? s3810 : s3811;+  const SWord8 s3813 = s3717 ? s3804 : s3812;+  const SWord8 s3814 = s3593 ? s3792 : s3813;+  const SWord8 s3815 = s3571 ? s3767 : s3814;+  const SWord8 s3816 = s3060 ? s3707 : s3815;+  const SWord8 s3817 = s1 + s3578;+  const SBool  s3818 = (SBool) ((s3817 >> 0) & 1);+  const SBool  s3819 = false != s3818;+  const SWord8 s3820 = s3819 ? s3582 : s3583;+  const SBool  s3821 = (SBool) ((s3820 >> 0) & 1);+  const SBool  s3822 = false != s3821;+  const SWord8 s3823 = s3822 ? s3588 : s3589;+  const SBool  s3824 = (SBool) ((s3823 >> 0) & 1);+  const SBool  s3825 = false != s3824;+  const SBool  s3826 = false == s3825;+  const SBool  s3827 = s3817 < s1;+  const SBool  s3828 = s3817 < s3578;+  const SBool  s3829 = s3827 || s3828;+  const SWord8 s3830 = (s3817 >> 1) | (s3817 << 7);+  const SWord8 s3831 = 128 | s3830;+  const SWord8 s3832 = 127 & s3830;+  const SWord8 s3833 = s3829 ? s3831 : s3832;+  const SBool  s3834 = (SBool) ((s3833 >> 0) & 1);+  const SBool  s3835 = false != s3834;+  const SWord8 s3836 = (s3820 >> 1) | (s3820 << 7);+  const SWord8 s3837 = 128 | s3836;+  const SWord8 s3838 = 127 & s3836;+  const SWord8 s3839 = s3835 ? s3837 : s3838;+  const SBool  s3840 = (SBool) ((s3839 >> 0) & 1);+  const SBool  s3841 = false != s3840;+  const SWord8 s3842 = (s3823 >> 1) | (s3823 << 7);+  const SWord8 s3843 = 128 | s3842;+  const SWord8 s3844 = 127 & s3842;+  const SWord8 s3845 = s3841 ? s3843 : s3844;+  const SBool  s3846 = (SBool) ((s3845 >> 0) & 1);+  const SBool  s3847 = false != s3846;+  const SBool  s3848 = false == s3847;+  const SWord8 s3849 = (s3833 >> 1) | (s3833 << 7);+  const SWord8 s3850 = 128 | s3849;+  const SWord8 s3851 = 127 & s3849;+  const SWord8 s3852 = s3059 ? s3850 : s3851;+  const SWord8 s3853 = (s3852 >> 1) | (s3852 << 7);+  const SWord8 s3854 = 128 | s3853;+  const SWord8 s3855 = 127 & s3853;+  const SWord8 s3856 = s3570 ? s3854 : s3855;+  const SWord8 s3857 = (s3856 >> 1) | (s3856 << 7);+  const SWord8 s3858 = 128 | s3857;+  const SWord8 s3859 = 127 & s3857;+  const SWord8 s3860 = s3825 ? s3858 : s3859;+  const SWord8 s3861 = (s3860 >> 1) | (s3860 << 7);+  const SWord8 s3862 = 128 | s3861;+  const SWord8 s3863 = 127 & s3861;+  const SWord8 s3864 = s3847 ? s3862 : s3863;+  const SWord8 s3865 = s1 + s3860;+  const SBool  s3866 = s3865 < s1;+  const SBool  s3867 = s3865 < s3860;+  const SBool  s3868 = s3866 || s3867;+  const SWord8 s3869 = (s3865 >> 1) | (s3865 << 7);+  const SWord8 s3870 = 128 | s3869;+  const SWord8 s3871 = 127 & s3869;+  const SWord8 s3872 = s3868 ? s3870 : s3871;+  const SWord8 s3873 = s3848 ? s3864 : s3872;+  const SWord8 s3874 = s1 + s3856;+  const SBool  s3875 = s3874 < s1;+  const SBool  s3876 = s3874 < s3856;+  const SBool  s3877 = s3875 || s3876;+  const SWord8 s3878 = (s3874 >> 1) | (s3874 << 7);+  const SWord8 s3879 = 128 | s3878;+  const SWord8 s3880 = 127 & s3878;+  const SWord8 s3881 = s3877 ? s3879 : s3880;+  const SWord8 s3882 = (s3881 >> 1) | (s3881 << 7);+  const SWord8 s3883 = 128 | s3882;+  const SWord8 s3884 = 127 & s3882;+  const SWord8 s3885 = s3847 ? s3883 : s3884;+  const SWord8 s3886 = s1 + s3881;+  const SBool  s3887 = s3886 < s1;+  const SBool  s3888 = s3886 < s3881;+  const SBool  s3889 = s3887 || s3888;+  const SWord8 s3890 = (s3886 >> 1) | (s3886 << 7);+  const SWord8 s3891 = 128 | s3890;+  const SWord8 s3892 = 127 & s3890;+  const SWord8 s3893 = s3889 ? s3891 : s3892;+  const SWord8 s3894 = s3848 ? s3885 : s3893;+  const SWord8 s3895 = s3826 ? s3873 : s3894;+  const SWord8 s3896 = s1 + s3852;+  const SBool  s3897 = s3896 < s1;+  const SBool  s3898 = s3896 < s3852;+  const SBool  s3899 = s3897 || s3898;+  const SWord8 s3900 = (s3896 >> 1) | (s3896 << 7);+  const SWord8 s3901 = 128 | s3900;+  const SWord8 s3902 = 127 & s3900;+  const SWord8 s3903 = s3899 ? s3901 : s3902;+  const SWord8 s3904 = (s3903 >> 1) | (s3903 << 7);+  const SWord8 s3905 = 128 | s3904;+  const SWord8 s3906 = 127 & s3904;+  const SWord8 s3907 = s3825 ? s3905 : s3906;+  const SWord8 s3908 = (s3907 >> 1) | (s3907 << 7);+  const SWord8 s3909 = 128 | s3908;+  const SWord8 s3910 = 127 & s3908;+  const SWord8 s3911 = s3847 ? s3909 : s3910;+  const SWord8 s3912 = s1 + s3907;+  const SBool  s3913 = s3912 < s1;+  const SBool  s3914 = s3912 < s3907;+  const SBool  s3915 = s3913 || s3914;+  const SWord8 s3916 = (s3912 >> 1) | (s3912 << 7);+  const SWord8 s3917 = 128 | s3916;+  const SWord8 s3918 = 127 & s3916;+  const SWord8 s3919 = s3915 ? s3917 : s3918;+  const SWord8 s3920 = s3848 ? s3911 : s3919;+  const SWord8 s3921 = s1 + s3903;+  const SBool  s3922 = s3921 < s1;+  const SBool  s3923 = s3921 < s3903;+  const SBool  s3924 = s3922 || s3923;+  const SWord8 s3925 = (s3921 >> 1) | (s3921 << 7);+  const SWord8 s3926 = 128 | s3925;+  const SWord8 s3927 = 127 & s3925;+  const SWord8 s3928 = s3924 ? s3926 : s3927;+  const SWord8 s3929 = (s3928 >> 1) | (s3928 << 7);+  const SWord8 s3930 = 128 | s3929;+  const SWord8 s3931 = 127 & s3929;+  const SWord8 s3932 = s3847 ? s3930 : s3931;+  const SWord8 s3933 = s1 + s3928;+  const SBool  s3934 = s3933 < s1;+  const SBool  s3935 = s3933 < s3928;+  const SBool  s3936 = s3934 || s3935;+  const SWord8 s3937 = (s3933 >> 1) | (s3933 << 7);+  const SWord8 s3938 = 128 | s3937;+  const SWord8 s3939 = 127 & s3937;+  const SWord8 s3940 = s3936 ? s3938 : s3939;+  const SWord8 s3941 = s3848 ? s3932 : s3940;+  const SWord8 s3942 = s3826 ? s3920 : s3941;+  const SWord8 s3943 = s3571 ? s3895 : s3942;+  const SWord8 s3944 = s1 + s3833;+  const SBool  s3945 = (SBool) ((s3944 >> 0) & 1);+  const SBool  s3946 = false != s3945;+  const SWord8 s3947 = s3946 ? s3837 : s3838;+  const SBool  s3948 = (SBool) ((s3947 >> 0) & 1);+  const SBool  s3949 = false != s3948;+  const SWord8 s3950 = s3949 ? s3843 : s3844;+  const SBool  s3951 = (SBool) ((s3950 >> 0) & 1);+  const SBool  s3952 = false != s3951;+  const SBool  s3953 = false == s3952;+  const SBool  s3954 = s3944 < s1;+  const SBool  s3955 = s3944 < s3833;+  const SBool  s3956 = s3954 || s3955;+  const SWord8 s3957 = (s3944 >> 1) | (s3944 << 7);+  const SWord8 s3958 = 128 | s3957;+  const SWord8 s3959 = 127 & s3957;+  const SWord8 s3960 = s3956 ? s3958 : s3959;+  const SWord8 s3961 = (s3960 >> 1) | (s3960 << 7);+  const SWord8 s3962 = 128 | s3961;+  const SWord8 s3963 = 127 & s3961;+  const SWord8 s3964 = s3570 ? s3962 : s3963;+  const SWord8 s3965 = (s3964 >> 1) | (s3964 << 7);+  const SWord8 s3966 = 128 | s3965;+  const SWord8 s3967 = 127 & s3965;+  const SWord8 s3968 = s3825 ? s3966 : s3967;+  const SWord8 s3969 = (s3968 >> 1) | (s3968 << 7);+  const SWord8 s3970 = 128 | s3969;+  const SWord8 s3971 = 127 & s3969;+  const SWord8 s3972 = s3952 ? s3970 : s3971;+  const SWord8 s3973 = s1 + s3968;+  const SBool  s3974 = s3973 < s1;+  const SBool  s3975 = s3973 < s3968;+  const SBool  s3976 = s3974 || s3975;+  const SWord8 s3977 = (s3973 >> 1) | (s3973 << 7);+  const SWord8 s3978 = 128 | s3977;+  const SWord8 s3979 = 127 & s3977;+  const SWord8 s3980 = s3976 ? s3978 : s3979;+  const SWord8 s3981 = s3953 ? s3972 : s3980;+  const SWord8 s3982 = s1 + s3964;+  const SBool  s3983 = s3982 < s1;+  const SBool  s3984 = s3982 < s3964;+  const SBool  s3985 = s3983 || s3984;+  const SWord8 s3986 = (s3982 >> 1) | (s3982 << 7);+  const SWord8 s3987 = 128 | s3986;+  const SWord8 s3988 = 127 & s3986;+  const SWord8 s3989 = s3985 ? s3987 : s3988;+  const SWord8 s3990 = (s3989 >> 1) | (s3989 << 7);+  const SWord8 s3991 = 128 | s3990;+  const SWord8 s3992 = 127 & s3990;+  const SWord8 s3993 = s3952 ? s3991 : s3992;+  const SWord8 s3994 = s1 + s3989;+  const SBool  s3995 = s3994 < s1;+  const SBool  s3996 = s3994 < s3989;+  const SBool  s3997 = s3995 || s3996;+  const SWord8 s3998 = (s3994 >> 1) | (s3994 << 7);+  const SWord8 s3999 = 128 | s3998;+  const SWord8 s4000 = 127 & s3998;+  const SWord8 s4001 = s3997 ? s3999 : s4000;+  const SWord8 s4002 = s3953 ? s3993 : s4001;+  const SWord8 s4003 = s3826 ? s3981 : s4002;+  const SWord8 s4004 = s1 + s3960;+  const SBool  s4005 = s4004 < s1;+  const SBool  s4006 = s4004 < s3960;+  const SBool  s4007 = s4005 || s4006;+  const SWord8 s4008 = (s4004 >> 1) | (s4004 << 7);+  const SWord8 s4009 = 128 | s4008;+  const SWord8 s4010 = 127 & s4008;+  const SWord8 s4011 = s4007 ? s4009 : s4010;+  const SWord8 s4012 = (s4011 >> 1) | (s4011 << 7);+  const SWord8 s4013 = 128 | s4012;+  const SWord8 s4014 = 127 & s4012;+  const SWord8 s4015 = s3825 ? s4013 : s4014;+  const SWord8 s4016 = (s4015 >> 1) | (s4015 << 7);+  const SWord8 s4017 = 128 | s4016;+  const SWord8 s4018 = 127 & s4016;+  const SWord8 s4019 = s3952 ? s4017 : s4018;+  const SWord8 s4020 = s1 + s4015;+  const SBool  s4021 = s4020 < s1;+  const SBool  s4022 = s4020 < s4015;+  const SBool  s4023 = s4021 || s4022;+  const SWord8 s4024 = (s4020 >> 1) | (s4020 << 7);+  const SWord8 s4025 = 128 | s4024;+  const SWord8 s4026 = 127 & s4024;+  const SWord8 s4027 = s4023 ? s4025 : s4026;+  const SWord8 s4028 = s3953 ? s4019 : s4027;+  const SWord8 s4029 = s1 + s4011;+  const SBool  s4030 = s4029 < s1;+  const SBool  s4031 = s4029 < s4011;+  const SBool  s4032 = s4030 || s4031;+  const SWord8 s4033 = (s4029 >> 1) | (s4029 << 7);+  const SWord8 s4034 = 128 | s4033;+  const SWord8 s4035 = 127 & s4033;+  const SWord8 s4036 = s4032 ? s4034 : s4035;+  const SWord8 s4037 = (s4036 >> 1) | (s4036 << 7);+  const SWord8 s4038 = 128 | s4037;+  const SWord8 s4039 = 127 & s4037;+  const SWord8 s4040 = s3952 ? s4038 : s4039;+  const SWord8 s4041 = s1 + s4036;+  const SBool  s4042 = s4041 < s1;+  const SBool  s4043 = s4041 < s4036;+  const SBool  s4044 = s4042 || s4043;+  const SWord8 s4045 = (s4041 >> 1) | (s4041 << 7);+  const SWord8 s4046 = 128 | s4045;+  const SWord8 s4047 = 127 & s4045;+  const SWord8 s4048 = s4044 ? s4046 : s4047;+  const SWord8 s4049 = s3953 ? s4040 : s4048;+  const SWord8 s4050 = s3826 ? s4028 : s4049;+  const SWord8 s4051 = s3571 ? s4003 : s4050;+  const SWord8 s4052 = s3060 ? s3943 : s4051;+  const SWord8 s4053 = s2042 ? s3816 : s4052;+  const SWord8 s4054 = s16 ? s3561 : s4053;+  const SWord8 s4055 = s11 ? s3050 : s4054;+  const SWord8 s4056 = s5 ? s2032 : s4055;+  const SBool  s4057 = (SBool) ((s105 >> 0) & 1);+  const SBool  s4058 = false != s4057;+  const SBool  s4059 = (SBool) ((s101 >> 0) & 1);+  const SBool  s4060 = false != s4059;+  const SBool  s4061 = (SBool) ((s97 >> 0) & 1);+  const SBool  s4062 = false != s4061;+  const SWord8 s4063 = (s84 >> 1) | (s84 << 7);+  const SWord8 s4064 = 128 | s4063;+  const SWord8 s4065 = 127 & s4063;+  const SWord8 s4066 = s4062 ? s4064 : s4065;+  const SWord8 s4067 = (s4066 >> 1) | (s4066 << 7);+  const SWord8 s4068 = 128 | s4067;+  const SWord8 s4069 = 127 & s4067;+  const SWord8 s4070 = s4060 ? s4068 : s4069;+  const SWord8 s4071 = (s4070 >> 1) | (s4070 << 7);+  const SWord8 s4072 = 128 | s4071;+  const SWord8 s4073 = 127 & s4071;+  const SWord8 s4074 = s4058 ? s4072 : s4073;+  const SBool  s4075 = (SBool) ((s110 >> 0) & 1);+  const SBool  s4076 = false != s4075;+  const SWord8 s4077 = s4076 ? s4072 : s4073;+  const SWord8 s4078 = s93 ? s4074 : s4077;+  const SBool  s4079 = (SBool) ((s126 >> 0) & 1);+  const SBool  s4080 = false != s4079;+  const SBool  s4081 = (SBool) ((s119 >> 0) & 1);+  const SBool  s4082 = false != s4081;+  const SWord8 s4083 = s4082 ? s4068 : s4069;+  const SWord8 s4084 = (s4083 >> 1) | (s4083 << 7);+  const SWord8 s4085 = 128 | s4084;+  const SWord8 s4086 = 127 & s4084;+  const SWord8 s4087 = s4080 ? s4085 : s4086;+  const SBool  s4088 = (SBool) ((s131 >> 0) & 1);+  const SBool  s4089 = false != s4088;+  const SWord8 s4090 = s4089 ? s4085 : s4086;+  const SWord8 s4091 = s93 ? s4087 : s4090;+  const SWord8 s4092 = s74 ? s4078 : s4091;+  const SBool  s4093 = (SBool) ((s152 >> 0) & 1);+  const SBool  s4094 = false != s4093;+  const SBool  s4095 = (SBool) ((s148 >> 0) & 1);+  const SBool  s4096 = false != s4095;+  const SBool  s4097 = (SBool) ((s141 >> 0) & 1);+  const SBool  s4098 = false != s4097;+  const SWord8 s4099 = s4098 ? s4064 : s4065;+  const SWord8 s4100 = (s4099 >> 1) | (s4099 << 7);+  const SWord8 s4101 = 128 | s4100;+  const SWord8 s4102 = 127 & s4100;+  const SWord8 s4103 = s4096 ? s4101 : s4102;+  const SWord8 s4104 = (s4103 >> 1) | (s4103 << 7);+  const SWord8 s4105 = 128 | s4104;+  const SWord8 s4106 = 127 & s4104;+  const SWord8 s4107 = s4094 ? s4105 : s4106;+  const SBool  s4108 = (SBool) ((s157 >> 0) & 1);+  const SBool  s4109 = false != s4108;+  const SWord8 s4110 = s4109 ? s4105 : s4106;+  const SWord8 s4111 = s93 ? s4107 : s4110;+  const SBool  s4112 = (SBool) ((s173 >> 0) & 1);+  const SBool  s4113 = false != s4112;+  const SBool  s4114 = (SBool) ((s166 >> 0) & 1);+  const SBool  s4115 = false != s4114;+  const SWord8 s4116 = s4115 ? s4101 : s4102;+  const SWord8 s4117 = (s4116 >> 1) | (s4116 << 7);+  const SWord8 s4118 = 128 | s4117;+  const SWord8 s4119 = 127 & s4117;+  const SWord8 s4120 = s4113 ? s4118 : s4119;+  const SBool  s4121 = (SBool) ((s178 >> 0) & 1);+  const SBool  s4122 = false != s4121;+  const SWord8 s4123 = s4122 ? s4118 : s4119;+  const SWord8 s4124 = s93 ? s4120 : s4123;+  const SWord8 s4125 = s74 ? s4111 : s4124;+  const SWord8 s4126 = s55 ? s4092 : s4125;+  const SBool  s4127 = (SBool) ((s213 >> 0) & 1);+  const SBool  s4128 = false != s4127;+  const SBool  s4129 = (SBool) ((s209 >> 0) & 1);+  const SBool  s4130 = false != s4129;+  const SBool  s4131 = (SBool) ((s205 >> 0) & 1);+  const SBool  s4132 = false != s4131;+  const SWord8 s4133 = (s192 >> 1) | (s192 << 7);+  const SWord8 s4134 = 128 | s4133;+  const SWord8 s4135 = 127 & s4133;+  const SWord8 s4136 = s4132 ? s4134 : s4135;+  const SWord8 s4137 = (s4136 >> 1) | (s4136 << 7);+  const SWord8 s4138 = 128 | s4137;+  const SWord8 s4139 = 127 & s4137;+  const SWord8 s4140 = s4130 ? s4138 : s4139;+  const SWord8 s4141 = (s4140 >> 1) | (s4140 << 7);+  const SWord8 s4142 = 128 | s4141;+  const SWord8 s4143 = 127 & s4141;+  const SWord8 s4144 = s4128 ? s4142 : s4143;+  const SBool  s4145 = (SBool) ((s218 >> 0) & 1);+  const SBool  s4146 = false != s4145;+  const SWord8 s4147 = s4146 ? s4142 : s4143;+  const SWord8 s4148 = s198 ? s4144 : s4147;+  const SBool  s4149 = (SBool) ((s234 >> 0) & 1);+  const SBool  s4150 = false != s4149;+  const SBool  s4151 = (SBool) ((s227 >> 0) & 1);+  const SBool  s4152 = false != s4151;+  const SWord8 s4153 = s4152 ? s4138 : s4139;+  const SWord8 s4154 = (s4153 >> 1) | (s4153 << 7);+  const SWord8 s4155 = 128 | s4154;+  const SWord8 s4156 = 127 & s4154;+  const SWord8 s4157 = s4150 ? s4155 : s4156;+  const SBool  s4158 = (SBool) ((s239 >> 0) & 1);+  const SBool  s4159 = false != s4158;+  const SWord8 s4160 = s4159 ? s4155 : s4156;+  const SWord8 s4161 = s198 ? s4157 : s4160;+  const SWord8 s4162 = s74 ? s4148 : s4161;+  const SBool  s4163 = (SBool) ((s260 >> 0) & 1);+  const SBool  s4164 = false != s4163;+  const SBool  s4165 = (SBool) ((s256 >> 0) & 1);+  const SBool  s4166 = false != s4165;+  const SBool  s4167 = (SBool) ((s249 >> 0) & 1);+  const SBool  s4168 = false != s4167;+  const SWord8 s4169 = s4168 ? s4134 : s4135;+  const SWord8 s4170 = (s4169 >> 1) | (s4169 << 7);+  const SWord8 s4171 = 128 | s4170;+  const SWord8 s4172 = 127 & s4170;+  const SWord8 s4173 = s4166 ? s4171 : s4172;+  const SWord8 s4174 = (s4173 >> 1) | (s4173 << 7);+  const SWord8 s4175 = 128 | s4174;+  const SWord8 s4176 = 127 & s4174;+  const SWord8 s4177 = s4164 ? s4175 : s4176;+  const SBool  s4178 = (SBool) ((s265 >> 0) & 1);+  const SBool  s4179 = false != s4178;+  const SWord8 s4180 = s4179 ? s4175 : s4176;+  const SWord8 s4181 = s198 ? s4177 : s4180;+  const SBool  s4182 = (SBool) ((s281 >> 0) & 1);+  const SBool  s4183 = false != s4182;+  const SBool  s4184 = (SBool) ((s274 >> 0) & 1);+  const SBool  s4185 = false != s4184;+  const SWord8 s4186 = s4185 ? s4171 : s4172;+  const SWord8 s4187 = (s4186 >> 1) | (s4186 << 7);+  const SWord8 s4188 = 128 | s4187;+  const SWord8 s4189 = 127 & s4187;+  const SWord8 s4190 = s4183 ? s4188 : s4189;+  const SBool  s4191 = (SBool) ((s286 >> 0) & 1);+  const SBool  s4192 = false != s4191;+  const SWord8 s4193 = s4192 ? s4188 : s4189;+  const SWord8 s4194 = s198 ? s4190 : s4193;+  const SWord8 s4195 = s74 ? s4181 : s4194;+  const SWord8 s4196 = s55 ? s4162 : s4195;+  const SWord8 s4197 = s36 ? s4126 : s4196;+  const SBool  s4198 = (SBool) ((s341 >> 0) & 1);+  const SBool  s4199 = false != s4198;+  const SBool  s4200 = (SBool) ((s337 >> 0) & 1);+  const SBool  s4201 = false != s4200;+  const SBool  s4202 = (SBool) ((s333 >> 0) & 1);+  const SBool  s4203 = false != s4202;+  const SWord8 s4204 = (s320 >> 1) | (s320 << 7);+  const SWord8 s4205 = 128 | s4204;+  const SWord8 s4206 = 127 & s4204;+  const SWord8 s4207 = s4203 ? s4205 : s4206;+  const SWord8 s4208 = (s4207 >> 1) | (s4207 << 7);+  const SWord8 s4209 = 128 | s4208;+  const SWord8 s4210 = 127 & s4208;+  const SWord8 s4211 = s4201 ? s4209 : s4210;+  const SWord8 s4212 = (s4211 >> 1) | (s4211 << 7);+  const SWord8 s4213 = 128 | s4212;+  const SWord8 s4214 = 127 & s4212;+  const SWord8 s4215 = s4199 ? s4213 : s4214;+  const SBool  s4216 = (SBool) ((s346 >> 0) & 1);+  const SBool  s4217 = false != s4216;+  const SWord8 s4218 = s4217 ? s4213 : s4214;+  const SWord8 s4219 = s329 ? s4215 : s4218;+  const SBool  s4220 = (SBool) ((s362 >> 0) & 1);+  const SBool  s4221 = false != s4220;+  const SBool  s4222 = (SBool) ((s355 >> 0) & 1);+  const SBool  s4223 = false != s4222;+  const SWord8 s4224 = s4223 ? s4209 : s4210;+  const SWord8 s4225 = (s4224 >> 1) | (s4224 << 7);+  const SWord8 s4226 = 128 | s4225;+  const SWord8 s4227 = 127 & s4225;+  const SWord8 s4228 = s4221 ? s4226 : s4227;+  const SBool  s4229 = (SBool) ((s367 >> 0) & 1);+  const SBool  s4230 = false != s4229;+  const SWord8 s4231 = s4230 ? s4226 : s4227;+  const SWord8 s4232 = s329 ? s4228 : s4231;+  const SWord8 s4233 = s307 ? s4219 : s4232;+  const SBool  s4234 = (SBool) ((s388 >> 0) & 1);+  const SBool  s4235 = false != s4234;+  const SBool  s4236 = (SBool) ((s384 >> 0) & 1);+  const SBool  s4237 = false != s4236;+  const SBool  s4238 = (SBool) ((s377 >> 0) & 1);+  const SBool  s4239 = false != s4238;+  const SWord8 s4240 = s4239 ? s4205 : s4206;+  const SWord8 s4241 = (s4240 >> 1) | (s4240 << 7);+  const SWord8 s4242 = 128 | s4241;+  const SWord8 s4243 = 127 & s4241;+  const SWord8 s4244 = s4237 ? s4242 : s4243;+  const SWord8 s4245 = (s4244 >> 1) | (s4244 << 7);+  const SWord8 s4246 = 128 | s4245;+  const SWord8 s4247 = 127 & s4245;+  const SWord8 s4248 = s4235 ? s4246 : s4247;+  const SBool  s4249 = (SBool) ((s393 >> 0) & 1);+  const SBool  s4250 = false != s4249;+  const SWord8 s4251 = s4250 ? s4246 : s4247;+  const SWord8 s4252 = s329 ? s4248 : s4251;+  const SBool  s4253 = (SBool) ((s409 >> 0) & 1);+  const SBool  s4254 = false != s4253;+  const SBool  s4255 = (SBool) ((s402 >> 0) & 1);+  const SBool  s4256 = false != s4255;+  const SWord8 s4257 = s4256 ? s4242 : s4243;+  const SWord8 s4258 = (s4257 >> 1) | (s4257 << 7);+  const SWord8 s4259 = 128 | s4258;+  const SWord8 s4260 = 127 & s4258;+  const SWord8 s4261 = s4254 ? s4259 : s4260;+  const SBool  s4262 = (SBool) ((s414 >> 0) & 1);+  const SBool  s4263 = false != s4262;+  const SWord8 s4264 = s4263 ? s4259 : s4260;+  const SWord8 s4265 = s329 ? s4261 : s4264;+  const SWord8 s4266 = s307 ? s4252 : s4265;+  const SWord8 s4267 = s55 ? s4233 : s4266;+  const SBool  s4268 = (SBool) ((s449 >> 0) & 1);+  const SBool  s4269 = false != s4268;+  const SBool  s4270 = (SBool) ((s445 >> 0) & 1);+  const SBool  s4271 = false != s4270;+  const SBool  s4272 = (SBool) ((s441 >> 0) & 1);+  const SBool  s4273 = false != s4272;+  const SWord8 s4274 = (s428 >> 1) | (s428 << 7);+  const SWord8 s4275 = 128 | s4274;+  const SWord8 s4276 = 127 & s4274;+  const SWord8 s4277 = s4273 ? s4275 : s4276;+  const SWord8 s4278 = (s4277 >> 1) | (s4277 << 7);+  const SWord8 s4279 = 128 | s4278;+  const SWord8 s4280 = 127 & s4278;+  const SWord8 s4281 = s4271 ? s4279 : s4280;+  const SWord8 s4282 = (s4281 >> 1) | (s4281 << 7);+  const SWord8 s4283 = 128 | s4282;+  const SWord8 s4284 = 127 & s4282;+  const SWord8 s4285 = s4269 ? s4283 : s4284;+  const SBool  s4286 = (SBool) ((s454 >> 0) & 1);+  const SBool  s4287 = false != s4286;+  const SWord8 s4288 = s4287 ? s4283 : s4284;+  const SWord8 s4289 = s434 ? s4285 : s4288;+  const SBool  s4290 = (SBool) ((s470 >> 0) & 1);+  const SBool  s4291 = false != s4290;+  const SBool  s4292 = (SBool) ((s463 >> 0) & 1);+  const SBool  s4293 = false != s4292;+  const SWord8 s4294 = s4293 ? s4279 : s4280;+  const SWord8 s4295 = (s4294 >> 1) | (s4294 << 7);+  const SWord8 s4296 = 128 | s4295;+  const SWord8 s4297 = 127 & s4295;+  const SWord8 s4298 = s4291 ? s4296 : s4297;+  const SBool  s4299 = (SBool) ((s475 >> 0) & 1);+  const SBool  s4300 = false != s4299;+  const SWord8 s4301 = s4300 ? s4296 : s4297;+  const SWord8 s4302 = s434 ? s4298 : s4301;+  const SWord8 s4303 = s307 ? s4289 : s4302;+  const SBool  s4304 = (SBool) ((s496 >> 0) & 1);+  const SBool  s4305 = false != s4304;+  const SBool  s4306 = (SBool) ((s492 >> 0) & 1);+  const SBool  s4307 = false != s4306;+  const SBool  s4308 = (SBool) ((s485 >> 0) & 1);+  const SBool  s4309 = false != s4308;+  const SWord8 s4310 = s4309 ? s4275 : s4276;+  const SWord8 s4311 = (s4310 >> 1) | (s4310 << 7);+  const SWord8 s4312 = 128 | s4311;+  const SWord8 s4313 = 127 & s4311;+  const SWord8 s4314 = s4307 ? s4312 : s4313;+  const SWord8 s4315 = (s4314 >> 1) | (s4314 << 7);+  const SWord8 s4316 = 128 | s4315;+  const SWord8 s4317 = 127 & s4315;+  const SWord8 s4318 = s4305 ? s4316 : s4317;+  const SBool  s4319 = (SBool) ((s501 >> 0) & 1);+  const SBool  s4320 = false != s4319;+  const SWord8 s4321 = s4320 ? s4316 : s4317;+  const SWord8 s4322 = s434 ? s4318 : s4321;+  const SBool  s4323 = (SBool) ((s517 >> 0) & 1);+  const SBool  s4324 = false != s4323;+  const SBool  s4325 = (SBool) ((s510 >> 0) & 1);+  const SBool  s4326 = false != s4325;+  const SWord8 s4327 = s4326 ? s4312 : s4313;+  const SWord8 s4328 = (s4327 >> 1) | (s4327 << 7);+  const SWord8 s4329 = 128 | s4328;+  const SWord8 s4330 = 127 & s4328;+  const SWord8 s4331 = s4324 ? s4329 : s4330;+  const SBool  s4332 = (SBool) ((s522 >> 0) & 1);+  const SBool  s4333 = false != s4332;+  const SWord8 s4334 = s4333 ? s4329 : s4330;+  const SWord8 s4335 = s434 ? s4331 : s4334;+  const SWord8 s4336 = s307 ? s4322 : s4335;+  const SWord8 s4337 = s55 ? s4303 : s4336;+  const SWord8 s4338 = s36 ? s4267 : s4337;+  const SWord8 s4339 = s21 ? s4197 : s4338;+  const SBool  s4340 = (SBool) ((s597 >> 0) & 1);+  const SBool  s4341 = false != s4340;+  const SBool  s4342 = (SBool) ((s593 >> 0) & 1);+  const SBool  s4343 = false != s4342;+  const SBool  s4344 = (SBool) ((s589 >> 0) & 1);+  const SBool  s4345 = false != s4344;+  const SWord8 s4346 = (s576 >> 1) | (s576 << 7);+  const SWord8 s4347 = 128 | s4346;+  const SWord8 s4348 = 127 & s4346;+  const SWord8 s4349 = s4345 ? s4347 : s4348;+  const SWord8 s4350 = (s4349 >> 1) | (s4349 << 7);+  const SWord8 s4351 = 128 | s4350;+  const SWord8 s4352 = 127 & s4350;+  const SWord8 s4353 = s4343 ? s4351 : s4352;+  const SWord8 s4354 = (s4353 >> 1) | (s4353 << 7);+  const SWord8 s4355 = 128 | s4354;+  const SWord8 s4356 = 127 & s4354;+  const SWord8 s4357 = s4341 ? s4355 : s4356;+  const SBool  s4358 = (SBool) ((s602 >> 0) & 1);+  const SBool  s4359 = false != s4358;+  const SWord8 s4360 = s4359 ? s4355 : s4356;+  const SWord8 s4361 = s585 ? s4357 : s4360;+  const SBool  s4362 = (SBool) ((s618 >> 0) & 1);+  const SBool  s4363 = false != s4362;+  const SBool  s4364 = (SBool) ((s611 >> 0) & 1);+  const SBool  s4365 = false != s4364;+  const SWord8 s4366 = s4365 ? s4351 : s4352;+  const SWord8 s4367 = (s4366 >> 1) | (s4366 << 7);+  const SWord8 s4368 = 128 | s4367;+  const SWord8 s4369 = 127 & s4367;+  const SWord8 s4370 = s4363 ? s4368 : s4369;+  const SBool  s4371 = (SBool) ((s623 >> 0) & 1);+  const SBool  s4372 = false != s4371;+  const SWord8 s4373 = s4372 ? s4368 : s4369;+  const SWord8 s4374 = s585 ? s4370 : s4373;+  const SWord8 s4375 = s566 ? s4361 : s4374;+  const SBool  s4376 = (SBool) ((s644 >> 0) & 1);+  const SBool  s4377 = false != s4376;+  const SBool  s4378 = (SBool) ((s640 >> 0) & 1);+  const SBool  s4379 = false != s4378;+  const SBool  s4380 = (SBool) ((s633 >> 0) & 1);+  const SBool  s4381 = false != s4380;+  const SWord8 s4382 = s4381 ? s4347 : s4348;+  const SWord8 s4383 = (s4382 >> 1) | (s4382 << 7);+  const SWord8 s4384 = 128 | s4383;+  const SWord8 s4385 = 127 & s4383;+  const SWord8 s4386 = s4379 ? s4384 : s4385;+  const SWord8 s4387 = (s4386 >> 1) | (s4386 << 7);+  const SWord8 s4388 = 128 | s4387;+  const SWord8 s4389 = 127 & s4387;+  const SWord8 s4390 = s4377 ? s4388 : s4389;+  const SBool  s4391 = (SBool) ((s649 >> 0) & 1);+  const SBool  s4392 = false != s4391;+  const SWord8 s4393 = s4392 ? s4388 : s4389;+  const SWord8 s4394 = s585 ? s4390 : s4393;+  const SBool  s4395 = (SBool) ((s665 >> 0) & 1);+  const SBool  s4396 = false != s4395;+  const SBool  s4397 = (SBool) ((s658 >> 0) & 1);+  const SBool  s4398 = false != s4397;+  const SWord8 s4399 = s4398 ? s4384 : s4385;+  const SWord8 s4400 = (s4399 >> 1) | (s4399 << 7);+  const SWord8 s4401 = 128 | s4400;+  const SWord8 s4402 = 127 & s4400;+  const SWord8 s4403 = s4396 ? s4401 : s4402;+  const SBool  s4404 = (SBool) ((s670 >> 0) & 1);+  const SBool  s4405 = false != s4404;+  const SWord8 s4406 = s4405 ? s4401 : s4402;+  const SWord8 s4407 = s585 ? s4403 : s4406;+  const SWord8 s4408 = s566 ? s4394 : s4407;+  const SWord8 s4409 = s544 ? s4375 : s4408;+  const SBool  s4410 = (SBool) ((s705 >> 0) & 1);+  const SBool  s4411 = false != s4410;+  const SBool  s4412 = (SBool) ((s701 >> 0) & 1);+  const SBool  s4413 = false != s4412;+  const SBool  s4414 = (SBool) ((s697 >> 0) & 1);+  const SBool  s4415 = false != s4414;+  const SWord8 s4416 = (s684 >> 1) | (s684 << 7);+  const SWord8 s4417 = 128 | s4416;+  const SWord8 s4418 = 127 & s4416;+  const SWord8 s4419 = s4415 ? s4417 : s4418;+  const SWord8 s4420 = (s4419 >> 1) | (s4419 << 7);+  const SWord8 s4421 = 128 | s4420;+  const SWord8 s4422 = 127 & s4420;+  const SWord8 s4423 = s4413 ? s4421 : s4422;+  const SWord8 s4424 = (s4423 >> 1) | (s4423 << 7);+  const SWord8 s4425 = 128 | s4424;+  const SWord8 s4426 = 127 & s4424;+  const SWord8 s4427 = s4411 ? s4425 : s4426;+  const SBool  s4428 = (SBool) ((s710 >> 0) & 1);+  const SBool  s4429 = false != s4428;+  const SWord8 s4430 = s4429 ? s4425 : s4426;+  const SWord8 s4431 = s690 ? s4427 : s4430;+  const SBool  s4432 = (SBool) ((s726 >> 0) & 1);+  const SBool  s4433 = false != s4432;+  const SBool  s4434 = (SBool) ((s719 >> 0) & 1);+  const SBool  s4435 = false != s4434;+  const SWord8 s4436 = s4435 ? s4421 : s4422;+  const SWord8 s4437 = (s4436 >> 1) | (s4436 << 7);+  const SWord8 s4438 = 128 | s4437;+  const SWord8 s4439 = 127 & s4437;+  const SWord8 s4440 = s4433 ? s4438 : s4439;+  const SBool  s4441 = (SBool) ((s731 >> 0) & 1);+  const SBool  s4442 = false != s4441;+  const SWord8 s4443 = s4442 ? s4438 : s4439;+  const SWord8 s4444 = s690 ? s4440 : s4443;+  const SWord8 s4445 = s566 ? s4431 : s4444;+  const SBool  s4446 = (SBool) ((s752 >> 0) & 1);+  const SBool  s4447 = false != s4446;+  const SBool  s4448 = (SBool) ((s748 >> 0) & 1);+  const SBool  s4449 = false != s4448;+  const SBool  s4450 = (SBool) ((s741 >> 0) & 1);+  const SBool  s4451 = false != s4450;+  const SWord8 s4452 = s4451 ? s4417 : s4418;+  const SWord8 s4453 = (s4452 >> 1) | (s4452 << 7);+  const SWord8 s4454 = 128 | s4453;+  const SWord8 s4455 = 127 & s4453;+  const SWord8 s4456 = s4449 ? s4454 : s4455;+  const SWord8 s4457 = (s4456 >> 1) | (s4456 << 7);+  const SWord8 s4458 = 128 | s4457;+  const SWord8 s4459 = 127 & s4457;+  const SWord8 s4460 = s4447 ? s4458 : s4459;+  const SBool  s4461 = (SBool) ((s757 >> 0) & 1);+  const SBool  s4462 = false != s4461;+  const SWord8 s4463 = s4462 ? s4458 : s4459;+  const SWord8 s4464 = s690 ? s4460 : s4463;+  const SBool  s4465 = (SBool) ((s773 >> 0) & 1);+  const SBool  s4466 = false != s4465;+  const SBool  s4467 = (SBool) ((s766 >> 0) & 1);+  const SBool  s4468 = false != s4467;+  const SWord8 s4469 = s4468 ? s4454 : s4455;+  const SWord8 s4470 = (s4469 >> 1) | (s4469 << 7);+  const SWord8 s4471 = 128 | s4470;+  const SWord8 s4472 = 127 & s4470;+  const SWord8 s4473 = s4466 ? s4471 : s4472;+  const SBool  s4474 = (SBool) ((s778 >> 0) & 1);+  const SBool  s4475 = false != s4474;+  const SWord8 s4476 = s4475 ? s4471 : s4472;+  const SWord8 s4477 = s690 ? s4473 : s4476;+  const SWord8 s4478 = s566 ? s4464 : s4477;+  const SWord8 s4479 = s544 ? s4445 : s4478;+  const SWord8 s4480 = s36 ? s4409 : s4479;+  const SBool  s4481 = (SBool) ((s833 >> 0) & 1);+  const SBool  s4482 = false != s4481;+  const SBool  s4483 = (SBool) ((s829 >> 0) & 1);+  const SBool  s4484 = false != s4483;+  const SBool  s4485 = (SBool) ((s825 >> 0) & 1);+  const SBool  s4486 = false != s4485;+  const SWord8 s4487 = (s812 >> 1) | (s812 << 7);+  const SWord8 s4488 = 128 | s4487;+  const SWord8 s4489 = 127 & s4487;+  const SWord8 s4490 = s4486 ? s4488 : s4489;+  const SWord8 s4491 = (s4490 >> 1) | (s4490 << 7);+  const SWord8 s4492 = 128 | s4491;+  const SWord8 s4493 = 127 & s4491;+  const SWord8 s4494 = s4484 ? s4492 : s4493;+  const SWord8 s4495 = (s4494 >> 1) | (s4494 << 7);+  const SWord8 s4496 = 128 | s4495;+  const SWord8 s4497 = 127 & s4495;+  const SWord8 s4498 = s4482 ? s4496 : s4497;+  const SBool  s4499 = (SBool) ((s838 >> 0) & 1);+  const SBool  s4500 = false != s4499;+  const SWord8 s4501 = s4500 ? s4496 : s4497;+  const SWord8 s4502 = s821 ? s4498 : s4501;+  const SBool  s4503 = (SBool) ((s854 >> 0) & 1);+  const SBool  s4504 = false != s4503;+  const SBool  s4505 = (SBool) ((s847 >> 0) & 1);+  const SBool  s4506 = false != s4505;+  const SWord8 s4507 = s4506 ? s4492 : s4493;+  const SWord8 s4508 = (s4507 >> 1) | (s4507 << 7);+  const SWord8 s4509 = 128 | s4508;+  const SWord8 s4510 = 127 & s4508;+  const SWord8 s4511 = s4504 ? s4509 : s4510;+  const SBool  s4512 = (SBool) ((s859 >> 0) & 1);+  const SBool  s4513 = false != s4512;+  const SWord8 s4514 = s4513 ? s4509 : s4510;+  const SWord8 s4515 = s821 ? s4511 : s4514;+  const SWord8 s4516 = s799 ? s4502 : s4515;+  const SBool  s4517 = (SBool) ((s880 >> 0) & 1);+  const SBool  s4518 = false != s4517;+  const SBool  s4519 = (SBool) ((s876 >> 0) & 1);+  const SBool  s4520 = false != s4519;+  const SBool  s4521 = (SBool) ((s869 >> 0) & 1);+  const SBool  s4522 = false != s4521;+  const SWord8 s4523 = s4522 ? s4488 : s4489;+  const SWord8 s4524 = (s4523 >> 1) | (s4523 << 7);+  const SWord8 s4525 = 128 | s4524;+  const SWord8 s4526 = 127 & s4524;+  const SWord8 s4527 = s4520 ? s4525 : s4526;+  const SWord8 s4528 = (s4527 >> 1) | (s4527 << 7);+  const SWord8 s4529 = 128 | s4528;+  const SWord8 s4530 = 127 & s4528;+  const SWord8 s4531 = s4518 ? s4529 : s4530;+  const SBool  s4532 = (SBool) ((s885 >> 0) & 1);+  const SBool  s4533 = false != s4532;+  const SWord8 s4534 = s4533 ? s4529 : s4530;+  const SWord8 s4535 = s821 ? s4531 : s4534;+  const SBool  s4536 = (SBool) ((s901 >> 0) & 1);+  const SBool  s4537 = false != s4536;+  const SBool  s4538 = (SBool) ((s894 >> 0) & 1);+  const SBool  s4539 = false != s4538;+  const SWord8 s4540 = s4539 ? s4525 : s4526;+  const SWord8 s4541 = (s4540 >> 1) | (s4540 << 7);+  const SWord8 s4542 = 128 | s4541;+  const SWord8 s4543 = 127 & s4541;+  const SWord8 s4544 = s4537 ? s4542 : s4543;+  const SBool  s4545 = (SBool) ((s906 >> 0) & 1);+  const SBool  s4546 = false != s4545;+  const SWord8 s4547 = s4546 ? s4542 : s4543;+  const SWord8 s4548 = s821 ? s4544 : s4547;+  const SWord8 s4549 = s799 ? s4535 : s4548;+  const SWord8 s4550 = s544 ? s4516 : s4549;+  const SBool  s4551 = (SBool) ((s941 >> 0) & 1);+  const SBool  s4552 = false != s4551;+  const SBool  s4553 = (SBool) ((s937 >> 0) & 1);+  const SBool  s4554 = false != s4553;+  const SBool  s4555 = (SBool) ((s933 >> 0) & 1);+  const SBool  s4556 = false != s4555;+  const SWord8 s4557 = (s920 >> 1) | (s920 << 7);+  const SWord8 s4558 = 128 | s4557;+  const SWord8 s4559 = 127 & s4557;+  const SWord8 s4560 = s4556 ? s4558 : s4559;+  const SWord8 s4561 = (s4560 >> 1) | (s4560 << 7);+  const SWord8 s4562 = 128 | s4561;+  const SWord8 s4563 = 127 & s4561;+  const SWord8 s4564 = s4554 ? s4562 : s4563;+  const SWord8 s4565 = (s4564 >> 1) | (s4564 << 7);+  const SWord8 s4566 = 128 | s4565;+  const SWord8 s4567 = 127 & s4565;+  const SWord8 s4568 = s4552 ? s4566 : s4567;+  const SBool  s4569 = (SBool) ((s946 >> 0) & 1);+  const SBool  s4570 = false != s4569;+  const SWord8 s4571 = s4570 ? s4566 : s4567;+  const SWord8 s4572 = s926 ? s4568 : s4571;+  const SBool  s4573 = (SBool) ((s962 >> 0) & 1);+  const SBool  s4574 = false != s4573;+  const SBool  s4575 = (SBool) ((s955 >> 0) & 1);+  const SBool  s4576 = false != s4575;+  const SWord8 s4577 = s4576 ? s4562 : s4563;+  const SWord8 s4578 = (s4577 >> 1) | (s4577 << 7);+  const SWord8 s4579 = 128 | s4578;+  const SWord8 s4580 = 127 & s4578;+  const SWord8 s4581 = s4574 ? s4579 : s4580;+  const SBool  s4582 = (SBool) ((s967 >> 0) & 1);+  const SBool  s4583 = false != s4582;+  const SWord8 s4584 = s4583 ? s4579 : s4580;+  const SWord8 s4585 = s926 ? s4581 : s4584;+  const SWord8 s4586 = s799 ? s4572 : s4585;+  const SBool  s4587 = (SBool) ((s988 >> 0) & 1);+  const SBool  s4588 = false != s4587;+  const SBool  s4589 = (SBool) ((s984 >> 0) & 1);+  const SBool  s4590 = false != s4589;+  const SBool  s4591 = (SBool) ((s977 >> 0) & 1);+  const SBool  s4592 = false != s4591;+  const SWord8 s4593 = s4592 ? s4558 : s4559;+  const SWord8 s4594 = (s4593 >> 1) | (s4593 << 7);+  const SWord8 s4595 = 128 | s4594;+  const SWord8 s4596 = 127 & s4594;+  const SWord8 s4597 = s4590 ? s4595 : s4596;+  const SWord8 s4598 = (s4597 >> 1) | (s4597 << 7);+  const SWord8 s4599 = 128 | s4598;+  const SWord8 s4600 = 127 & s4598;+  const SWord8 s4601 = s4588 ? s4599 : s4600;+  const SBool  s4602 = (SBool) ((s993 >> 0) & 1);+  const SBool  s4603 = false != s4602;+  const SWord8 s4604 = s4603 ? s4599 : s4600;+  const SWord8 s4605 = s926 ? s4601 : s4604;+  const SBool  s4606 = (SBool) ((s1009 >> 0) & 1);+  const SBool  s4607 = false != s4606;+  const SBool  s4608 = (SBool) ((s1002 >> 0) & 1);+  const SBool  s4609 = false != s4608;+  const SWord8 s4610 = s4609 ? s4595 : s4596;+  const SWord8 s4611 = (s4610 >> 1) | (s4610 << 7);+  const SWord8 s4612 = 128 | s4611;+  const SWord8 s4613 = 127 & s4611;+  const SWord8 s4614 = s4607 ? s4612 : s4613;+  const SBool  s4615 = (SBool) ((s1014 >> 0) & 1);+  const SBool  s4616 = false != s4615;+  const SWord8 s4617 = s4616 ? s4612 : s4613;+  const SWord8 s4618 = s926 ? s4614 : s4617;+  const SWord8 s4619 = s799 ? s4605 : s4618;+  const SWord8 s4620 = s544 ? s4586 : s4619;+  const SWord8 s4621 = s36 ? s4550 : s4620;+  const SWord8 s4622 = s21 ? s4480 : s4621;+  const SWord8 s4623 = s16 ? s4339 : s4622;+  const SBool  s4624 = (SBool) ((s1109 >> 0) & 1);+  const SBool  s4625 = false != s4624;+  const SBool  s4626 = (SBool) ((s1105 >> 0) & 1);+  const SBool  s4627 = false != s4626;+  const SBool  s4628 = (SBool) ((s1101 >> 0) & 1);+  const SBool  s4629 = false != s4628;+  const SWord8 s4630 = (s1088 >> 1) | (s1088 << 7);+  const SWord8 s4631 = 128 | s4630;+  const SWord8 s4632 = 127 & s4630;+  const SWord8 s4633 = s4629 ? s4631 : s4632;+  const SWord8 s4634 = (s4633 >> 1) | (s4633 << 7);+  const SWord8 s4635 = 128 | s4634;+  const SWord8 s4636 = 127 & s4634;+  const SWord8 s4637 = s4627 ? s4635 : s4636;+  const SWord8 s4638 = (s4637 >> 1) | (s4637 << 7);+  const SWord8 s4639 = 128 | s4638;+  const SWord8 s4640 = 127 & s4638;+  const SWord8 s4641 = s4625 ? s4639 : s4640;+  const SBool  s4642 = (SBool) ((s1114 >> 0) & 1);+  const SBool  s4643 = false != s4642;+  const SWord8 s4644 = s4643 ? s4639 : s4640;+  const SWord8 s4645 = s1097 ? s4641 : s4644;+  const SBool  s4646 = (SBool) ((s1130 >> 0) & 1);+  const SBool  s4647 = false != s4646;+  const SBool  s4648 = (SBool) ((s1123 >> 0) & 1);+  const SBool  s4649 = false != s4648;+  const SWord8 s4650 = s4649 ? s4635 : s4636;+  const SWord8 s4651 = (s4650 >> 1) | (s4650 << 7);+  const SWord8 s4652 = 128 | s4651;+  const SWord8 s4653 = 127 & s4651;+  const SWord8 s4654 = s4647 ? s4652 : s4653;+  const SBool  s4655 = (SBool) ((s1135 >> 0) & 1);+  const SBool  s4656 = false != s4655;+  const SWord8 s4657 = s4656 ? s4652 : s4653;+  const SWord8 s4658 = s1097 ? s4654 : s4657;+  const SWord8 s4659 = s1078 ? s4645 : s4658;+  const SBool  s4660 = (SBool) ((s1156 >> 0) & 1);+  const SBool  s4661 = false != s4660;+  const SBool  s4662 = (SBool) ((s1152 >> 0) & 1);+  const SBool  s4663 = false != s4662;+  const SBool  s4664 = (SBool) ((s1145 >> 0) & 1);+  const SBool  s4665 = false != s4664;+  const SWord8 s4666 = s4665 ? s4631 : s4632;+  const SWord8 s4667 = (s4666 >> 1) | (s4666 << 7);+  const SWord8 s4668 = 128 | s4667;+  const SWord8 s4669 = 127 & s4667;+  const SWord8 s4670 = s4663 ? s4668 : s4669;+  const SWord8 s4671 = (s4670 >> 1) | (s4670 << 7);+  const SWord8 s4672 = 128 | s4671;+  const SWord8 s4673 = 127 & s4671;+  const SWord8 s4674 = s4661 ? s4672 : s4673;+  const SBool  s4675 = (SBool) ((s1161 >> 0) & 1);+  const SBool  s4676 = false != s4675;+  const SWord8 s4677 = s4676 ? s4672 : s4673;+  const SWord8 s4678 = s1097 ? s4674 : s4677;+  const SBool  s4679 = (SBool) ((s1177 >> 0) & 1);+  const SBool  s4680 = false != s4679;+  const SBool  s4681 = (SBool) ((s1170 >> 0) & 1);+  const SBool  s4682 = false != s4681;+  const SWord8 s4683 = s4682 ? s4668 : s4669;+  const SWord8 s4684 = (s4683 >> 1) | (s4683 << 7);+  const SWord8 s4685 = 128 | s4684;+  const SWord8 s4686 = 127 & s4684;+  const SWord8 s4687 = s4680 ? s4685 : s4686;+  const SBool  s4688 = (SBool) ((s1182 >> 0) & 1);+  const SBool  s4689 = false != s4688;+  const SWord8 s4690 = s4689 ? s4685 : s4686;+  const SWord8 s4691 = s1097 ? s4687 : s4690;+  const SWord8 s4692 = s1078 ? s4678 : s4691;+  const SWord8 s4693 = s1059 ? s4659 : s4692;+  const SBool  s4694 = (SBool) ((s1217 >> 0) & 1);+  const SBool  s4695 = false != s4694;+  const SBool  s4696 = (SBool) ((s1213 >> 0) & 1);+  const SBool  s4697 = false != s4696;+  const SBool  s4698 = (SBool) ((s1209 >> 0) & 1);+  const SBool  s4699 = false != s4698;+  const SWord8 s4700 = (s1196 >> 1) | (s1196 << 7);+  const SWord8 s4701 = 128 | s4700;+  const SWord8 s4702 = 127 & s4700;+  const SWord8 s4703 = s4699 ? s4701 : s4702;+  const SWord8 s4704 = (s4703 >> 1) | (s4703 << 7);+  const SWord8 s4705 = 128 | s4704;+  const SWord8 s4706 = 127 & s4704;+  const SWord8 s4707 = s4697 ? s4705 : s4706;+  const SWord8 s4708 = (s4707 >> 1) | (s4707 << 7);+  const SWord8 s4709 = 128 | s4708;+  const SWord8 s4710 = 127 & s4708;+  const SWord8 s4711 = s4695 ? s4709 : s4710;+  const SBool  s4712 = (SBool) ((s1222 >> 0) & 1);+  const SBool  s4713 = false != s4712;+  const SWord8 s4714 = s4713 ? s4709 : s4710;+  const SWord8 s4715 = s1202 ? s4711 : s4714;+  const SBool  s4716 = (SBool) ((s1238 >> 0) & 1);+  const SBool  s4717 = false != s4716;+  const SBool  s4718 = (SBool) ((s1231 >> 0) & 1);+  const SBool  s4719 = false != s4718;+  const SWord8 s4720 = s4719 ? s4705 : s4706;+  const SWord8 s4721 = (s4720 >> 1) | (s4720 << 7);+  const SWord8 s4722 = 128 | s4721;+  const SWord8 s4723 = 127 & s4721;+  const SWord8 s4724 = s4717 ? s4722 : s4723;+  const SBool  s4725 = (SBool) ((s1243 >> 0) & 1);+  const SBool  s4726 = false != s4725;+  const SWord8 s4727 = s4726 ? s4722 : s4723;+  const SWord8 s4728 = s1202 ? s4724 : s4727;+  const SWord8 s4729 = s1078 ? s4715 : s4728;+  const SBool  s4730 = (SBool) ((s1264 >> 0) & 1);+  const SBool  s4731 = false != s4730;+  const SBool  s4732 = (SBool) ((s1260 >> 0) & 1);+  const SBool  s4733 = false != s4732;+  const SBool  s4734 = (SBool) ((s1253 >> 0) & 1);+  const SBool  s4735 = false != s4734;+  const SWord8 s4736 = s4735 ? s4701 : s4702;+  const SWord8 s4737 = (s4736 >> 1) | (s4736 << 7);+  const SWord8 s4738 = 128 | s4737;+  const SWord8 s4739 = 127 & s4737;+  const SWord8 s4740 = s4733 ? s4738 : s4739;+  const SWord8 s4741 = (s4740 >> 1) | (s4740 << 7);+  const SWord8 s4742 = 128 | s4741;+  const SWord8 s4743 = 127 & s4741;+  const SWord8 s4744 = s4731 ? s4742 : s4743;+  const SBool  s4745 = (SBool) ((s1269 >> 0) & 1);+  const SBool  s4746 = false != s4745;+  const SWord8 s4747 = s4746 ? s4742 : s4743;+  const SWord8 s4748 = s1202 ? s4744 : s4747;+  const SBool  s4749 = (SBool) ((s1285 >> 0) & 1);+  const SBool  s4750 = false != s4749;+  const SBool  s4751 = (SBool) ((s1278 >> 0) & 1);+  const SBool  s4752 = false != s4751;+  const SWord8 s4753 = s4752 ? s4738 : s4739;+  const SWord8 s4754 = (s4753 >> 1) | (s4753 << 7);+  const SWord8 s4755 = 128 | s4754;+  const SWord8 s4756 = 127 & s4754;+  const SWord8 s4757 = s4750 ? s4755 : s4756;+  const SBool  s4758 = (SBool) ((s1290 >> 0) & 1);+  const SBool  s4759 = false != s4758;+  const SWord8 s4760 = s4759 ? s4755 : s4756;+  const SWord8 s4761 = s1202 ? s4757 : s4760;+  const SWord8 s4762 = s1078 ? s4748 : s4761;+  const SWord8 s4763 = s1059 ? s4729 : s4762;+  const SWord8 s4764 = s1037 ? s4693 : s4763;+  const SBool  s4765 = (SBool) ((s1345 >> 0) & 1);+  const SBool  s4766 = false != s4765;+  const SBool  s4767 = (SBool) ((s1341 >> 0) & 1);+  const SBool  s4768 = false != s4767;+  const SBool  s4769 = (SBool) ((s1337 >> 0) & 1);+  const SBool  s4770 = false != s4769;+  const SWord8 s4771 = (s1324 >> 1) | (s1324 << 7);+  const SWord8 s4772 = 128 | s4771;+  const SWord8 s4773 = 127 & s4771;+  const SWord8 s4774 = s4770 ? s4772 : s4773;+  const SWord8 s4775 = (s4774 >> 1) | (s4774 << 7);+  const SWord8 s4776 = 128 | s4775;+  const SWord8 s4777 = 127 & s4775;+  const SWord8 s4778 = s4768 ? s4776 : s4777;+  const SWord8 s4779 = (s4778 >> 1) | (s4778 << 7);+  const SWord8 s4780 = 128 | s4779;+  const SWord8 s4781 = 127 & s4779;+  const SWord8 s4782 = s4766 ? s4780 : s4781;+  const SBool  s4783 = (SBool) ((s1350 >> 0) & 1);+  const SBool  s4784 = false != s4783;+  const SWord8 s4785 = s4784 ? s4780 : s4781;+  const SWord8 s4786 = s1333 ? s4782 : s4785;+  const SBool  s4787 = (SBool) ((s1366 >> 0) & 1);+  const SBool  s4788 = false != s4787;+  const SBool  s4789 = (SBool) ((s1359 >> 0) & 1);+  const SBool  s4790 = false != s4789;+  const SWord8 s4791 = s4790 ? s4776 : s4777;+  const SWord8 s4792 = (s4791 >> 1) | (s4791 << 7);+  const SWord8 s4793 = 128 | s4792;+  const SWord8 s4794 = 127 & s4792;+  const SWord8 s4795 = s4788 ? s4793 : s4794;+  const SBool  s4796 = (SBool) ((s1371 >> 0) & 1);+  const SBool  s4797 = false != s4796;+  const SWord8 s4798 = s4797 ? s4793 : s4794;+  const SWord8 s4799 = s1333 ? s4795 : s4798;+  const SWord8 s4800 = s1311 ? s4786 : s4799;+  const SBool  s4801 = (SBool) ((s1392 >> 0) & 1);+  const SBool  s4802 = false != s4801;+  const SBool  s4803 = (SBool) ((s1388 >> 0) & 1);+  const SBool  s4804 = false != s4803;+  const SBool  s4805 = (SBool) ((s1381 >> 0) & 1);+  const SBool  s4806 = false != s4805;+  const SWord8 s4807 = s4806 ? s4772 : s4773;+  const SWord8 s4808 = (s4807 >> 1) | (s4807 << 7);+  const SWord8 s4809 = 128 | s4808;+  const SWord8 s4810 = 127 & s4808;+  const SWord8 s4811 = s4804 ? s4809 : s4810;+  const SWord8 s4812 = (s4811 >> 1) | (s4811 << 7);+  const SWord8 s4813 = 128 | s4812;+  const SWord8 s4814 = 127 & s4812;+  const SWord8 s4815 = s4802 ? s4813 : s4814;+  const SBool  s4816 = (SBool) ((s1397 >> 0) & 1);+  const SBool  s4817 = false != s4816;+  const SWord8 s4818 = s4817 ? s4813 : s4814;+  const SWord8 s4819 = s1333 ? s4815 : s4818;+  const SBool  s4820 = (SBool) ((s1413 >> 0) & 1);+  const SBool  s4821 = false != s4820;+  const SBool  s4822 = (SBool) ((s1406 >> 0) & 1);+  const SBool  s4823 = false != s4822;+  const SWord8 s4824 = s4823 ? s4809 : s4810;+  const SWord8 s4825 = (s4824 >> 1) | (s4824 << 7);+  const SWord8 s4826 = 128 | s4825;+  const SWord8 s4827 = 127 & s4825;+  const SWord8 s4828 = s4821 ? s4826 : s4827;+  const SBool  s4829 = (SBool) ((s1418 >> 0) & 1);+  const SBool  s4830 = false != s4829;+  const SWord8 s4831 = s4830 ? s4826 : s4827;+  const SWord8 s4832 = s1333 ? s4828 : s4831;+  const SWord8 s4833 = s1311 ? s4819 : s4832;+  const SWord8 s4834 = s1059 ? s4800 : s4833;+  const SBool  s4835 = (SBool) ((s1453 >> 0) & 1);+  const SBool  s4836 = false != s4835;+  const SBool  s4837 = (SBool) ((s1449 >> 0) & 1);+  const SBool  s4838 = false != s4837;+  const SBool  s4839 = (SBool) ((s1445 >> 0) & 1);+  const SBool  s4840 = false != s4839;+  const SWord8 s4841 = (s1432 >> 1) | (s1432 << 7);+  const SWord8 s4842 = 128 | s4841;+  const SWord8 s4843 = 127 & s4841;+  const SWord8 s4844 = s4840 ? s4842 : s4843;+  const SWord8 s4845 = (s4844 >> 1) | (s4844 << 7);+  const SWord8 s4846 = 128 | s4845;+  const SWord8 s4847 = 127 & s4845;+  const SWord8 s4848 = s4838 ? s4846 : s4847;+  const SWord8 s4849 = (s4848 >> 1) | (s4848 << 7);+  const SWord8 s4850 = 128 | s4849;+  const SWord8 s4851 = 127 & s4849;+  const SWord8 s4852 = s4836 ? s4850 : s4851;+  const SBool  s4853 = (SBool) ((s1458 >> 0) & 1);+  const SBool  s4854 = false != s4853;+  const SWord8 s4855 = s4854 ? s4850 : s4851;+  const SWord8 s4856 = s1438 ? s4852 : s4855;+  const SBool  s4857 = (SBool) ((s1474 >> 0) & 1);+  const SBool  s4858 = false != s4857;+  const SBool  s4859 = (SBool) ((s1467 >> 0) & 1);+  const SBool  s4860 = false != s4859;+  const SWord8 s4861 = s4860 ? s4846 : s4847;+  const SWord8 s4862 = (s4861 >> 1) | (s4861 << 7);+  const SWord8 s4863 = 128 | s4862;+  const SWord8 s4864 = 127 & s4862;+  const SWord8 s4865 = s4858 ? s4863 : s4864;+  const SBool  s4866 = (SBool) ((s1479 >> 0) & 1);+  const SBool  s4867 = false != s4866;+  const SWord8 s4868 = s4867 ? s4863 : s4864;+  const SWord8 s4869 = s1438 ? s4865 : s4868;+  const SWord8 s4870 = s1311 ? s4856 : s4869;+  const SBool  s4871 = (SBool) ((s1500 >> 0) & 1);+  const SBool  s4872 = false != s4871;+  const SBool  s4873 = (SBool) ((s1496 >> 0) & 1);+  const SBool  s4874 = false != s4873;+  const SBool  s4875 = (SBool) ((s1489 >> 0) & 1);+  const SBool  s4876 = false != s4875;+  const SWord8 s4877 = s4876 ? s4842 : s4843;+  const SWord8 s4878 = (s4877 >> 1) | (s4877 << 7);+  const SWord8 s4879 = 128 | s4878;+  const SWord8 s4880 = 127 & s4878;+  const SWord8 s4881 = s4874 ? s4879 : s4880;+  const SWord8 s4882 = (s4881 >> 1) | (s4881 << 7);+  const SWord8 s4883 = 128 | s4882;+  const SWord8 s4884 = 127 & s4882;+  const SWord8 s4885 = s4872 ? s4883 : s4884;+  const SBool  s4886 = (SBool) ((s1505 >> 0) & 1);+  const SBool  s4887 = false != s4886;+  const SWord8 s4888 = s4887 ? s4883 : s4884;+  const SWord8 s4889 = s1438 ? s4885 : s4888;+  const SBool  s4890 = (SBool) ((s1521 >> 0) & 1);+  const SBool  s4891 = false != s4890;+  const SBool  s4892 = (SBool) ((s1514 >> 0) & 1);+  const SBool  s4893 = false != s4892;+  const SWord8 s4894 = s4893 ? s4879 : s4880;+  const SWord8 s4895 = (s4894 >> 1) | (s4894 << 7);+  const SWord8 s4896 = 128 | s4895;+  const SWord8 s4897 = 127 & s4895;+  const SWord8 s4898 = s4891 ? s4896 : s4897;+  const SBool  s4899 = (SBool) ((s1526 >> 0) & 1);+  const SBool  s4900 = false != s4899;+  const SWord8 s4901 = s4900 ? s4896 : s4897;+  const SWord8 s4902 = s1438 ? s4898 : s4901;+  const SWord8 s4903 = s1311 ? s4889 : s4902;+  const SWord8 s4904 = s1059 ? s4870 : s4903;+  const SWord8 s4905 = s1037 ? s4834 : s4904;+  const SWord8 s4906 = s21 ? s4764 : s4905;+  const SBool  s4907 = (SBool) ((s1601 >> 0) & 1);+  const SBool  s4908 = false != s4907;+  const SBool  s4909 = (SBool) ((s1597 >> 0) & 1);+  const SBool  s4910 = false != s4909;+  const SBool  s4911 = (SBool) ((s1593 >> 0) & 1);+  const SBool  s4912 = false != s4911;+  const SWord8 s4913 = (s1580 >> 1) | (s1580 << 7);+  const SWord8 s4914 = 128 | s4913;+  const SWord8 s4915 = 127 & s4913;+  const SWord8 s4916 = s4912 ? s4914 : s4915;+  const SWord8 s4917 = (s4916 >> 1) | (s4916 << 7);+  const SWord8 s4918 = 128 | s4917;+  const SWord8 s4919 = 127 & s4917;+  const SWord8 s4920 = s4910 ? s4918 : s4919;+  const SWord8 s4921 = (s4920 >> 1) | (s4920 << 7);+  const SWord8 s4922 = 128 | s4921;+  const SWord8 s4923 = 127 & s4921;+  const SWord8 s4924 = s4908 ? s4922 : s4923;+  const SBool  s4925 = (SBool) ((s1606 >> 0) & 1);+  const SBool  s4926 = false != s4925;+  const SWord8 s4927 = s4926 ? s4922 : s4923;+  const SWord8 s4928 = s1589 ? s4924 : s4927;+  const SBool  s4929 = (SBool) ((s1622 >> 0) & 1);+  const SBool  s4930 = false != s4929;+  const SBool  s4931 = (SBool) ((s1615 >> 0) & 1);+  const SBool  s4932 = false != s4931;+  const SWord8 s4933 = s4932 ? s4918 : s4919;+  const SWord8 s4934 = (s4933 >> 1) | (s4933 << 7);+  const SWord8 s4935 = 128 | s4934;+  const SWord8 s4936 = 127 & s4934;+  const SWord8 s4937 = s4930 ? s4935 : s4936;+  const SBool  s4938 = (SBool) ((s1627 >> 0) & 1);+  const SBool  s4939 = false != s4938;+  const SWord8 s4940 = s4939 ? s4935 : s4936;+  const SWord8 s4941 = s1589 ? s4937 : s4940;+  const SWord8 s4942 = s1570 ? s4928 : s4941;+  const SBool  s4943 = (SBool) ((s1648 >> 0) & 1);+  const SBool  s4944 = false != s4943;+  const SBool  s4945 = (SBool) ((s1644 >> 0) & 1);+  const SBool  s4946 = false != s4945;+  const SBool  s4947 = (SBool) ((s1637 >> 0) & 1);+  const SBool  s4948 = false != s4947;+  const SWord8 s4949 = s4948 ? s4914 : s4915;+  const SWord8 s4950 = (s4949 >> 1) | (s4949 << 7);+  const SWord8 s4951 = 128 | s4950;+  const SWord8 s4952 = 127 & s4950;+  const SWord8 s4953 = s4946 ? s4951 : s4952;+  const SWord8 s4954 = (s4953 >> 1) | (s4953 << 7);+  const SWord8 s4955 = 128 | s4954;+  const SWord8 s4956 = 127 & s4954;+  const SWord8 s4957 = s4944 ? s4955 : s4956;+  const SBool  s4958 = (SBool) ((s1653 >> 0) & 1);+  const SBool  s4959 = false != s4958;+  const SWord8 s4960 = s4959 ? s4955 : s4956;+  const SWord8 s4961 = s1589 ? s4957 : s4960;+  const SBool  s4962 = (SBool) ((s1669 >> 0) & 1);+  const SBool  s4963 = false != s4962;+  const SBool  s4964 = (SBool) ((s1662 >> 0) & 1);+  const SBool  s4965 = false != s4964;+  const SWord8 s4966 = s4965 ? s4951 : s4952;+  const SWord8 s4967 = (s4966 >> 1) | (s4966 << 7);+  const SWord8 s4968 = 128 | s4967;+  const SWord8 s4969 = 127 & s4967;+  const SWord8 s4970 = s4963 ? s4968 : s4969;+  const SBool  s4971 = (SBool) ((s1674 >> 0) & 1);+  const SBool  s4972 = false != s4971;+  const SWord8 s4973 = s4972 ? s4968 : s4969;+  const SWord8 s4974 = s1589 ? s4970 : s4973;+  const SWord8 s4975 = s1570 ? s4961 : s4974;+  const SWord8 s4976 = s1548 ? s4942 : s4975;+  const SBool  s4977 = (SBool) ((s1709 >> 0) & 1);+  const SBool  s4978 = false != s4977;+  const SBool  s4979 = (SBool) ((s1705 >> 0) & 1);+  const SBool  s4980 = false != s4979;+  const SBool  s4981 = (SBool) ((s1701 >> 0) & 1);+  const SBool  s4982 = false != s4981;+  const SWord8 s4983 = (s1688 >> 1) | (s1688 << 7);+  const SWord8 s4984 = 128 | s4983;+  const SWord8 s4985 = 127 & s4983;+  const SWord8 s4986 = s4982 ? s4984 : s4985;+  const SWord8 s4987 = (s4986 >> 1) | (s4986 << 7);+  const SWord8 s4988 = 128 | s4987;+  const SWord8 s4989 = 127 & s4987;+  const SWord8 s4990 = s4980 ? s4988 : s4989;+  const SWord8 s4991 = (s4990 >> 1) | (s4990 << 7);+  const SWord8 s4992 = 128 | s4991;+  const SWord8 s4993 = 127 & s4991;+  const SWord8 s4994 = s4978 ? s4992 : s4993;+  const SBool  s4995 = (SBool) ((s1714 >> 0) & 1);+  const SBool  s4996 = false != s4995;+  const SWord8 s4997 = s4996 ? s4992 : s4993;+  const SWord8 s4998 = s1694 ? s4994 : s4997;+  const SBool  s4999 = (SBool) ((s1730 >> 0) & 1);+  const SBool  s5000 = false != s4999;+  const SBool  s5001 = (SBool) ((s1723 >> 0) & 1);+  const SBool  s5002 = false != s5001;+  const SWord8 s5003 = s5002 ? s4988 : s4989;+  const SWord8 s5004 = (s5003 >> 1) | (s5003 << 7);+  const SWord8 s5005 = 128 | s5004;+  const SWord8 s5006 = 127 & s5004;+  const SWord8 s5007 = s5000 ? s5005 : s5006;+  const SBool  s5008 = (SBool) ((s1735 >> 0) & 1);+  const SBool  s5009 = false != s5008;+  const SWord8 s5010 = s5009 ? s5005 : s5006;+  const SWord8 s5011 = s1694 ? s5007 : s5010;+  const SWord8 s5012 = s1570 ? s4998 : s5011;+  const SBool  s5013 = (SBool) ((s1756 >> 0) & 1);+  const SBool  s5014 = false != s5013;+  const SBool  s5015 = (SBool) ((s1752 >> 0) & 1);+  const SBool  s5016 = false != s5015;+  const SBool  s5017 = (SBool) ((s1745 >> 0) & 1);+  const SBool  s5018 = false != s5017;+  const SWord8 s5019 = s5018 ? s4984 : s4985;+  const SWord8 s5020 = (s5019 >> 1) | (s5019 << 7);+  const SWord8 s5021 = 128 | s5020;+  const SWord8 s5022 = 127 & s5020;+  const SWord8 s5023 = s5016 ? s5021 : s5022;+  const SWord8 s5024 = (s5023 >> 1) | (s5023 << 7);+  const SWord8 s5025 = 128 | s5024;+  const SWord8 s5026 = 127 & s5024;+  const SWord8 s5027 = s5014 ? s5025 : s5026;+  const SBool  s5028 = (SBool) ((s1761 >> 0) & 1);+  const SBool  s5029 = false != s5028;+  const SWord8 s5030 = s5029 ? s5025 : s5026;+  const SWord8 s5031 = s1694 ? s5027 : s5030;+  const SBool  s5032 = (SBool) ((s1777 >> 0) & 1);+  const SBool  s5033 = false != s5032;+  const SBool  s5034 = (SBool) ((s1770 >> 0) & 1);+  const SBool  s5035 = false != s5034;+  const SWord8 s5036 = s5035 ? s5021 : s5022;+  const SWord8 s5037 = (s5036 >> 1) | (s5036 << 7);+  const SWord8 s5038 = 128 | s5037;+  const SWord8 s5039 = 127 & s5037;+  const SWord8 s5040 = s5033 ? s5038 : s5039;+  const SBool  s5041 = (SBool) ((s1782 >> 0) & 1);+  const SBool  s5042 = false != s5041;+  const SWord8 s5043 = s5042 ? s5038 : s5039;+  const SWord8 s5044 = s1694 ? s5040 : s5043;+  const SWord8 s5045 = s1570 ? s5031 : s5044;+  const SWord8 s5046 = s1548 ? s5012 : s5045;+  const SWord8 s5047 = s1037 ? s4976 : s5046;+  const SBool  s5048 = (SBool) ((s1837 >> 0) & 1);+  const SBool  s5049 = false != s5048;+  const SBool  s5050 = (SBool) ((s1833 >> 0) & 1);+  const SBool  s5051 = false != s5050;+  const SBool  s5052 = (SBool) ((s1829 >> 0) & 1);+  const SBool  s5053 = false != s5052;+  const SWord8 s5054 = (s1816 >> 1) | (s1816 << 7);+  const SWord8 s5055 = 128 | s5054;+  const SWord8 s5056 = 127 & s5054;+  const SWord8 s5057 = s5053 ? s5055 : s5056;+  const SWord8 s5058 = (s5057 >> 1) | (s5057 << 7);+  const SWord8 s5059 = 128 | s5058;+  const SWord8 s5060 = 127 & s5058;+  const SWord8 s5061 = s5051 ? s5059 : s5060;+  const SWord8 s5062 = (s5061 >> 1) | (s5061 << 7);+  const SWord8 s5063 = 128 | s5062;+  const SWord8 s5064 = 127 & s5062;+  const SWord8 s5065 = s5049 ? s5063 : s5064;+  const SBool  s5066 = (SBool) ((s1842 >> 0) & 1);+  const SBool  s5067 = false != s5066;+  const SWord8 s5068 = s5067 ? s5063 : s5064;+  const SWord8 s5069 = s1825 ? s5065 : s5068;+  const SBool  s5070 = (SBool) ((s1858 >> 0) & 1);+  const SBool  s5071 = false != s5070;+  const SBool  s5072 = (SBool) ((s1851 >> 0) & 1);+  const SBool  s5073 = false != s5072;+  const SWord8 s5074 = s5073 ? s5059 : s5060;+  const SWord8 s5075 = (s5074 >> 1) | (s5074 << 7);+  const SWord8 s5076 = 128 | s5075;+  const SWord8 s5077 = 127 & s5075;+  const SWord8 s5078 = s5071 ? s5076 : s5077;+  const SBool  s5079 = (SBool) ((s1863 >> 0) & 1);+  const SBool  s5080 = false != s5079;+  const SWord8 s5081 = s5080 ? s5076 : s5077;+  const SWord8 s5082 = s1825 ? s5078 : s5081;+  const SWord8 s5083 = s1803 ? s5069 : s5082;+  const SBool  s5084 = (SBool) ((s1884 >> 0) & 1);+  const SBool  s5085 = false != s5084;+  const SBool  s5086 = (SBool) ((s1880 >> 0) & 1);+  const SBool  s5087 = false != s5086;+  const SBool  s5088 = (SBool) ((s1873 >> 0) & 1);+  const SBool  s5089 = false != s5088;+  const SWord8 s5090 = s5089 ? s5055 : s5056;+  const SWord8 s5091 = (s5090 >> 1) | (s5090 << 7);+  const SWord8 s5092 = 128 | s5091;+  const SWord8 s5093 = 127 & s5091;+  const SWord8 s5094 = s5087 ? s5092 : s5093;+  const SWord8 s5095 = (s5094 >> 1) | (s5094 << 7);+  const SWord8 s5096 = 128 | s5095;+  const SWord8 s5097 = 127 & s5095;+  const SWord8 s5098 = s5085 ? s5096 : s5097;+  const SBool  s5099 = (SBool) ((s1889 >> 0) & 1);+  const SBool  s5100 = false != s5099;+  const SWord8 s5101 = s5100 ? s5096 : s5097;+  const SWord8 s5102 = s1825 ? s5098 : s5101;+  const SBool  s5103 = (SBool) ((s1905 >> 0) & 1);+  const SBool  s5104 = false != s5103;+  const SBool  s5105 = (SBool) ((s1898 >> 0) & 1);+  const SBool  s5106 = false != s5105;+  const SWord8 s5107 = s5106 ? s5092 : s5093;+  const SWord8 s5108 = (s5107 >> 1) | (s5107 << 7);+  const SWord8 s5109 = 128 | s5108;+  const SWord8 s5110 = 127 & s5108;+  const SWord8 s5111 = s5104 ? s5109 : s5110;+  const SBool  s5112 = (SBool) ((s1910 >> 0) & 1);+  const SBool  s5113 = false != s5112;+  const SWord8 s5114 = s5113 ? s5109 : s5110;+  const SWord8 s5115 = s1825 ? s5111 : s5114;+  const SWord8 s5116 = s1803 ? s5102 : s5115;+  const SWord8 s5117 = s1548 ? s5083 : s5116;+  const SBool  s5118 = (SBool) ((s1945 >> 0) & 1);+  const SBool  s5119 = false != s5118;+  const SBool  s5120 = (SBool) ((s1941 >> 0) & 1);+  const SBool  s5121 = false != s5120;+  const SBool  s5122 = (SBool) ((s1937 >> 0) & 1);+  const SBool  s5123 = false != s5122;+  const SWord8 s5124 = (s1924 >> 1) | (s1924 << 7);+  const SWord8 s5125 = 128 | s5124;+  const SWord8 s5126 = 127 & s5124;+  const SWord8 s5127 = s5123 ? s5125 : s5126;+  const SWord8 s5128 = (s5127 >> 1) | (s5127 << 7);+  const SWord8 s5129 = 128 | s5128;+  const SWord8 s5130 = 127 & s5128;+  const SWord8 s5131 = s5121 ? s5129 : s5130;+  const SWord8 s5132 = (s5131 >> 1) | (s5131 << 7);+  const SWord8 s5133 = 128 | s5132;+  const SWord8 s5134 = 127 & s5132;+  const SWord8 s5135 = s5119 ? s5133 : s5134;+  const SBool  s5136 = (SBool) ((s1950 >> 0) & 1);+  const SBool  s5137 = false != s5136;+  const SWord8 s5138 = s5137 ? s5133 : s5134;+  const SWord8 s5139 = s1930 ? s5135 : s5138;+  const SBool  s5140 = (SBool) ((s1966 >> 0) & 1);+  const SBool  s5141 = false != s5140;+  const SBool  s5142 = (SBool) ((s1959 >> 0) & 1);+  const SBool  s5143 = false != s5142;+  const SWord8 s5144 = s5143 ? s5129 : s5130;+  const SWord8 s5145 = (s5144 >> 1) | (s5144 << 7);+  const SWord8 s5146 = 128 | s5145;+  const SWord8 s5147 = 127 & s5145;+  const SWord8 s5148 = s5141 ? s5146 : s5147;+  const SBool  s5149 = (SBool) ((s1971 >> 0) & 1);+  const SBool  s5150 = false != s5149;+  const SWord8 s5151 = s5150 ? s5146 : s5147;+  const SWord8 s5152 = s1930 ? s5148 : s5151;+  const SWord8 s5153 = s1803 ? s5139 : s5152;+  const SBool  s5154 = (SBool) ((s1992 >> 0) & 1);+  const SBool  s5155 = false != s5154;+  const SBool  s5156 = (SBool) ((s1988 >> 0) & 1);+  const SBool  s5157 = false != s5156;+  const SBool  s5158 = (SBool) ((s1981 >> 0) & 1);+  const SBool  s5159 = false != s5158;+  const SWord8 s5160 = s5159 ? s5125 : s5126;+  const SWord8 s5161 = (s5160 >> 1) | (s5160 << 7);+  const SWord8 s5162 = 128 | s5161;+  const SWord8 s5163 = 127 & s5161;+  const SWord8 s5164 = s5157 ? s5162 : s5163;+  const SWord8 s5165 = (s5164 >> 1) | (s5164 << 7);+  const SWord8 s5166 = 128 | s5165;+  const SWord8 s5167 = 127 & s5165;+  const SWord8 s5168 = s5155 ? s5166 : s5167;+  const SBool  s5169 = (SBool) ((s1997 >> 0) & 1);+  const SBool  s5170 = false != s5169;+  const SWord8 s5171 = s5170 ? s5166 : s5167;+  const SWord8 s5172 = s1930 ? s5168 : s5171;+  const SBool  s5173 = (SBool) ((s2013 >> 0) & 1);+  const SBool  s5174 = false != s5173;+  const SBool  s5175 = (SBool) ((s2006 >> 0) & 1);+  const SBool  s5176 = false != s5175;+  const SWord8 s5177 = s5176 ? s5162 : s5163;+  const SWord8 s5178 = (s5177 >> 1) | (s5177 << 7);+  const SWord8 s5179 = 128 | s5178;+  const SWord8 s5180 = 127 & s5178;+  const SWord8 s5181 = s5174 ? s5179 : s5180;+  const SBool  s5182 = (SBool) ((s2018 >> 0) & 1);+  const SBool  s5183 = false != s5182;+  const SWord8 s5184 = s5183 ? s5179 : s5180;+  const SWord8 s5185 = s1930 ? s5181 : s5184;+  const SWord8 s5186 = s1803 ? s5172 : s5185;+  const SWord8 s5187 = s1548 ? s5153 : s5186;+  const SWord8 s5188 = s1037 ? s5117 : s5187;+  const SWord8 s5189 = s21 ? s5047 : s5188;+  const SWord8 s5190 = s16 ? s4906 : s5189;+  const SWord8 s5191 = s11 ? s4623 : s5190;+  const SBool  s5192 = (SBool) ((s2128 >> 0) & 1);+  const SBool  s5193 = false != s5192;+  const SBool  s5194 = (SBool) ((s2124 >> 0) & 1);+  const SBool  s5195 = false != s5194;+  const SBool  s5196 = (SBool) ((s2120 >> 0) & 1);+  const SBool  s5197 = false != s5196;+  const SWord8 s5198 = (s2107 >> 1) | (s2107 << 7);+  const SWord8 s5199 = 128 | s5198;+  const SWord8 s5200 = 127 & s5198;+  const SWord8 s5201 = s5197 ? s5199 : s5200;+  const SWord8 s5202 = (s5201 >> 1) | (s5201 << 7);+  const SWord8 s5203 = 128 | s5202;+  const SWord8 s5204 = 127 & s5202;+  const SWord8 s5205 = s5195 ? s5203 : s5204;+  const SWord8 s5206 = (s5205 >> 1) | (s5205 << 7);+  const SWord8 s5207 = 128 | s5206;+  const SWord8 s5208 = 127 & s5206;+  const SWord8 s5209 = s5193 ? s5207 : s5208;+  const SBool  s5210 = (SBool) ((s2133 >> 0) & 1);+  const SBool  s5211 = false != s5210;+  const SWord8 s5212 = s5211 ? s5207 : s5208;+  const SWord8 s5213 = s2116 ? s5209 : s5212;+  const SBool  s5214 = (SBool) ((s2149 >> 0) & 1);+  const SBool  s5215 = false != s5214;+  const SBool  s5216 = (SBool) ((s2142 >> 0) & 1);+  const SBool  s5217 = false != s5216;+  const SWord8 s5218 = s5217 ? s5203 : s5204;+  const SWord8 s5219 = (s5218 >> 1) | (s5218 << 7);+  const SWord8 s5220 = 128 | s5219;+  const SWord8 s5221 = 127 & s5219;+  const SWord8 s5222 = s5215 ? s5220 : s5221;+  const SBool  s5223 = (SBool) ((s2154 >> 0) & 1);+  const SBool  s5224 = false != s5223;+  const SWord8 s5225 = s5224 ? s5220 : s5221;+  const SWord8 s5226 = s2116 ? s5222 : s5225;+  const SWord8 s5227 = s2097 ? s5213 : s5226;+  const SBool  s5228 = (SBool) ((s2175 >> 0) & 1);+  const SBool  s5229 = false != s5228;+  const SBool  s5230 = (SBool) ((s2171 >> 0) & 1);+  const SBool  s5231 = false != s5230;+  const SBool  s5232 = (SBool) ((s2164 >> 0) & 1);+  const SBool  s5233 = false != s5232;+  const SWord8 s5234 = s5233 ? s5199 : s5200;+  const SWord8 s5235 = (s5234 >> 1) | (s5234 << 7);+  const SWord8 s5236 = 128 | s5235;+  const SWord8 s5237 = 127 & s5235;+  const SWord8 s5238 = s5231 ? s5236 : s5237;+  const SWord8 s5239 = (s5238 >> 1) | (s5238 << 7);+  const SWord8 s5240 = 128 | s5239;+  const SWord8 s5241 = 127 & s5239;+  const SWord8 s5242 = s5229 ? s5240 : s5241;+  const SBool  s5243 = (SBool) ((s2180 >> 0) & 1);+  const SBool  s5244 = false != s5243;+  const SWord8 s5245 = s5244 ? s5240 : s5241;+  const SWord8 s5246 = s2116 ? s5242 : s5245;+  const SBool  s5247 = (SBool) ((s2196 >> 0) & 1);+  const SBool  s5248 = false != s5247;+  const SBool  s5249 = (SBool) ((s2189 >> 0) & 1);+  const SBool  s5250 = false != s5249;+  const SWord8 s5251 = s5250 ? s5236 : s5237;+  const SWord8 s5252 = (s5251 >> 1) | (s5251 << 7);+  const SWord8 s5253 = 128 | s5252;+  const SWord8 s5254 = 127 & s5252;+  const SWord8 s5255 = s5248 ? s5253 : s5254;+  const SBool  s5256 = (SBool) ((s2201 >> 0) & 1);+  const SBool  s5257 = false != s5256;+  const SWord8 s5258 = s5257 ? s5253 : s5254;+  const SWord8 s5259 = s2116 ? s5255 : s5258;+  const SWord8 s5260 = s2097 ? s5246 : s5259;+  const SWord8 s5261 = s2078 ? s5227 : s5260;+  const SBool  s5262 = (SBool) ((s2236 >> 0) & 1);+  const SBool  s5263 = false != s5262;+  const SBool  s5264 = (SBool) ((s2232 >> 0) & 1);+  const SBool  s5265 = false != s5264;+  const SBool  s5266 = (SBool) ((s2228 >> 0) & 1);+  const SBool  s5267 = false != s5266;+  const SWord8 s5268 = (s2215 >> 1) | (s2215 << 7);+  const SWord8 s5269 = 128 | s5268;+  const SWord8 s5270 = 127 & s5268;+  const SWord8 s5271 = s5267 ? s5269 : s5270;+  const SWord8 s5272 = (s5271 >> 1) | (s5271 << 7);+  const SWord8 s5273 = 128 | s5272;+  const SWord8 s5274 = 127 & s5272;+  const SWord8 s5275 = s5265 ? s5273 : s5274;+  const SWord8 s5276 = (s5275 >> 1) | (s5275 << 7);+  const SWord8 s5277 = 128 | s5276;+  const SWord8 s5278 = 127 & s5276;+  const SWord8 s5279 = s5263 ? s5277 : s5278;+  const SBool  s5280 = (SBool) ((s2241 >> 0) & 1);+  const SBool  s5281 = false != s5280;+  const SWord8 s5282 = s5281 ? s5277 : s5278;+  const SWord8 s5283 = s2221 ? s5279 : s5282;+  const SBool  s5284 = (SBool) ((s2257 >> 0) & 1);+  const SBool  s5285 = false != s5284;+  const SBool  s5286 = (SBool) ((s2250 >> 0) & 1);+  const SBool  s5287 = false != s5286;+  const SWord8 s5288 = s5287 ? s5273 : s5274;+  const SWord8 s5289 = (s5288 >> 1) | (s5288 << 7);+  const SWord8 s5290 = 128 | s5289;+  const SWord8 s5291 = 127 & s5289;+  const SWord8 s5292 = s5285 ? s5290 : s5291;+  const SBool  s5293 = (SBool) ((s2262 >> 0) & 1);+  const SBool  s5294 = false != s5293;+  const SWord8 s5295 = s5294 ? s5290 : s5291;+  const SWord8 s5296 = s2221 ? s5292 : s5295;+  const SWord8 s5297 = s2097 ? s5283 : s5296;+  const SBool  s5298 = (SBool) ((s2283 >> 0) & 1);+  const SBool  s5299 = false != s5298;+  const SBool  s5300 = (SBool) ((s2279 >> 0) & 1);+  const SBool  s5301 = false != s5300;+  const SBool  s5302 = (SBool) ((s2272 >> 0) & 1);+  const SBool  s5303 = false != s5302;+  const SWord8 s5304 = s5303 ? s5269 : s5270;+  const SWord8 s5305 = (s5304 >> 1) | (s5304 << 7);+  const SWord8 s5306 = 128 | s5305;+  const SWord8 s5307 = 127 & s5305;+  const SWord8 s5308 = s5301 ? s5306 : s5307;+  const SWord8 s5309 = (s5308 >> 1) | (s5308 << 7);+  const SWord8 s5310 = 128 | s5309;+  const SWord8 s5311 = 127 & s5309;+  const SWord8 s5312 = s5299 ? s5310 : s5311;+  const SBool  s5313 = (SBool) ((s2288 >> 0) & 1);+  const SBool  s5314 = false != s5313;+  const SWord8 s5315 = s5314 ? s5310 : s5311;+  const SWord8 s5316 = s2221 ? s5312 : s5315;+  const SBool  s5317 = (SBool) ((s2304 >> 0) & 1);+  const SBool  s5318 = false != s5317;+  const SBool  s5319 = (SBool) ((s2297 >> 0) & 1);+  const SBool  s5320 = false != s5319;+  const SWord8 s5321 = s5320 ? s5306 : s5307;+  const SWord8 s5322 = (s5321 >> 1) | (s5321 << 7);+  const SWord8 s5323 = 128 | s5322;+  const SWord8 s5324 = 127 & s5322;+  const SWord8 s5325 = s5318 ? s5323 : s5324;+  const SBool  s5326 = (SBool) ((s2309 >> 0) & 1);+  const SBool  s5327 = false != s5326;+  const SWord8 s5328 = s5327 ? s5323 : s5324;+  const SWord8 s5329 = s2221 ? s5325 : s5328;+  const SWord8 s5330 = s2097 ? s5316 : s5329;+  const SWord8 s5331 = s2078 ? s5297 : s5330;+  const SWord8 s5332 = s2059 ? s5261 : s5331;+  const SBool  s5333 = (SBool) ((s2364 >> 0) & 1);+  const SBool  s5334 = false != s5333;+  const SBool  s5335 = (SBool) ((s2360 >> 0) & 1);+  const SBool  s5336 = false != s5335;+  const SBool  s5337 = (SBool) ((s2356 >> 0) & 1);+  const SBool  s5338 = false != s5337;+  const SWord8 s5339 = (s2343 >> 1) | (s2343 << 7);+  const SWord8 s5340 = 128 | s5339;+  const SWord8 s5341 = 127 & s5339;+  const SWord8 s5342 = s5338 ? s5340 : s5341;+  const SWord8 s5343 = (s5342 >> 1) | (s5342 << 7);+  const SWord8 s5344 = 128 | s5343;+  const SWord8 s5345 = 127 & s5343;+  const SWord8 s5346 = s5336 ? s5344 : s5345;+  const SWord8 s5347 = (s5346 >> 1) | (s5346 << 7);+  const SWord8 s5348 = 128 | s5347;+  const SWord8 s5349 = 127 & s5347;+  const SWord8 s5350 = s5334 ? s5348 : s5349;+  const SBool  s5351 = (SBool) ((s2369 >> 0) & 1);+  const SBool  s5352 = false != s5351;+  const SWord8 s5353 = s5352 ? s5348 : s5349;+  const SWord8 s5354 = s2352 ? s5350 : s5353;+  const SBool  s5355 = (SBool) ((s2385 >> 0) & 1);+  const SBool  s5356 = false != s5355;+  const SBool  s5357 = (SBool) ((s2378 >> 0) & 1);+  const SBool  s5358 = false != s5357;+  const SWord8 s5359 = s5358 ? s5344 : s5345;+  const SWord8 s5360 = (s5359 >> 1) | (s5359 << 7);+  const SWord8 s5361 = 128 | s5360;+  const SWord8 s5362 = 127 & s5360;+  const SWord8 s5363 = s5356 ? s5361 : s5362;+  const SBool  s5364 = (SBool) ((s2390 >> 0) & 1);+  const SBool  s5365 = false != s5364;+  const SWord8 s5366 = s5365 ? s5361 : s5362;+  const SWord8 s5367 = s2352 ? s5363 : s5366;+  const SWord8 s5368 = s2330 ? s5354 : s5367;+  const SBool  s5369 = (SBool) ((s2411 >> 0) & 1);+  const SBool  s5370 = false != s5369;+  const SBool  s5371 = (SBool) ((s2407 >> 0) & 1);+  const SBool  s5372 = false != s5371;+  const SBool  s5373 = (SBool) ((s2400 >> 0) & 1);+  const SBool  s5374 = false != s5373;+  const SWord8 s5375 = s5374 ? s5340 : s5341;+  const SWord8 s5376 = (s5375 >> 1) | (s5375 << 7);+  const SWord8 s5377 = 128 | s5376;+  const SWord8 s5378 = 127 & s5376;+  const SWord8 s5379 = s5372 ? s5377 : s5378;+  const SWord8 s5380 = (s5379 >> 1) | (s5379 << 7);+  const SWord8 s5381 = 128 | s5380;+  const SWord8 s5382 = 127 & s5380;+  const SWord8 s5383 = s5370 ? s5381 : s5382;+  const SBool  s5384 = (SBool) ((s2416 >> 0) & 1);+  const SBool  s5385 = false != s5384;+  const SWord8 s5386 = s5385 ? s5381 : s5382;+  const SWord8 s5387 = s2352 ? s5383 : s5386;+  const SBool  s5388 = (SBool) ((s2432 >> 0) & 1);+  const SBool  s5389 = false != s5388;+  const SBool  s5390 = (SBool) ((s2425 >> 0) & 1);+  const SBool  s5391 = false != s5390;+  const SWord8 s5392 = s5391 ? s5377 : s5378;+  const SWord8 s5393 = (s5392 >> 1) | (s5392 << 7);+  const SWord8 s5394 = 128 | s5393;+  const SWord8 s5395 = 127 & s5393;+  const SWord8 s5396 = s5389 ? s5394 : s5395;+  const SBool  s5397 = (SBool) ((s2437 >> 0) & 1);+  const SBool  s5398 = false != s5397;+  const SWord8 s5399 = s5398 ? s5394 : s5395;+  const SWord8 s5400 = s2352 ? s5396 : s5399;+  const SWord8 s5401 = s2330 ? s5387 : s5400;+  const SWord8 s5402 = s2078 ? s5368 : s5401;+  const SBool  s5403 = (SBool) ((s2472 >> 0) & 1);+  const SBool  s5404 = false != s5403;+  const SBool  s5405 = (SBool) ((s2468 >> 0) & 1);+  const SBool  s5406 = false != s5405;+  const SBool  s5407 = (SBool) ((s2464 >> 0) & 1);+  const SBool  s5408 = false != s5407;+  const SWord8 s5409 = (s2451 >> 1) | (s2451 << 7);+  const SWord8 s5410 = 128 | s5409;+  const SWord8 s5411 = 127 & s5409;+  const SWord8 s5412 = s5408 ? s5410 : s5411;+  const SWord8 s5413 = (s5412 >> 1) | (s5412 << 7);+  const SWord8 s5414 = 128 | s5413;+  const SWord8 s5415 = 127 & s5413;+  const SWord8 s5416 = s5406 ? s5414 : s5415;+  const SWord8 s5417 = (s5416 >> 1) | (s5416 << 7);+  const SWord8 s5418 = 128 | s5417;+  const SWord8 s5419 = 127 & s5417;+  const SWord8 s5420 = s5404 ? s5418 : s5419;+  const SBool  s5421 = (SBool) ((s2477 >> 0) & 1);+  const SBool  s5422 = false != s5421;+  const SWord8 s5423 = s5422 ? s5418 : s5419;+  const SWord8 s5424 = s2457 ? s5420 : s5423;+  const SBool  s5425 = (SBool) ((s2493 >> 0) & 1);+  const SBool  s5426 = false != s5425;+  const SBool  s5427 = (SBool) ((s2486 >> 0) & 1);+  const SBool  s5428 = false != s5427;+  const SWord8 s5429 = s5428 ? s5414 : s5415;+  const SWord8 s5430 = (s5429 >> 1) | (s5429 << 7);+  const SWord8 s5431 = 128 | s5430;+  const SWord8 s5432 = 127 & s5430;+  const SWord8 s5433 = s5426 ? s5431 : s5432;+  const SBool  s5434 = (SBool) ((s2498 >> 0) & 1);+  const SBool  s5435 = false != s5434;+  const SWord8 s5436 = s5435 ? s5431 : s5432;+  const SWord8 s5437 = s2457 ? s5433 : s5436;+  const SWord8 s5438 = s2330 ? s5424 : s5437;+  const SBool  s5439 = (SBool) ((s2519 >> 0) & 1);+  const SBool  s5440 = false != s5439;+  const SBool  s5441 = (SBool) ((s2515 >> 0) & 1);+  const SBool  s5442 = false != s5441;+  const SBool  s5443 = (SBool) ((s2508 >> 0) & 1);+  const SBool  s5444 = false != s5443;+  const SWord8 s5445 = s5444 ? s5410 : s5411;+  const SWord8 s5446 = (s5445 >> 1) | (s5445 << 7);+  const SWord8 s5447 = 128 | s5446;+  const SWord8 s5448 = 127 & s5446;+  const SWord8 s5449 = s5442 ? s5447 : s5448;+  const SWord8 s5450 = (s5449 >> 1) | (s5449 << 7);+  const SWord8 s5451 = 128 | s5450;+  const SWord8 s5452 = 127 & s5450;+  const SWord8 s5453 = s5440 ? s5451 : s5452;+  const SBool  s5454 = (SBool) ((s2524 >> 0) & 1);+  const SBool  s5455 = false != s5454;+  const SWord8 s5456 = s5455 ? s5451 : s5452;+  const SWord8 s5457 = s2457 ? s5453 : s5456;+  const SBool  s5458 = (SBool) ((s2540 >> 0) & 1);+  const SBool  s5459 = false != s5458;+  const SBool  s5460 = (SBool) ((s2533 >> 0) & 1);+  const SBool  s5461 = false != s5460;+  const SWord8 s5462 = s5461 ? s5447 : s5448;+  const SWord8 s5463 = (s5462 >> 1) | (s5462 << 7);+  const SWord8 s5464 = 128 | s5463;+  const SWord8 s5465 = 127 & s5463;+  const SWord8 s5466 = s5459 ? s5464 : s5465;+  const SBool  s5467 = (SBool) ((s2545 >> 0) & 1);+  const SBool  s5468 = false != s5467;+  const SWord8 s5469 = s5468 ? s5464 : s5465;+  const SWord8 s5470 = s2457 ? s5466 : s5469;+  const SWord8 s5471 = s2330 ? s5457 : s5470;+  const SWord8 s5472 = s2078 ? s5438 : s5471;+  const SWord8 s5473 = s2059 ? s5402 : s5472;+  const SWord8 s5474 = s2042 ? s5332 : s5473;+  const SBool  s5475 = (SBool) ((s2620 >> 0) & 1);+  const SBool  s5476 = false != s5475;+  const SBool  s5477 = (SBool) ((s2616 >> 0) & 1);+  const SBool  s5478 = false != s5477;+  const SBool  s5479 = (SBool) ((s2612 >> 0) & 1);+  const SBool  s5480 = false != s5479;+  const SWord8 s5481 = (s2599 >> 1) | (s2599 << 7);+  const SWord8 s5482 = 128 | s5481;+  const SWord8 s5483 = 127 & s5481;+  const SWord8 s5484 = s5480 ? s5482 : s5483;+  const SWord8 s5485 = (s5484 >> 1) | (s5484 << 7);+  const SWord8 s5486 = 128 | s5485;+  const SWord8 s5487 = 127 & s5485;+  const SWord8 s5488 = s5478 ? s5486 : s5487;+  const SWord8 s5489 = (s5488 >> 1) | (s5488 << 7);+  const SWord8 s5490 = 128 | s5489;+  const SWord8 s5491 = 127 & s5489;+  const SWord8 s5492 = s5476 ? s5490 : s5491;+  const SBool  s5493 = (SBool) ((s2625 >> 0) & 1);+  const SBool  s5494 = false != s5493;+  const SWord8 s5495 = s5494 ? s5490 : s5491;+  const SWord8 s5496 = s2608 ? s5492 : s5495;+  const SBool  s5497 = (SBool) ((s2641 >> 0) & 1);+  const SBool  s5498 = false != s5497;+  const SBool  s5499 = (SBool) ((s2634 >> 0) & 1);+  const SBool  s5500 = false != s5499;+  const SWord8 s5501 = s5500 ? s5486 : s5487;+  const SWord8 s5502 = (s5501 >> 1) | (s5501 << 7);+  const SWord8 s5503 = 128 | s5502;+  const SWord8 s5504 = 127 & s5502;+  const SWord8 s5505 = s5498 ? s5503 : s5504;+  const SBool  s5506 = (SBool) ((s2646 >> 0) & 1);+  const SBool  s5507 = false != s5506;+  const SWord8 s5508 = s5507 ? s5503 : s5504;+  const SWord8 s5509 = s2608 ? s5505 : s5508;+  const SWord8 s5510 = s2589 ? s5496 : s5509;+  const SBool  s5511 = (SBool) ((s2667 >> 0) & 1);+  const SBool  s5512 = false != s5511;+  const SBool  s5513 = (SBool) ((s2663 >> 0) & 1);+  const SBool  s5514 = false != s5513;+  const SBool  s5515 = (SBool) ((s2656 >> 0) & 1);+  const SBool  s5516 = false != s5515;+  const SWord8 s5517 = s5516 ? s5482 : s5483;+  const SWord8 s5518 = (s5517 >> 1) | (s5517 << 7);+  const SWord8 s5519 = 128 | s5518;+  const SWord8 s5520 = 127 & s5518;+  const SWord8 s5521 = s5514 ? s5519 : s5520;+  const SWord8 s5522 = (s5521 >> 1) | (s5521 << 7);+  const SWord8 s5523 = 128 | s5522;+  const SWord8 s5524 = 127 & s5522;+  const SWord8 s5525 = s5512 ? s5523 : s5524;+  const SBool  s5526 = (SBool) ((s2672 >> 0) & 1);+  const SBool  s5527 = false != s5526;+  const SWord8 s5528 = s5527 ? s5523 : s5524;+  const SWord8 s5529 = s2608 ? s5525 : s5528;+  const SBool  s5530 = (SBool) ((s2688 >> 0) & 1);+  const SBool  s5531 = false != s5530;+  const SBool  s5532 = (SBool) ((s2681 >> 0) & 1);+  const SBool  s5533 = false != s5532;+  const SWord8 s5534 = s5533 ? s5519 : s5520;+  const SWord8 s5535 = (s5534 >> 1) | (s5534 << 7);+  const SWord8 s5536 = 128 | s5535;+  const SWord8 s5537 = 127 & s5535;+  const SWord8 s5538 = s5531 ? s5536 : s5537;+  const SBool  s5539 = (SBool) ((s2693 >> 0) & 1);+  const SBool  s5540 = false != s5539;+  const SWord8 s5541 = s5540 ? s5536 : s5537;+  const SWord8 s5542 = s2608 ? s5538 : s5541;+  const SWord8 s5543 = s2589 ? s5529 : s5542;+  const SWord8 s5544 = s2567 ? s5510 : s5543;+  const SBool  s5545 = (SBool) ((s2728 >> 0) & 1);+  const SBool  s5546 = false != s5545;+  const SBool  s5547 = (SBool) ((s2724 >> 0) & 1);+  const SBool  s5548 = false != s5547;+  const SBool  s5549 = (SBool) ((s2720 >> 0) & 1);+  const SBool  s5550 = false != s5549;+  const SWord8 s5551 = (s2707 >> 1) | (s2707 << 7);+  const SWord8 s5552 = 128 | s5551;+  const SWord8 s5553 = 127 & s5551;+  const SWord8 s5554 = s5550 ? s5552 : s5553;+  const SWord8 s5555 = (s5554 >> 1) | (s5554 << 7);+  const SWord8 s5556 = 128 | s5555;+  const SWord8 s5557 = 127 & s5555;+  const SWord8 s5558 = s5548 ? s5556 : s5557;+  const SWord8 s5559 = (s5558 >> 1) | (s5558 << 7);+  const SWord8 s5560 = 128 | s5559;+  const SWord8 s5561 = 127 & s5559;+  const SWord8 s5562 = s5546 ? s5560 : s5561;+  const SBool  s5563 = (SBool) ((s2733 >> 0) & 1);+  const SBool  s5564 = false != s5563;+  const SWord8 s5565 = s5564 ? s5560 : s5561;+  const SWord8 s5566 = s2713 ? s5562 : s5565;+  const SBool  s5567 = (SBool) ((s2749 >> 0) & 1);+  const SBool  s5568 = false != s5567;+  const SBool  s5569 = (SBool) ((s2742 >> 0) & 1);+  const SBool  s5570 = false != s5569;+  const SWord8 s5571 = s5570 ? s5556 : s5557;+  const SWord8 s5572 = (s5571 >> 1) | (s5571 << 7);+  const SWord8 s5573 = 128 | s5572;+  const SWord8 s5574 = 127 & s5572;+  const SWord8 s5575 = s5568 ? s5573 : s5574;+  const SBool  s5576 = (SBool) ((s2754 >> 0) & 1);+  const SBool  s5577 = false != s5576;+  const SWord8 s5578 = s5577 ? s5573 : s5574;+  const SWord8 s5579 = s2713 ? s5575 : s5578;+  const SWord8 s5580 = s2589 ? s5566 : s5579;+  const SBool  s5581 = (SBool) ((s2775 >> 0) & 1);+  const SBool  s5582 = false != s5581;+  const SBool  s5583 = (SBool) ((s2771 >> 0) & 1);+  const SBool  s5584 = false != s5583;+  const SBool  s5585 = (SBool) ((s2764 >> 0) & 1);+  const SBool  s5586 = false != s5585;+  const SWord8 s5587 = s5586 ? s5552 : s5553;+  const SWord8 s5588 = (s5587 >> 1) | (s5587 << 7);+  const SWord8 s5589 = 128 | s5588;+  const SWord8 s5590 = 127 & s5588;+  const SWord8 s5591 = s5584 ? s5589 : s5590;+  const SWord8 s5592 = (s5591 >> 1) | (s5591 << 7);+  const SWord8 s5593 = 128 | s5592;+  const SWord8 s5594 = 127 & s5592;+  const SWord8 s5595 = s5582 ? s5593 : s5594;+  const SBool  s5596 = (SBool) ((s2780 >> 0) & 1);+  const SBool  s5597 = false != s5596;+  const SWord8 s5598 = s5597 ? s5593 : s5594;+  const SWord8 s5599 = s2713 ? s5595 : s5598;+  const SBool  s5600 = (SBool) ((s2796 >> 0) & 1);+  const SBool  s5601 = false != s5600;+  const SBool  s5602 = (SBool) ((s2789 >> 0) & 1);+  const SBool  s5603 = false != s5602;+  const SWord8 s5604 = s5603 ? s5589 : s5590;+  const SWord8 s5605 = (s5604 >> 1) | (s5604 << 7);+  const SWord8 s5606 = 128 | s5605;+  const SWord8 s5607 = 127 & s5605;+  const SWord8 s5608 = s5601 ? s5606 : s5607;+  const SBool  s5609 = (SBool) ((s2801 >> 0) & 1);+  const SBool  s5610 = false != s5609;+  const SWord8 s5611 = s5610 ? s5606 : s5607;+  const SWord8 s5612 = s2713 ? s5608 : s5611;+  const SWord8 s5613 = s2589 ? s5599 : s5612;+  const SWord8 s5614 = s2567 ? s5580 : s5613;+  const SWord8 s5615 = s2059 ? s5544 : s5614;+  const SBool  s5616 = (SBool) ((s2856 >> 0) & 1);+  const SBool  s5617 = false != s5616;+  const SBool  s5618 = (SBool) ((s2852 >> 0) & 1);+  const SBool  s5619 = false != s5618;+  const SBool  s5620 = (SBool) ((s2848 >> 0) & 1);+  const SBool  s5621 = false != s5620;+  const SWord8 s5622 = (s2835 >> 1) | (s2835 << 7);+  const SWord8 s5623 = 128 | s5622;+  const SWord8 s5624 = 127 & s5622;+  const SWord8 s5625 = s5621 ? s5623 : s5624;+  const SWord8 s5626 = (s5625 >> 1) | (s5625 << 7);+  const SWord8 s5627 = 128 | s5626;+  const SWord8 s5628 = 127 & s5626;+  const SWord8 s5629 = s5619 ? s5627 : s5628;+  const SWord8 s5630 = (s5629 >> 1) | (s5629 << 7);+  const SWord8 s5631 = 128 | s5630;+  const SWord8 s5632 = 127 & s5630;+  const SWord8 s5633 = s5617 ? s5631 : s5632;+  const SBool  s5634 = (SBool) ((s2861 >> 0) & 1);+  const SBool  s5635 = false != s5634;+  const SWord8 s5636 = s5635 ? s5631 : s5632;+  const SWord8 s5637 = s2844 ? s5633 : s5636;+  const SBool  s5638 = (SBool) ((s2877 >> 0) & 1);+  const SBool  s5639 = false != s5638;+  const SBool  s5640 = (SBool) ((s2870 >> 0) & 1);+  const SBool  s5641 = false != s5640;+  const SWord8 s5642 = s5641 ? s5627 : s5628;+  const SWord8 s5643 = (s5642 >> 1) | (s5642 << 7);+  const SWord8 s5644 = 128 | s5643;+  const SWord8 s5645 = 127 & s5643;+  const SWord8 s5646 = s5639 ? s5644 : s5645;+  const SBool  s5647 = (SBool) ((s2882 >> 0) & 1);+  const SBool  s5648 = false != s5647;+  const SWord8 s5649 = s5648 ? s5644 : s5645;+  const SWord8 s5650 = s2844 ? s5646 : s5649;+  const SWord8 s5651 = s2822 ? s5637 : s5650;+  const SBool  s5652 = (SBool) ((s2903 >> 0) & 1);+  const SBool  s5653 = false != s5652;+  const SBool  s5654 = (SBool) ((s2899 >> 0) & 1);+  const SBool  s5655 = false != s5654;+  const SBool  s5656 = (SBool) ((s2892 >> 0) & 1);+  const SBool  s5657 = false != s5656;+  const SWord8 s5658 = s5657 ? s5623 : s5624;+  const SWord8 s5659 = (s5658 >> 1) | (s5658 << 7);+  const SWord8 s5660 = 128 | s5659;+  const SWord8 s5661 = 127 & s5659;+  const SWord8 s5662 = s5655 ? s5660 : s5661;+  const SWord8 s5663 = (s5662 >> 1) | (s5662 << 7);+  const SWord8 s5664 = 128 | s5663;+  const SWord8 s5665 = 127 & s5663;+  const SWord8 s5666 = s5653 ? s5664 : s5665;+  const SBool  s5667 = (SBool) ((s2908 >> 0) & 1);+  const SBool  s5668 = false != s5667;+  const SWord8 s5669 = s5668 ? s5664 : s5665;+  const SWord8 s5670 = s2844 ? s5666 : s5669;+  const SBool  s5671 = (SBool) ((s2924 >> 0) & 1);+  const SBool  s5672 = false != s5671;+  const SBool  s5673 = (SBool) ((s2917 >> 0) & 1);+  const SBool  s5674 = false != s5673;+  const SWord8 s5675 = s5674 ? s5660 : s5661;+  const SWord8 s5676 = (s5675 >> 1) | (s5675 << 7);+  const SWord8 s5677 = 128 | s5676;+  const SWord8 s5678 = 127 & s5676;+  const SWord8 s5679 = s5672 ? s5677 : s5678;+  const SBool  s5680 = (SBool) ((s2929 >> 0) & 1);+  const SBool  s5681 = false != s5680;+  const SWord8 s5682 = s5681 ? s5677 : s5678;+  const SWord8 s5683 = s2844 ? s5679 : s5682;+  const SWord8 s5684 = s2822 ? s5670 : s5683;+  const SWord8 s5685 = s2567 ? s5651 : s5684;+  const SBool  s5686 = (SBool) ((s2964 >> 0) & 1);+  const SBool  s5687 = false != s5686;+  const SBool  s5688 = (SBool) ((s2960 >> 0) & 1);+  const SBool  s5689 = false != s5688;+  const SBool  s5690 = (SBool) ((s2956 >> 0) & 1);+  const SBool  s5691 = false != s5690;+  const SWord8 s5692 = (s2943 >> 1) | (s2943 << 7);+  const SWord8 s5693 = 128 | s5692;+  const SWord8 s5694 = 127 & s5692;+  const SWord8 s5695 = s5691 ? s5693 : s5694;+  const SWord8 s5696 = (s5695 >> 1) | (s5695 << 7);+  const SWord8 s5697 = 128 | s5696;+  const SWord8 s5698 = 127 & s5696;+  const SWord8 s5699 = s5689 ? s5697 : s5698;+  const SWord8 s5700 = (s5699 >> 1) | (s5699 << 7);+  const SWord8 s5701 = 128 | s5700;+  const SWord8 s5702 = 127 & s5700;+  const SWord8 s5703 = s5687 ? s5701 : s5702;+  const SBool  s5704 = (SBool) ((s2969 >> 0) & 1);+  const SBool  s5705 = false != s5704;+  const SWord8 s5706 = s5705 ? s5701 : s5702;+  const SWord8 s5707 = s2949 ? s5703 : s5706;+  const SBool  s5708 = (SBool) ((s2985 >> 0) & 1);+  const SBool  s5709 = false != s5708;+  const SBool  s5710 = (SBool) ((s2978 >> 0) & 1);+  const SBool  s5711 = false != s5710;+  const SWord8 s5712 = s5711 ? s5697 : s5698;+  const SWord8 s5713 = (s5712 >> 1) | (s5712 << 7);+  const SWord8 s5714 = 128 | s5713;+  const SWord8 s5715 = 127 & s5713;+  const SWord8 s5716 = s5709 ? s5714 : s5715;+  const SBool  s5717 = (SBool) ((s2990 >> 0) & 1);+  const SBool  s5718 = false != s5717;+  const SWord8 s5719 = s5718 ? s5714 : s5715;+  const SWord8 s5720 = s2949 ? s5716 : s5719;+  const SWord8 s5721 = s2822 ? s5707 : s5720;+  const SBool  s5722 = (SBool) ((s3011 >> 0) & 1);+  const SBool  s5723 = false != s5722;+  const SBool  s5724 = (SBool) ((s3007 >> 0) & 1);+  const SBool  s5725 = false != s5724;+  const SBool  s5726 = (SBool) ((s3000 >> 0) & 1);+  const SBool  s5727 = false != s5726;+  const SWord8 s5728 = s5727 ? s5693 : s5694;+  const SWord8 s5729 = (s5728 >> 1) | (s5728 << 7);+  const SWord8 s5730 = 128 | s5729;+  const SWord8 s5731 = 127 & s5729;+  const SWord8 s5732 = s5725 ? s5730 : s5731;+  const SWord8 s5733 = (s5732 >> 1) | (s5732 << 7);+  const SWord8 s5734 = 128 | s5733;+  const SWord8 s5735 = 127 & s5733;+  const SWord8 s5736 = s5723 ? s5734 : s5735;+  const SBool  s5737 = (SBool) ((s3016 >> 0) & 1);+  const SBool  s5738 = false != s5737;+  const SWord8 s5739 = s5738 ? s5734 : s5735;+  const SWord8 s5740 = s2949 ? s5736 : s5739;+  const SBool  s5741 = (SBool) ((s3032 >> 0) & 1);+  const SBool  s5742 = false != s5741;+  const SBool  s5743 = (SBool) ((s3025 >> 0) & 1);+  const SBool  s5744 = false != s5743;+  const SWord8 s5745 = s5744 ? s5730 : s5731;+  const SWord8 s5746 = (s5745 >> 1) | (s5745 << 7);+  const SWord8 s5747 = 128 | s5746;+  const SWord8 s5748 = 127 & s5746;+  const SWord8 s5749 = s5742 ? s5747 : s5748;+  const SBool  s5750 = (SBool) ((s3037 >> 0) & 1);+  const SBool  s5751 = false != s5750;+  const SWord8 s5752 = s5751 ? s5747 : s5748;+  const SWord8 s5753 = s2949 ? s5749 : s5752;+  const SWord8 s5754 = s2822 ? s5740 : s5753;+  const SWord8 s5755 = s2567 ? s5721 : s5754;+  const SWord8 s5756 = s2059 ? s5685 : s5755;+  const SWord8 s5757 = s2042 ? s5615 : s5756;+  const SWord8 s5758 = s16 ? s5474 : s5757;+  const SBool  s5759 = (SBool) ((s3132 >> 0) & 1);+  const SBool  s5760 = false != s5759;+  const SBool  s5761 = (SBool) ((s3128 >> 0) & 1);+  const SBool  s5762 = false != s5761;+  const SBool  s5763 = (SBool) ((s3124 >> 0) & 1);+  const SBool  s5764 = false != s5763;+  const SWord8 s5765 = (s3111 >> 1) | (s3111 << 7);+  const SWord8 s5766 = 128 | s5765;+  const SWord8 s5767 = 127 & s5765;+  const SWord8 s5768 = s5764 ? s5766 : s5767;+  const SWord8 s5769 = (s5768 >> 1) | (s5768 << 7);+  const SWord8 s5770 = 128 | s5769;+  const SWord8 s5771 = 127 & s5769;+  const SWord8 s5772 = s5762 ? s5770 : s5771;+  const SWord8 s5773 = (s5772 >> 1) | (s5772 << 7);+  const SWord8 s5774 = 128 | s5773;+  const SWord8 s5775 = 127 & s5773;+  const SWord8 s5776 = s5760 ? s5774 : s5775;+  const SBool  s5777 = (SBool) ((s3137 >> 0) & 1);+  const SBool  s5778 = false != s5777;+  const SWord8 s5779 = s5778 ? s5774 : s5775;+  const SWord8 s5780 = s3120 ? s5776 : s5779;+  const SBool  s5781 = (SBool) ((s3153 >> 0) & 1);+  const SBool  s5782 = false != s5781;+  const SBool  s5783 = (SBool) ((s3146 >> 0) & 1);+  const SBool  s5784 = false != s5783;+  const SWord8 s5785 = s5784 ? s5770 : s5771;+  const SWord8 s5786 = (s5785 >> 1) | (s5785 << 7);+  const SWord8 s5787 = 128 | s5786;+  const SWord8 s5788 = 127 & s5786;+  const SWord8 s5789 = s5782 ? s5787 : s5788;+  const SBool  s5790 = (SBool) ((s3158 >> 0) & 1);+  const SBool  s5791 = false != s5790;+  const SWord8 s5792 = s5791 ? s5787 : s5788;+  const SWord8 s5793 = s3120 ? s5789 : s5792;+  const SWord8 s5794 = s3101 ? s5780 : s5793;+  const SBool  s5795 = (SBool) ((s3179 >> 0) & 1);+  const SBool  s5796 = false != s5795;+  const SBool  s5797 = (SBool) ((s3175 >> 0) & 1);+  const SBool  s5798 = false != s5797;+  const SBool  s5799 = (SBool) ((s3168 >> 0) & 1);+  const SBool  s5800 = false != s5799;+  const SWord8 s5801 = s5800 ? s5766 : s5767;+  const SWord8 s5802 = (s5801 >> 1) | (s5801 << 7);+  const SWord8 s5803 = 128 | s5802;+  const SWord8 s5804 = 127 & s5802;+  const SWord8 s5805 = s5798 ? s5803 : s5804;+  const SWord8 s5806 = (s5805 >> 1) | (s5805 << 7);+  const SWord8 s5807 = 128 | s5806;+  const SWord8 s5808 = 127 & s5806;+  const SWord8 s5809 = s5796 ? s5807 : s5808;+  const SBool  s5810 = (SBool) ((s3184 >> 0) & 1);+  const SBool  s5811 = false != s5810;+  const SWord8 s5812 = s5811 ? s5807 : s5808;+  const SWord8 s5813 = s3120 ? s5809 : s5812;+  const SBool  s5814 = (SBool) ((s3200 >> 0) & 1);+  const SBool  s5815 = false != s5814;+  const SBool  s5816 = (SBool) ((s3193 >> 0) & 1);+  const SBool  s5817 = false != s5816;+  const SWord8 s5818 = s5817 ? s5803 : s5804;+  const SWord8 s5819 = (s5818 >> 1) | (s5818 << 7);+  const SWord8 s5820 = 128 | s5819;+  const SWord8 s5821 = 127 & s5819;+  const SWord8 s5822 = s5815 ? s5820 : s5821;+  const SBool  s5823 = (SBool) ((s3205 >> 0) & 1);+  const SBool  s5824 = false != s5823;+  const SWord8 s5825 = s5824 ? s5820 : s5821;+  const SWord8 s5826 = s3120 ? s5822 : s5825;+  const SWord8 s5827 = s3101 ? s5813 : s5826;+  const SWord8 s5828 = s3082 ? s5794 : s5827;+  const SBool  s5829 = (SBool) ((s3240 >> 0) & 1);+  const SBool  s5830 = false != s5829;+  const SBool  s5831 = (SBool) ((s3236 >> 0) & 1);+  const SBool  s5832 = false != s5831;+  const SBool  s5833 = (SBool) ((s3232 >> 0) & 1);+  const SBool  s5834 = false != s5833;+  const SWord8 s5835 = (s3219 >> 1) | (s3219 << 7);+  const SWord8 s5836 = 128 | s5835;+  const SWord8 s5837 = 127 & s5835;+  const SWord8 s5838 = s5834 ? s5836 : s5837;+  const SWord8 s5839 = (s5838 >> 1) | (s5838 << 7);+  const SWord8 s5840 = 128 | s5839;+  const SWord8 s5841 = 127 & s5839;+  const SWord8 s5842 = s5832 ? s5840 : s5841;+  const SWord8 s5843 = (s5842 >> 1) | (s5842 << 7);+  const SWord8 s5844 = 128 | s5843;+  const SWord8 s5845 = 127 & s5843;+  const SWord8 s5846 = s5830 ? s5844 : s5845;+  const SBool  s5847 = (SBool) ((s3245 >> 0) & 1);+  const SBool  s5848 = false != s5847;+  const SWord8 s5849 = s5848 ? s5844 : s5845;+  const SWord8 s5850 = s3225 ? s5846 : s5849;+  const SBool  s5851 = (SBool) ((s3261 >> 0) & 1);+  const SBool  s5852 = false != s5851;+  const SBool  s5853 = (SBool) ((s3254 >> 0) & 1);+  const SBool  s5854 = false != s5853;+  const SWord8 s5855 = s5854 ? s5840 : s5841;+  const SWord8 s5856 = (s5855 >> 1) | (s5855 << 7);+  const SWord8 s5857 = 128 | s5856;+  const SWord8 s5858 = 127 & s5856;+  const SWord8 s5859 = s5852 ? s5857 : s5858;+  const SBool  s5860 = (SBool) ((s3266 >> 0) & 1);+  const SBool  s5861 = false != s5860;+  const SWord8 s5862 = s5861 ? s5857 : s5858;+  const SWord8 s5863 = s3225 ? s5859 : s5862;+  const SWord8 s5864 = s3101 ? s5850 : s5863;+  const SBool  s5865 = (SBool) ((s3287 >> 0) & 1);+  const SBool  s5866 = false != s5865;+  const SBool  s5867 = (SBool) ((s3283 >> 0) & 1);+  const SBool  s5868 = false != s5867;+  const SBool  s5869 = (SBool) ((s3276 >> 0) & 1);+  const SBool  s5870 = false != s5869;+  const SWord8 s5871 = s5870 ? s5836 : s5837;+  const SWord8 s5872 = (s5871 >> 1) | (s5871 << 7);+  const SWord8 s5873 = 128 | s5872;+  const SWord8 s5874 = 127 & s5872;+  const SWord8 s5875 = s5868 ? s5873 : s5874;+  const SWord8 s5876 = (s5875 >> 1) | (s5875 << 7);+  const SWord8 s5877 = 128 | s5876;+  const SWord8 s5878 = 127 & s5876;+  const SWord8 s5879 = s5866 ? s5877 : s5878;+  const SBool  s5880 = (SBool) ((s3292 >> 0) & 1);+  const SBool  s5881 = false != s5880;+  const SWord8 s5882 = s5881 ? s5877 : s5878;+  const SWord8 s5883 = s3225 ? s5879 : s5882;+  const SBool  s5884 = (SBool) ((s3308 >> 0) & 1);+  const SBool  s5885 = false != s5884;+  const SBool  s5886 = (SBool) ((s3301 >> 0) & 1);+  const SBool  s5887 = false != s5886;+  const SWord8 s5888 = s5887 ? s5873 : s5874;+  const SWord8 s5889 = (s5888 >> 1) | (s5888 << 7);+  const SWord8 s5890 = 128 | s5889;+  const SWord8 s5891 = 127 & s5889;+  const SWord8 s5892 = s5885 ? s5890 : s5891;+  const SBool  s5893 = (SBool) ((s3313 >> 0) & 1);+  const SBool  s5894 = false != s5893;+  const SWord8 s5895 = s5894 ? s5890 : s5891;+  const SWord8 s5896 = s3225 ? s5892 : s5895;+  const SWord8 s5897 = s3101 ? s5883 : s5896;+  const SWord8 s5898 = s3082 ? s5864 : s5897;+  const SWord8 s5899 = s3060 ? s5828 : s5898;+  const SBool  s5900 = (SBool) ((s3368 >> 0) & 1);+  const SBool  s5901 = false != s5900;+  const SBool  s5902 = (SBool) ((s3364 >> 0) & 1);+  const SBool  s5903 = false != s5902;+  const SBool  s5904 = (SBool) ((s3360 >> 0) & 1);+  const SBool  s5905 = false != s5904;+  const SWord8 s5906 = (s3347 >> 1) | (s3347 << 7);+  const SWord8 s5907 = 128 | s5906;+  const SWord8 s5908 = 127 & s5906;+  const SWord8 s5909 = s5905 ? s5907 : s5908;+  const SWord8 s5910 = (s5909 >> 1) | (s5909 << 7);+  const SWord8 s5911 = 128 | s5910;+  const SWord8 s5912 = 127 & s5910;+  const SWord8 s5913 = s5903 ? s5911 : s5912;+  const SWord8 s5914 = (s5913 >> 1) | (s5913 << 7);+  const SWord8 s5915 = 128 | s5914;+  const SWord8 s5916 = 127 & s5914;+  const SWord8 s5917 = s5901 ? s5915 : s5916;+  const SBool  s5918 = (SBool) ((s3373 >> 0) & 1);+  const SBool  s5919 = false != s5918;+  const SWord8 s5920 = s5919 ? s5915 : s5916;+  const SWord8 s5921 = s3356 ? s5917 : s5920;+  const SBool  s5922 = (SBool) ((s3389 >> 0) & 1);+  const SBool  s5923 = false != s5922;+  const SBool  s5924 = (SBool) ((s3382 >> 0) & 1);+  const SBool  s5925 = false != s5924;+  const SWord8 s5926 = s5925 ? s5911 : s5912;+  const SWord8 s5927 = (s5926 >> 1) | (s5926 << 7);+  const SWord8 s5928 = 128 | s5927;+  const SWord8 s5929 = 127 & s5927;+  const SWord8 s5930 = s5923 ? s5928 : s5929;+  const SBool  s5931 = (SBool) ((s3394 >> 0) & 1);+  const SBool  s5932 = false != s5931;+  const SWord8 s5933 = s5932 ? s5928 : s5929;+  const SWord8 s5934 = s3356 ? s5930 : s5933;+  const SWord8 s5935 = s3334 ? s5921 : s5934;+  const SBool  s5936 = (SBool) ((s3415 >> 0) & 1);+  const SBool  s5937 = false != s5936;+  const SBool  s5938 = (SBool) ((s3411 >> 0) & 1);+  const SBool  s5939 = false != s5938;+  const SBool  s5940 = (SBool) ((s3404 >> 0) & 1);+  const SBool  s5941 = false != s5940;+  const SWord8 s5942 = s5941 ? s5907 : s5908;+  const SWord8 s5943 = (s5942 >> 1) | (s5942 << 7);+  const SWord8 s5944 = 128 | s5943;+  const SWord8 s5945 = 127 & s5943;+  const SWord8 s5946 = s5939 ? s5944 : s5945;+  const SWord8 s5947 = (s5946 >> 1) | (s5946 << 7);+  const SWord8 s5948 = 128 | s5947;+  const SWord8 s5949 = 127 & s5947;+  const SWord8 s5950 = s5937 ? s5948 : s5949;+  const SBool  s5951 = (SBool) ((s3420 >> 0) & 1);+  const SBool  s5952 = false != s5951;+  const SWord8 s5953 = s5952 ? s5948 : s5949;+  const SWord8 s5954 = s3356 ? s5950 : s5953;+  const SBool  s5955 = (SBool) ((s3436 >> 0) & 1);+  const SBool  s5956 = false != s5955;+  const SBool  s5957 = (SBool) ((s3429 >> 0) & 1);+  const SBool  s5958 = false != s5957;+  const SWord8 s5959 = s5958 ? s5944 : s5945;+  const SWord8 s5960 = (s5959 >> 1) | (s5959 << 7);+  const SWord8 s5961 = 128 | s5960;+  const SWord8 s5962 = 127 & s5960;+  const SWord8 s5963 = s5956 ? s5961 : s5962;+  const SBool  s5964 = (SBool) ((s3441 >> 0) & 1);+  const SBool  s5965 = false != s5964;+  const SWord8 s5966 = s5965 ? s5961 : s5962;+  const SWord8 s5967 = s3356 ? s5963 : s5966;+  const SWord8 s5968 = s3334 ? s5954 : s5967;+  const SWord8 s5969 = s3082 ? s5935 : s5968;+  const SBool  s5970 = (SBool) ((s3476 >> 0) & 1);+  const SBool  s5971 = false != s5970;+  const SBool  s5972 = (SBool) ((s3472 >> 0) & 1);+  const SBool  s5973 = false != s5972;+  const SBool  s5974 = (SBool) ((s3468 >> 0) & 1);+  const SBool  s5975 = false != s5974;+  const SWord8 s5976 = (s3455 >> 1) | (s3455 << 7);+  const SWord8 s5977 = 128 | s5976;+  const SWord8 s5978 = 127 & s5976;+  const SWord8 s5979 = s5975 ? s5977 : s5978;+  const SWord8 s5980 = (s5979 >> 1) | (s5979 << 7);+  const SWord8 s5981 = 128 | s5980;+  const SWord8 s5982 = 127 & s5980;+  const SWord8 s5983 = s5973 ? s5981 : s5982;+  const SWord8 s5984 = (s5983 >> 1) | (s5983 << 7);+  const SWord8 s5985 = 128 | s5984;+  const SWord8 s5986 = 127 & s5984;+  const SWord8 s5987 = s5971 ? s5985 : s5986;+  const SBool  s5988 = (SBool) ((s3481 >> 0) & 1);+  const SBool  s5989 = false != s5988;+  const SWord8 s5990 = s5989 ? s5985 : s5986;+  const SWord8 s5991 = s3461 ? s5987 : s5990;+  const SBool  s5992 = (SBool) ((s3497 >> 0) & 1);+  const SBool  s5993 = false != s5992;+  const SBool  s5994 = (SBool) ((s3490 >> 0) & 1);+  const SBool  s5995 = false != s5994;+  const SWord8 s5996 = s5995 ? s5981 : s5982;+  const SWord8 s5997 = (s5996 >> 1) | (s5996 << 7);+  const SWord8 s5998 = 128 | s5997;+  const SWord8 s5999 = 127 & s5997;+  const SWord8 s6000 = s5993 ? s5998 : s5999;+  const SBool  s6001 = (SBool) ((s3502 >> 0) & 1);+  const SBool  s6002 = false != s6001;+  const SWord8 s6003 = s6002 ? s5998 : s5999;+  const SWord8 s6004 = s3461 ? s6000 : s6003;+  const SWord8 s6005 = s3334 ? s5991 : s6004;+  const SBool  s6006 = (SBool) ((s3523 >> 0) & 1);+  const SBool  s6007 = false != s6006;+  const SBool  s6008 = (SBool) ((s3519 >> 0) & 1);+  const SBool  s6009 = false != s6008;+  const SBool  s6010 = (SBool) ((s3512 >> 0) & 1);+  const SBool  s6011 = false != s6010;+  const SWord8 s6012 = s6011 ? s5977 : s5978;+  const SWord8 s6013 = (s6012 >> 1) | (s6012 << 7);+  const SWord8 s6014 = 128 | s6013;+  const SWord8 s6015 = 127 & s6013;+  const SWord8 s6016 = s6009 ? s6014 : s6015;+  const SWord8 s6017 = (s6016 >> 1) | (s6016 << 7);+  const SWord8 s6018 = 128 | s6017;+  const SWord8 s6019 = 127 & s6017;+  const SWord8 s6020 = s6007 ? s6018 : s6019;+  const SBool  s6021 = (SBool) ((s3528 >> 0) & 1);+  const SBool  s6022 = false != s6021;+  const SWord8 s6023 = s6022 ? s6018 : s6019;+  const SWord8 s6024 = s3461 ? s6020 : s6023;+  const SBool  s6025 = (SBool) ((s3544 >> 0) & 1);+  const SBool  s6026 = false != s6025;+  const SBool  s6027 = (SBool) ((s3537 >> 0) & 1);+  const SBool  s6028 = false != s6027;+  const SWord8 s6029 = s6028 ? s6014 : s6015;+  const SWord8 s6030 = (s6029 >> 1) | (s6029 << 7);+  const SWord8 s6031 = 128 | s6030;+  const SWord8 s6032 = 127 & s6030;+  const SWord8 s6033 = s6026 ? s6031 : s6032;+  const SBool  s6034 = (SBool) ((s3549 >> 0) & 1);+  const SBool  s6035 = false != s6034;+  const SWord8 s6036 = s6035 ? s6031 : s6032;+  const SWord8 s6037 = s3461 ? s6033 : s6036;+  const SWord8 s6038 = s3334 ? s6024 : s6037;+  const SWord8 s6039 = s3082 ? s6005 : s6038;+  const SWord8 s6040 = s3060 ? s5969 : s6039;+  const SWord8 s6041 = s2042 ? s5899 : s6040;+  const SBool  s6042 = (SBool) ((s3624 >> 0) & 1);+  const SBool  s6043 = false != s6042;+  const SBool  s6044 = (SBool) ((s3620 >> 0) & 1);+  const SBool  s6045 = false != s6044;+  const SBool  s6046 = (SBool) ((s3616 >> 0) & 1);+  const SBool  s6047 = false != s6046;+  const SWord8 s6048 = (s3603 >> 1) | (s3603 << 7);+  const SWord8 s6049 = 128 | s6048;+  const SWord8 s6050 = 127 & s6048;+  const SWord8 s6051 = s6047 ? s6049 : s6050;+  const SWord8 s6052 = (s6051 >> 1) | (s6051 << 7);+  const SWord8 s6053 = 128 | s6052;+  const SWord8 s6054 = 127 & s6052;+  const SWord8 s6055 = s6045 ? s6053 : s6054;+  const SWord8 s6056 = (s6055 >> 1) | (s6055 << 7);+  const SWord8 s6057 = 128 | s6056;+  const SWord8 s6058 = 127 & s6056;+  const SWord8 s6059 = s6043 ? s6057 : s6058;+  const SBool  s6060 = (SBool) ((s3629 >> 0) & 1);+  const SBool  s6061 = false != s6060;+  const SWord8 s6062 = s6061 ? s6057 : s6058;+  const SWord8 s6063 = s3612 ? s6059 : s6062;+  const SBool  s6064 = (SBool) ((s3645 >> 0) & 1);+  const SBool  s6065 = false != s6064;+  const SBool  s6066 = (SBool) ((s3638 >> 0) & 1);+  const SBool  s6067 = false != s6066;+  const SWord8 s6068 = s6067 ? s6053 : s6054;+  const SWord8 s6069 = (s6068 >> 1) | (s6068 << 7);+  const SWord8 s6070 = 128 | s6069;+  const SWord8 s6071 = 127 & s6069;+  const SWord8 s6072 = s6065 ? s6070 : s6071;+  const SBool  s6073 = (SBool) ((s3650 >> 0) & 1);+  const SBool  s6074 = false != s6073;+  const SWord8 s6075 = s6074 ? s6070 : s6071;+  const SWord8 s6076 = s3612 ? s6072 : s6075;+  const SWord8 s6077 = s3593 ? s6063 : s6076;+  const SBool  s6078 = (SBool) ((s3671 >> 0) & 1);+  const SBool  s6079 = false != s6078;+  const SBool  s6080 = (SBool) ((s3667 >> 0) & 1);+  const SBool  s6081 = false != s6080;+  const SBool  s6082 = (SBool) ((s3660 >> 0) & 1);+  const SBool  s6083 = false != s6082;+  const SWord8 s6084 = s6083 ? s6049 : s6050;+  const SWord8 s6085 = (s6084 >> 1) | (s6084 << 7);+  const SWord8 s6086 = 128 | s6085;+  const SWord8 s6087 = 127 & s6085;+  const SWord8 s6088 = s6081 ? s6086 : s6087;+  const SWord8 s6089 = (s6088 >> 1) | (s6088 << 7);+  const SWord8 s6090 = 128 | s6089;+  const SWord8 s6091 = 127 & s6089;+  const SWord8 s6092 = s6079 ? s6090 : s6091;+  const SBool  s6093 = (SBool) ((s3676 >> 0) & 1);+  const SBool  s6094 = false != s6093;+  const SWord8 s6095 = s6094 ? s6090 : s6091;+  const SWord8 s6096 = s3612 ? s6092 : s6095;+  const SBool  s6097 = (SBool) ((s3692 >> 0) & 1);+  const SBool  s6098 = false != s6097;+  const SBool  s6099 = (SBool) ((s3685 >> 0) & 1);+  const SBool  s6100 = false != s6099;+  const SWord8 s6101 = s6100 ? s6086 : s6087;+  const SWord8 s6102 = (s6101 >> 1) | (s6101 << 7);+  const SWord8 s6103 = 128 | s6102;+  const SWord8 s6104 = 127 & s6102;+  const SWord8 s6105 = s6098 ? s6103 : s6104;+  const SBool  s6106 = (SBool) ((s3697 >> 0) & 1);+  const SBool  s6107 = false != s6106;+  const SWord8 s6108 = s6107 ? s6103 : s6104;+  const SWord8 s6109 = s3612 ? s6105 : s6108;+  const SWord8 s6110 = s3593 ? s6096 : s6109;+  const SWord8 s6111 = s3571 ? s6077 : s6110;+  const SBool  s6112 = (SBool) ((s3732 >> 0) & 1);+  const SBool  s6113 = false != s6112;+  const SBool  s6114 = (SBool) ((s3728 >> 0) & 1);+  const SBool  s6115 = false != s6114;+  const SBool  s6116 = (SBool) ((s3724 >> 0) & 1);+  const SBool  s6117 = false != s6116;+  const SWord8 s6118 = (s3711 >> 1) | (s3711 << 7);+  const SWord8 s6119 = 128 | s6118;+  const SWord8 s6120 = 127 & s6118;+  const SWord8 s6121 = s6117 ? s6119 : s6120;+  const SWord8 s6122 = (s6121 >> 1) | (s6121 << 7);+  const SWord8 s6123 = 128 | s6122;+  const SWord8 s6124 = 127 & s6122;+  const SWord8 s6125 = s6115 ? s6123 : s6124;+  const SWord8 s6126 = (s6125 >> 1) | (s6125 << 7);+  const SWord8 s6127 = 128 | s6126;+  const SWord8 s6128 = 127 & s6126;+  const SWord8 s6129 = s6113 ? s6127 : s6128;+  const SBool  s6130 = (SBool) ((s3737 >> 0) & 1);+  const SBool  s6131 = false != s6130;+  const SWord8 s6132 = s6131 ? s6127 : s6128;+  const SWord8 s6133 = s3717 ? s6129 : s6132;+  const SBool  s6134 = (SBool) ((s3753 >> 0) & 1);+  const SBool  s6135 = false != s6134;+  const SBool  s6136 = (SBool) ((s3746 >> 0) & 1);+  const SBool  s6137 = false != s6136;+  const SWord8 s6138 = s6137 ? s6123 : s6124;+  const SWord8 s6139 = (s6138 >> 1) | (s6138 << 7);+  const SWord8 s6140 = 128 | s6139;+  const SWord8 s6141 = 127 & s6139;+  const SWord8 s6142 = s6135 ? s6140 : s6141;+  const SBool  s6143 = (SBool) ((s3758 >> 0) & 1);+  const SBool  s6144 = false != s6143;+  const SWord8 s6145 = s6144 ? s6140 : s6141;+  const SWord8 s6146 = s3717 ? s6142 : s6145;+  const SWord8 s6147 = s3593 ? s6133 : s6146;+  const SBool  s6148 = (SBool) ((s3779 >> 0) & 1);+  const SBool  s6149 = false != s6148;+  const SBool  s6150 = (SBool) ((s3775 >> 0) & 1);+  const SBool  s6151 = false != s6150;+  const SBool  s6152 = (SBool) ((s3768 >> 0) & 1);+  const SBool  s6153 = false != s6152;+  const SWord8 s6154 = s6153 ? s6119 : s6120;+  const SWord8 s6155 = (s6154 >> 1) | (s6154 << 7);+  const SWord8 s6156 = 128 | s6155;+  const SWord8 s6157 = 127 & s6155;+  const SWord8 s6158 = s6151 ? s6156 : s6157;+  const SWord8 s6159 = (s6158 >> 1) | (s6158 << 7);+  const SWord8 s6160 = 128 | s6159;+  const SWord8 s6161 = 127 & s6159;+  const SWord8 s6162 = s6149 ? s6160 : s6161;+  const SBool  s6163 = (SBool) ((s3784 >> 0) & 1);+  const SBool  s6164 = false != s6163;+  const SWord8 s6165 = s6164 ? s6160 : s6161;+  const SWord8 s6166 = s3717 ? s6162 : s6165;+  const SBool  s6167 = (SBool) ((s3800 >> 0) & 1);+  const SBool  s6168 = false != s6167;+  const SBool  s6169 = (SBool) ((s3793 >> 0) & 1);+  const SBool  s6170 = false != s6169;+  const SWord8 s6171 = s6170 ? s6156 : s6157;+  const SWord8 s6172 = (s6171 >> 1) | (s6171 << 7);+  const SWord8 s6173 = 128 | s6172;+  const SWord8 s6174 = 127 & s6172;+  const SWord8 s6175 = s6168 ? s6173 : s6174;+  const SBool  s6176 = (SBool) ((s3805 >> 0) & 1);+  const SBool  s6177 = false != s6176;+  const SWord8 s6178 = s6177 ? s6173 : s6174;+  const SWord8 s6179 = s3717 ? s6175 : s6178;+  const SWord8 s6180 = s3593 ? s6166 : s6179;+  const SWord8 s6181 = s3571 ? s6147 : s6180;+  const SWord8 s6182 = s3060 ? s6111 : s6181;+  const SBool  s6183 = (SBool) ((s3860 >> 0) & 1);+  const SBool  s6184 = false != s6183;+  const SBool  s6185 = (SBool) ((s3856 >> 0) & 1);+  const SBool  s6186 = false != s6185;+  const SBool  s6187 = (SBool) ((s3852 >> 0) & 1);+  const SBool  s6188 = false != s6187;+  const SWord8 s6189 = (s3839 >> 1) | (s3839 << 7);+  const SWord8 s6190 = 128 | s6189;+  const SWord8 s6191 = 127 & s6189;+  const SWord8 s6192 = s6188 ? s6190 : s6191;+  const SWord8 s6193 = (s6192 >> 1) | (s6192 << 7);+  const SWord8 s6194 = 128 | s6193;+  const SWord8 s6195 = 127 & s6193;+  const SWord8 s6196 = s6186 ? s6194 : s6195;+  const SWord8 s6197 = (s6196 >> 1) | (s6196 << 7);+  const SWord8 s6198 = 128 | s6197;+  const SWord8 s6199 = 127 & s6197;+  const SWord8 s6200 = s6184 ? s6198 : s6199;+  const SBool  s6201 = (SBool) ((s3865 >> 0) & 1);+  const SBool  s6202 = false != s6201;+  const SWord8 s6203 = s6202 ? s6198 : s6199;+  const SWord8 s6204 = s3848 ? s6200 : s6203;+  const SBool  s6205 = (SBool) ((s3881 >> 0) & 1);+  const SBool  s6206 = false != s6205;+  const SBool  s6207 = (SBool) ((s3874 >> 0) & 1);+  const SBool  s6208 = false != s6207;+  const SWord8 s6209 = s6208 ? s6194 : s6195;+  const SWord8 s6210 = (s6209 >> 1) | (s6209 << 7);+  const SWord8 s6211 = 128 | s6210;+  const SWord8 s6212 = 127 & s6210;+  const SWord8 s6213 = s6206 ? s6211 : s6212;+  const SBool  s6214 = (SBool) ((s3886 >> 0) & 1);+  const SBool  s6215 = false != s6214;+  const SWord8 s6216 = s6215 ? s6211 : s6212;+  const SWord8 s6217 = s3848 ? s6213 : s6216;+  const SWord8 s6218 = s3826 ? s6204 : s6217;+  const SBool  s6219 = (SBool) ((s3907 >> 0) & 1);+  const SBool  s6220 = false != s6219;+  const SBool  s6221 = (SBool) ((s3903 >> 0) & 1);+  const SBool  s6222 = false != s6221;+  const SBool  s6223 = (SBool) ((s3896 >> 0) & 1);+  const SBool  s6224 = false != s6223;+  const SWord8 s6225 = s6224 ? s6190 : s6191;+  const SWord8 s6226 = (s6225 >> 1) | (s6225 << 7);+  const SWord8 s6227 = 128 | s6226;+  const SWord8 s6228 = 127 & s6226;+  const SWord8 s6229 = s6222 ? s6227 : s6228;+  const SWord8 s6230 = (s6229 >> 1) | (s6229 << 7);+  const SWord8 s6231 = 128 | s6230;+  const SWord8 s6232 = 127 & s6230;+  const SWord8 s6233 = s6220 ? s6231 : s6232;+  const SBool  s6234 = (SBool) ((s3912 >> 0) & 1);+  const SBool  s6235 = false != s6234;+  const SWord8 s6236 = s6235 ? s6231 : s6232;+  const SWord8 s6237 = s3848 ? s6233 : s6236;+  const SBool  s6238 = (SBool) ((s3928 >> 0) & 1);+  const SBool  s6239 = false != s6238;+  const SBool  s6240 = (SBool) ((s3921 >> 0) & 1);+  const SBool  s6241 = false != s6240;+  const SWord8 s6242 = s6241 ? s6227 : s6228;+  const SWord8 s6243 = (s6242 >> 1) | (s6242 << 7);+  const SWord8 s6244 = 128 | s6243;+  const SWord8 s6245 = 127 & s6243;+  const SWord8 s6246 = s6239 ? s6244 : s6245;+  const SBool  s6247 = (SBool) ((s3933 >> 0) & 1);+  const SBool  s6248 = false != s6247;+  const SWord8 s6249 = s6248 ? s6244 : s6245;+  const SWord8 s6250 = s3848 ? s6246 : s6249;+  const SWord8 s6251 = s3826 ? s6237 : s6250;+  const SWord8 s6252 = s3571 ? s6218 : s6251;+  const SBool  s6253 = (SBool) ((s3968 >> 0) & 1);+  const SBool  s6254 = false != s6253;+  const SBool  s6255 = (SBool) ((s3964 >> 0) & 1);+  const SBool  s6256 = false != s6255;+  const SBool  s6257 = (SBool) ((s3960 >> 0) & 1);+  const SBool  s6258 = false != s6257;+  const SWord8 s6259 = (s3947 >> 1) | (s3947 << 7);+  const SWord8 s6260 = 128 | s6259;+  const SWord8 s6261 = 127 & s6259;+  const SWord8 s6262 = s6258 ? s6260 : s6261;+  const SWord8 s6263 = (s6262 >> 1) | (s6262 << 7);+  const SWord8 s6264 = 128 | s6263;+  const SWord8 s6265 = 127 & s6263;+  const SWord8 s6266 = s6256 ? s6264 : s6265;+  const SWord8 s6267 = (s6266 >> 1) | (s6266 << 7);+  const SWord8 s6268 = 128 | s6267;+  const SWord8 s6269 = 127 & s6267;+  const SWord8 s6270 = s6254 ? s6268 : s6269;+  const SBool  s6271 = (SBool) ((s3973 >> 0) & 1);+  const SBool  s6272 = false != s6271;+  const SWord8 s6273 = s6272 ? s6268 : s6269;+  const SWord8 s6274 = s3953 ? s6270 : s6273;+  const SBool  s6275 = (SBool) ((s3989 >> 0) & 1);+  const SBool  s6276 = false != s6275;+  const SBool  s6277 = (SBool) ((s3982 >> 0) & 1);+  const SBool  s6278 = false != s6277;+  const SWord8 s6279 = s6278 ? s6264 : s6265;+  const SWord8 s6280 = (s6279 >> 1) | (s6279 << 7);+  const SWord8 s6281 = 128 | s6280;+  const SWord8 s6282 = 127 & s6280;+  const SWord8 s6283 = s6276 ? s6281 : s6282;+  const SBool  s6284 = (SBool) ((s3994 >> 0) & 1);+  const SBool  s6285 = false != s6284;+  const SWord8 s6286 = s6285 ? s6281 : s6282;+  const SWord8 s6287 = s3953 ? s6283 : s6286;+  const SWord8 s6288 = s3826 ? s6274 : s6287;+  const SBool  s6289 = (SBool) ((s4015 >> 0) & 1);+  const SBool  s6290 = false != s6289;+  const SBool  s6291 = (SBool) ((s4011 >> 0) & 1);+  const SBool  s6292 = false != s6291;+  const SBool  s6293 = (SBool) ((s4004 >> 0) & 1);+  const SBool  s6294 = false != s6293;+  const SWord8 s6295 = s6294 ? s6260 : s6261;+  const SWord8 s6296 = (s6295 >> 1) | (s6295 << 7);+  const SWord8 s6297 = 128 | s6296;+  const SWord8 s6298 = 127 & s6296;+  const SWord8 s6299 = s6292 ? s6297 : s6298;+  const SWord8 s6300 = (s6299 >> 1) | (s6299 << 7);+  const SWord8 s6301 = 128 | s6300;+  const SWord8 s6302 = 127 & s6300;+  const SWord8 s6303 = s6290 ? s6301 : s6302;+  const SBool  s6304 = (SBool) ((s4020 >> 0) & 1);+  const SBool  s6305 = false != s6304;+  const SWord8 s6306 = s6305 ? s6301 : s6302;+  const SWord8 s6307 = s3953 ? s6303 : s6306;+  const SBool  s6308 = (SBool) ((s4036 >> 0) & 1);+  const SBool  s6309 = false != s6308;+  const SBool  s6310 = (SBool) ((s4029 >> 0) & 1);+  const SBool  s6311 = false != s6310;+  const SWord8 s6312 = s6311 ? s6297 : s6298;+  const SWord8 s6313 = (s6312 >> 1) | (s6312 << 7);+  const SWord8 s6314 = 128 | s6313;+  const SWord8 s6315 = 127 & s6313;+  const SWord8 s6316 = s6309 ? s6314 : s6315;+  const SBool  s6317 = (SBool) ((s4041 >> 0) & 1);+  const SBool  s6318 = false != s6317;+  const SWord8 s6319 = s6318 ? s6314 : s6315;+  const SWord8 s6320 = s3953 ? s6316 : s6319;+  const SWord8 s6321 = s3826 ? s6307 : s6320;+  const SWord8 s6322 = s3571 ? s6288 : s6321;+  const SWord8 s6323 = s3060 ? s6252 : s6322;+  const SWord8 s6324 = s2042 ? s6182 : s6323;+  const SWord8 s6325 = s16 ? s6041 : s6324;+  const SWord8 s6326 = s11 ? s5758 : s6325;+  const SWord8 s6327 = s5 ? s5191 : s6326;++  *hi = s4056;+  *lo = s6327;+}+== END: "legatoMult.c" ==================
+ SBVTestSuite/GoldFiles/merge.gold view
@@ -0,0 +1,156 @@+== BEGIN: "Makefile" ================+# Makefile for merge. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: merge_driver++merge.o: merge.c merge.h+	${CC} ${CCFLAGS} -c $< -o $@++merge_driver.o: merge_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++merge_driver: merge.o merge_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f merge_driver+== END: "Makefile" ==================+== BEGIN: "merge.h" ================+/* Header file for merge. Automatically generated by SBV. Do not edit! */++#ifndef __merge__HEADER_INCLUDED__+#define __merge__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+void merge(const SWord8 *xs, SWord8 *ys);++#endif /* __merge__HEADER_INCLUDED__ */+== END: "merge.h" ==================+== BEGIN: "merge_driver.c" ================+/* Example driver program for merge. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "merge.h"++int main(void)+{+  const SWord8 xs[5] = {+      10,  6,  4, 82, 71+  };++  printf("Contents of input array xs:\n");+  int xs_ctr;+  for(xs_ctr = 0; xs_ctr < 5 ; ++xs_ctr)+    printf("  xs[%d] = %"PRIu8"\n", xs_ctr ,xs[xs_ctr]);++  SWord8 ys[5];++  merge(xs, ys);++  printf("merge(xs, ys) ->\n");+  int ys_ctr;+  for(ys_ctr = 0; ys_ctr < 5 ; ++ys_ctr)+    printf("  ys[%d] = %"PRIu8"\n", ys_ctr ,ys[ys_ctr]);++  return 0;+}+== END: "merge_driver.c" ==================+== BEGIN: "merge.c" ================+/* File: "merge.c". Automatically generated by SBV. Do not edit! */++#include "merge.h"++void merge(const SWord8 *xs, SWord8 *ys)+{+  const SWord8 s0 = xs[0];+  const SWord8 s1 = xs[1];+  const SWord8 s2 = xs[2];+  const SWord8 s3 = xs[3];+  const SWord8 s4 = xs[4];+  const SBool  s5 = s0 < s1;+  const SWord8 s6 = s5 ? s0 : s1;+  const SBool  s7 = s3 < s4;+  const SWord8 s8 = s7 ? s3 : s4;+  const SBool  s9 = s2 < s8;+  const SWord8 s10 = s9 ? s2 : s8;+  const SBool  s11 = s6 < s10;+  const SWord8 s12 = s11 ? s6 : s10;+  const SWord8 s13 = s5 ? s1 : s0;+  const SBool  s14 = s13 < s10;+  const SWord8 s15 = s14 ? s13 : s10;+  const SWord8 s16 = s7 ? s4 : s3;+  const SBool  s17 = s2 < s16;+  const SWord8 s18 = s17 ? s2 : s16;+  const SWord8 s19 = s9 ? s8 : s18;+  const SBool  s20 = s6 < s19;+  const SWord8 s21 = s20 ? s6 : s19;+  const SWord8 s22 = s11 ? s15 : s21;+  const SBool  s23 = s13 < s19;+  const SWord8 s24 = s23 ? s13 : s19;+  const SWord8 s25 = s14 ? s10 : s24;+  const SWord8 s26 = s17 ? s16 : s2;+  const SWord8 s27 = s9 ? s16 : s26;+  const SBool  s28 = s6 < s27;+  const SWord8 s29 = s28 ? s6 : s27;+  const SWord8 s30 = s20 ? s24 : s29;+  const SWord8 s31 = s11 ? s25 : s30;+  const SBool  s32 = s13 < s27;+  const SWord8 s33 = s32 ? s13 : s27;+  const SWord8 s34 = s23 ? s19 : s33;+  const SWord8 s35 = s14 ? s19 : s34;+  const SWord8 s36 = s28 ? s33 : s6;+  const SWord8 s37 = s20 ? s34 : s36;+  const SWord8 s38 = s11 ? s35 : s37;+  const SWord8 s39 = s32 ? s27 : s13;+  const SWord8 s40 = s23 ? s27 : s39;+  const SWord8 s41 = s14 ? s27 : s40;+  const SWord8 s42 = s28 ? s39 : s13;+  const SWord8 s43 = s20 ? s40 : s42;+  const SWord8 s44 = s11 ? s41 : s43;++  ys[0] = s12;+  ys[1] = s22;+  ys[2] = s31;+  ys[3] = s38;+  ys[4] = s44;+}+== END: "merge.c" ==================
+ SBVTestSuite/GoldFiles/noTravis_query1.gold view
@@ -0,0 +1,190 @@+** 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-unsat-cores true)+[GOOD] (set-option :produce-unsat-assumptions true)+[GOOD] (set-option :produce-proofs true)+[GOOD] (set-option :random-seed 123)+[GOOD] (set-option :produce-assertions true)+[GOOD] (set-option :smt.mbqi true)+[GOOD] (set-option :produce-assignments true)+[GOOD] (set-info :status sat)+[GOOD] (set-info :bad what)+[GOOD] (set-option :produce-models true)+[GOOD] (set-logic ALL)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s6 () Int 0)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () Int) ; tracks user variable "a"+[GOOD] (declare-fun s1 () Int) ; tracks user variable "b"+[GOOD] (declare-fun s2 () (_ FloatingPoint  8 24)) ; tracks user variable "c"+[GOOD] (declare-fun s3 () Bool) ; tracks user variable "d"+[GOOD] (declare-fun s4 () Real) ; tracks user variable "e"+[GOOD] (declare-fun s5 () (_ BitVec 8))+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s7 () Bool (> s0 s6))+[GOOD] (define-fun s8 () Bool (> s1 s6))+[GOOD] (assert (! s7 :named |a > 0|))+[GOOD] (assert s8)+[GOOD] (define-fun s9 () Int 2)+[GOOD] (define-fun s11 () Int 5)+[GOOD] (define-fun s10 () Int (+ s0 s9))+[GOOD] (define-fun s12 () Bool (>= s10 s11))+[GOOD] (assert s12)+[GOOD] (define-fun s14 () Int 12)+[GOOD] (define-fun s13 () Int (+ s0 s1))+[GOOD] (define-fun s15 () Bool (< s13 s14))+[GOOD] (assert (! s15 :named |a+b_<_12|))+[SEND] (get-option :diagnostic-output-channel)+[RECV] stdout+[SEND] (get-option :produce-assertions)+[RECV] true+[SEND] (get-option :produce-assignments)+[RECV] true+[SEND] (get-option :produce-proofs)+[RECV] true+[SEND] (get-option :produce-unsat-assumptions)+[RECV] unsupported+[SEND] (get-option :produce-unsat-cores)+[SKIP] ; :produce-unsat-assumptions line: 42 position: 0+[RECV] true+[SEND] (get-option :random-seed)+[RECV] 123+[SEND] (get-option :reproducible-resource-limit)+[RECV] unsupported+[SEND] (get-option :verbosity)+[SKIP] ; :reproducible-resource-limit line: 45 position: 0+[RECV] 0+[SEND] (get-option :smt.mbqi)+[RECV] true+[SEND] (get-option :smt.mbqi)+[RECV] true+[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.5.1")+[SEND] (get-info :status)+[RECV] (:status sat)+[GOOD] (define-fun s16 () Int 4)+[GOOD] (define-fun s17 () Bool (> s0 s16))+[GOOD] (assert (! s17 :named |later, a > 4|))+[SEND] (check-sat)+[RECV] sat+[GOOD] (set-info :status unknown)+[GOOD] (define-fun s18 () Bool (> s0 s9))+[GOOD] (declare-const __assumption_proxy_s18_19 Bool)+[GOOD] (assert (= __assumption_proxy_s18_19 s18))+[SEND] (check-sat-assuming (__assumption_proxy_s18_19))+[RECV] sat+[GOOD] (declare-const __assumption_proxy_s18_20 Bool)+[GOOD] (assert (= __assumption_proxy_s18_20 s18))+[SEND] (check-sat-assuming (__assumption_proxy_s18_20))+[RECV] sat+[SEND] (get-assignment)+[RECV] ((s_1 true) (s7 true) (|a > 0| true) (s15 true) (s_2 false) (s8 true) (a+b_<_12 true) (s17 true) (|later, a > 4| true) (s18 true) (s12 true))+[SEND] (get-info :assertion-stack-levels)+[RECV] (:assertion-stack-levels 0)+[SEND] (get-info :authors)+[RECV] (:authors "Leonardo de Moura, Nikolaj Bjorner and Christoph Wintersteiger")+[SEND] (get-info :error-behavior)+[RECV] (:error-behavior continued-execution)+[SEND] (get-info :name)+[RECV] (:name "Z3")+[SEND] (get-info :reason-unknown)+[RECV] (:reason-unknown "unknown")+[SEND] (get-info :version)+[RECV] (:version "4.5.1")+[SEND] (get-info :memory)+[RECV] unsupported+[SEND] (get-info :time)+[SKIP] ; :memory line: 71 position: 0+[RECV] unsupported+[SEND] (get-value (s0))+[SKIP] ; :time line: 72 position: 0+[RECV] ((s0 5))+[SEND] (get-value (s1))+[RECV] ((s1 1))+[GOOD] (define-fun s21 () Int 100)+[GOOD] (define-fun s23 () Int 9)+[GOOD] (define-fun s22 () Bool (> s0 s21))+[GOOD] (define-fun s24 () Bool (> s0 s23))+[GOOD] (declare-const __assumption_proxy_s22_25 Bool)+[GOOD] (assert (= __assumption_proxy_s22_25 s22))+[GOOD] (declare-const __assumption_proxy_s24_26 Bool)+[GOOD] (assert (= __assumption_proxy_s24_26 s24))+[SEND] (check-sat-assuming (__assumption_proxy_s22_25 __assumption_proxy_s24_26))+[RECV] unsat+[SEND] (get-unsat-assumptions)+[RECV] (a+b_<_12 __assumption_proxy_s22_25)+*** In call to 'getUnsatAssumptions'+***+***    Unexpected assumption named: "a+b_<_12"+***    Was expecting one of       : ["s22","s24"]+***+*** This can happen if unsat-cores are also enabled. Ignoring.+[GOOD] (push 5)+[GOOD] (pop 3)+[GOOD] (define-fun s27 () Int 6)+[GOOD] (define-fun s28 () Bool (> s0 s27))+[GOOD] (assert (! s28 :named |bey|))+[GOOD] (define-fun s29 () Bool (< s0 s27))+[GOOD] (assert (! s29 :named |hey|))+[SEND] (check-sat)+[RECV] unsat+[SEND, TimeOut: 4000ms] (get-unsat-core)+[RECV] (bey hey)+[SEND] (get-proof)+[RECV] ((set-logic ALL)+       (declare-fun bey () Bool)+       (declare-fun hey () Bool)+       (proof+       (let (($x232 (<= s0 6)))+       (let (($x233 (not $x232)))+       (let (($x236 (or (not bey) $x233)))+       (let ((@x238 (monotonicity (rewrite (= (> s0 6) $x233)) (= (or (not bey) (> s0 6)) $x236))))+       (let ((@x231 (rewrite (= (=> bey (> s0 6)) (or (not bey) (> s0 6))))))+       (let ((@x241 (mp (asserted (=> bey (> s0 6))) (trans @x231 @x238 (= (=> bey (> s0 6)) $x236)) $x236)))+       (let (($x252 (>= s0 6)))+       (let (($x250 (not $x252)))+       (let (($x254 (or (not hey) $x250)))+       (let ((@x256 (monotonicity (rewrite (= (< s0 6) $x250)) (= (or (not hey) (< s0 6)) $x254))))+       (let ((@x249 (rewrite (= (=> hey (< s0 6)) (or (not hey) (< s0 6))))))+       (let ((@x259 (mp (asserted (=> hey (< s0 6))) (trans @x249 @x256 (= (=> hey (< s0 6)) $x254)) $x254)))+       (unit-resolution ((_ th-lemma arith farkas 1 1) (or $x252 $x232)) (unit-resolution @x259 (asserted hey) $x250) (unit-resolution @x241 (asserted bey) $x233) false)))))))))))))))+[SEND, TimeOut: 6000ms] (get-assertions)++[RECV] ((! s7 :named |a > 0|)+        s8+        s12+        (! s15 :named |a+b_<_12|)+        (! s17 :named |later, a > 4|)+        (= __assumption_proxy_s18_19 s18)+        (= __assumption_proxy_s18_20 s18)+        (= __assumption_proxy_s22_25 s22)+        (= __assumption_proxy_s24_26 s24)+        (! s28 :named |bey|)+        (! s29 :named |hey|))+[SEND] (echo "there we go")+[RECV] "there we go"+*** Solver   : Z3+*** Exit code: ExitSuccess++ FINAL:Satisfiable. Model:+  a  =  332 :: Integer+  b  =    3 :: Integer+  c  =  2.3 :: Float+  d  = True :: Bool+  e  = 3.12 :: Real+  s5 =  244 :: Word8+DONE!
+ SBVTestSuite/GoldFiles/noTravis_query_abc.gold view
@@ -0,0 +1,34 @@+** Calling: abc -S "%blast; &sweep -C 5000; &syn4; &cec -s -m -C 2000"+[ISSUE] ; Automatically generated by SBV. Do not edit.+** Skipping heart-beat for the solver ABC+** Backend solver ABC does not support global decls.+** Some incremental calls, such as pop, will be limited.+[ISSUE] (set-option :diagnostic-output-channel "stdout")+[ISSUE] (set-option :produce-models true)+[ISSUE] (set-logic QF_BV)+[ISSUE] ; --- uninterpreted sorts ---+[ISSUE] ; --- literal constants ---+[ISSUE] (define-fun s_2 () Bool false)+[ISSUE] (define-fun s_1 () Bool true)+[ISSUE] (define-fun s2 () (_ BitVec 32) #x00000000)+[ISSUE] ; --- skolem constants ---+[ISSUE] (declare-fun s0 () (_ BitVec 32)) ; tracks user variable "a"+[ISSUE] (declare-fun s1 () (_ BitVec 32)) ; tracks user variable "b"+[ISSUE] ; --- constant tables ---+[ISSUE] ; --- skolemized tables ---+[ISSUE] ; --- arrays ---+[ISSUE] ; --- uninterpreted constants ---+[ISSUE] ; --- user given axioms ---+[ISSUE] ; --- formula ---+[ISSUE] (define-fun s3 () Bool (bvsgt s0 s2))+[ISSUE] (define-fun s4 () Bool (bvsgt s1 s2))+[ISSUE] (assert s3)+[ISSUE] (assert s4)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #x1))+[SEND] (get-value (s1))+[RECV] ((s1 #x1))+*** Solver   : ABC+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/noTravis_query_boolector.gold view
@@ -0,0 +1,54 @@+** Calling: boolector --smt2 --smt2-model --no-exit-codes --incremental+[GOOD] ; Automatically generated by SBV. Do not edit.+[GOOD] (set-option :print-success true)+** Backend solver Boolector does not support global decls.+** Some incremental calls, such as pop, will be limited.+[GOOD] (set-option :produce-models true)+[GOOD] (set-logic QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 32) #x00000000)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 32)) ; tracks user variable "a"+[GOOD] (declare-fun s1 () (_ BitVec 32)) ; tracks user variable "b"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s3 () Bool (bvsgt s0 s2))+[GOOD] (define-fun s4 () Bool (bvsgt s1 s2))+[GOOD] (assert s3)+[GOOD] (assert s4)+[GOOD] (define-fun s5 () (_ BitVec 32) #x00000002)+[GOOD] (define-fun s7 () (_ BitVec 32) #x0000000f)+[GOOD] (define-fun s6 () (_ BitVec 32) (bvadd s0 s5))+[GOOD] (define-fun s8 () Bool (bvsle s6 s7))+[GOOD] (assert s8)+[GOOD] (define-fun s9 () (_ BitVec 32) #x00000003)+[GOOD] (define-fun s10 () Bool (bvslt s0 s9))+[GOOD] (assert s10)+[GOOD] (define-fun s11 () Bool (bvslt s1 s5))+[GOOD] (assert s11)+[GOOD] (define-fun s13 () (_ BitVec 32) #x0000000c)+[GOOD] (define-fun s12 () (_ BitVec 32) (bvadd s0 s1))+[GOOD] (define-fun s14 () Bool (bvslt s12 s13))+[GOOD] (assert s14)+[GOOD] (define-fun s15 () Bool (bvslt s0 s5))+[GOOD] (assert s15)+[SEND] (check-sat)+[RECV] sat+[GOOD] (define-fun s16 () (_ BitVec 32) #x00000001)+[GOOD] (define-fun s17 () Bool (bvsge s0 s16))+[GOOD] (assert s17)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #b00000000000000000000000000000001))+[SEND] (get-value (s1))+[RECV] ((s1 #b00000000000000000000000000000001))+*** Solver   : Boolector+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/noTravis_query_cvc4.gold view
@@ -0,0 +1,60 @@+** Calling: cvc4 --lang smt --incremental --interactive --no-interactive-prompt+[GOOD] ; Automatically generated by SBV. Do not edit.+[GOOD] (set-option :print-success true)+[GOOD] (set-option :global-declarations true)+[GOOD] (set-option :diagnostic-output-channel "stdout")+[GOOD] (set-option :produce-models true)+[GOOD] (set-logic QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 32) #x00000000)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 32)) ; tracks user variable "a"+[GOOD] (declare-fun s1 () (_ BitVec 32)) ; tracks user variable "b"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s3 () Bool (bvsgt s0 s2))+[GOOD] (define-fun s4 () Bool (bvsgt s1 s2))+[GOOD] (assert (! s3 :named |a > 0|))+[GOOD] (assert s4)+[GOOD] (define-fun s5 () (_ BitVec 32) #x00000002)+[GOOD] (define-fun s7 () (_ BitVec 32) #x0000000f)+[GOOD] (define-fun s6 () (_ BitVec 32) (bvadd s0 s5))+[GOOD] (define-fun s8 () Bool (bvsle s6 s7))+[GOOD] (assert s8)+[GOOD] (define-fun s9 () (_ BitVec 32) #x00000003)+[GOOD] (define-fun s10 () Bool (bvslt s0 s9))+[GOOD] (assert s10)+[GOOD] (define-fun s11 () Bool (bvslt s1 s5))+[GOOD] (assert s11)+[GOOD] (define-fun s13 () (_ BitVec 32) #x0000000c)+[GOOD] (define-fun s12 () (_ BitVec 32) (bvadd s0 s1))+[GOOD] (define-fun s14 () Bool (bvslt s12 s13))+[GOOD] (assert (! s14 :named |a+b_<_12|))+[GOOD] (push 1)+[GOOD] (define-fun s15 () Bool (bvslt s0 s5))+[GOOD] (assert s15)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 (_ bv1 32)))+[GOOD] (pop 1)+[GOOD] (define-fun s16 () (_ BitVec 32) #x00000001)+[GOOD] (define-fun s17 () Bool (bvsgt s0 s16))+[GOOD] (assert (! s17 :named |extra|))+[GOOD] (assert s11)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 (_ bv2 32)))+[SEND] (get-value (s1))+[RECV] ((s1 (_ bv1 32)))+*** Solver   : CVC4+*** Exit code: ExitSuccess+*** Std-out  :
+ SBVTestSuite/GoldFiles/noTravis_query_mathsat.gold view
@@ -0,0 +1,55 @@+** 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 :diagnostic-output-channel "stdout")+[GOOD] (set-option :produce-models true)+[GOOD] (set-logic QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 32) #x00000000)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 32)) ; tracks user variable "a"+[GOOD] (declare-fun s1 () (_ BitVec 32)) ; tracks user variable "b"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s3 () Bool (bvsgt s0 s2))+[GOOD] (define-fun s4 () Bool (bvsgt s1 s2))+[GOOD] (assert (! s3 :named |a > 0|))+[GOOD] (assert s4)+[GOOD] (define-fun s5 () (_ BitVec 32) #x00000002)+[GOOD] (define-fun s7 () (_ BitVec 32) #x0000000f)+[GOOD] (define-fun s6 () (_ BitVec 32) (bvadd s0 s5))+[GOOD] (define-fun s8 () Bool (bvsle s6 s7))+[GOOD] (assert s8)+[GOOD] (define-fun s9 () (_ BitVec 32) #x00000003)+[GOOD] (define-fun s10 () Bool (bvslt s0 s9))+[GOOD] (assert s10)+[GOOD] (define-fun s11 () Bool (bvslt s1 s5))+[GOOD] (assert s11)+[GOOD] (define-fun s13 () (_ BitVec 32) #x0000000c)+[GOOD] (define-fun s12 () (_ BitVec 32) (bvadd s0 s1))+[GOOD] (define-fun s14 () Bool (bvslt s12 s13))+[GOOD] (assert (! s14 :named |a+b_<_12|))+[GOOD] (define-fun s15 () Bool (bvslt s0 s5))+[GOOD] (assert s15)+[SEND] (check-sat)+[RECV] sat+[GOOD] (define-fun s16 () (_ BitVec 32) #x00000001)+[GOOD] (define-fun s17 () Bool (bvsge s0 s16))+[GOOD] (assert (! s17 :named |extra|))+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ( (s0 (_ bv1 32)) )+[SEND] (get-value (s1))+[RECV] ( (s1 (_ bv1 32)) )+*** Solver   : MathSAT+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/noTravis_query_yices.gold view
@@ -0,0 +1,54 @@+** Calling: yices-smt2 --incremental+[GOOD] ; Automatically generated by SBV. Do not edit.+[GOOD] (set-option :print-success true)+** Backend solver Yices does not support global decls.+** Some incremental calls, such as pop, will be limited.+[GOOD] (set-option :produce-models true)+[GOOD] (set-logic QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 32) #x00000000)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 32)) ; tracks user variable "a"+[GOOD] (declare-fun s1 () (_ BitVec 32)) ; tracks user variable "b"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s3 () Bool (bvsgt s0 s2))+[GOOD] (define-fun s4 () Bool (bvsgt s1 s2))+[GOOD] (assert (! s3 :named |a > 0|))+[GOOD] (assert s4)+[GOOD] (define-fun s5 () (_ BitVec 32) #x00000002)+[GOOD] (define-fun s7 () (_ BitVec 32) #x0000000f)+[GOOD] (define-fun s6 () (_ BitVec 32) (bvadd s0 s5))+[GOOD] (define-fun s8 () Bool (bvsle s6 s7))+[GOOD] (assert s8)+[GOOD] (define-fun s9 () (_ BitVec 32) #x00000003)+[GOOD] (define-fun s10 () Bool (bvslt s0 s9))+[GOOD] (assert s10)+[GOOD] (define-fun s11 () Bool (bvslt s1 s5))+[GOOD] (assert s11)+[GOOD] (define-fun s13 () (_ BitVec 32) #x0000000c)+[GOOD] (define-fun s12 () (_ BitVec 32) (bvadd s0 s1))+[GOOD] (define-fun s14 () Bool (bvslt s12 s13))+[GOOD] (assert (! s14 :named |a+b_<_12|))+[GOOD] (define-fun s15 () Bool (bvslt s0 s5))+[GOOD] (assert s15)+[SEND] (check-sat)+[RECV] sat+[GOOD] (define-fun s16 () (_ BitVec 32) #x00000001)+[GOOD] (define-fun s17 () Bool (bvsge s0 s16))+[GOOD] (assert (! s17 :named |extra|))+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #b00000000000000000000000000000001))+[SEND] (get-value (s1))+[RECV] ((s1 #b00000000000000000000000000000001))+*** Solver   : Yices+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/optBasics1.gold view
@@ -0,0 +1,4 @@+Optimal model:+  x        = 1 :: Integer+  y        = 1 :: Integer+  x_plus_y = 2 :: Integer
+ SBVTestSuite/GoldFiles/optBasics2.gold view
@@ -0,0 +1,4 @@+Optimal model:+  x        = 2 :: Integer+  y        = 2 :: Integer+  x_plus_y = 4 :: Integer
+ SBVTestSuite/GoldFiles/optExtField1.gold view
@@ -0,0 +1,2 @@+Optimal in an extension field:+  x_plus_y = oo :: Integer
+ SBVTestSuite/GoldFiles/optExtField2.gold view
@@ -0,0 +1,2 @@+Optimal in an extension field:+  x_plus_y = -oo :: Integer
+ SBVTestSuite/GoldFiles/optExtField3.gold view
@@ -0,0 +1,2 @@+Optimal in an extension field:+  x_plus_y = 9.0 + (-2.0 * epsilon) :: Real
+ SBVTestSuite/GoldFiles/optReal1.gold view
@@ -0,0 +1,6 @@+Optimal model:+  x =  10.0 :: Real+  y =  10.0 :: Real+  z =   0.0 :: Real+  w =  20.0 :: Real+  p = 115.0 :: Real
+ SBVTestSuite/GoldFiles/pareto1.gold view
@@ -0,0 +1,180 @@+Pareto front #1: Optimal model:+  x            = 1 :: Integer+  y            = 0 :: Integer+  min_x        = 1 :: Integer+  max_x_plus_y = 1 :: Integer+  min_y        = 0 :: Integer+Pareto front #2: Optimal model:+  x            = 0 :: Integer+  y            = 2 :: Integer+  min_x        = 0 :: Integer+  max_x_plus_y = 2 :: Integer+  min_y        = 2 :: Integer+Pareto front #3: Optimal model:+  x            = 0 :: Integer+  y            = 0 :: Integer+  min_x        = 0 :: Integer+  max_x_plus_y = 0 :: Integer+  min_y        = 0 :: Integer+Pareto front #4: Optimal model:+  x            = 1 :: Integer+  y            = 2 :: Integer+  min_x        = 1 :: Integer+  max_x_plus_y = 3 :: Integer+  min_y        = 2 :: Integer+Pareto front #5: Optimal model:+  x            = 0 :: Integer+  y            = 1 :: Integer+  min_x        = 0 :: Integer+  max_x_plus_y = 1 :: Integer+  min_y        = 1 :: Integer+Pareto front #6: Optimal model:+  x            = 1 :: Integer+  y            = 1 :: Integer+  min_x        = 1 :: Integer+  max_x_plus_y = 2 :: Integer+  min_y        = 1 :: Integer+Pareto front #7: Optimal model:+  x            = 2 :: Integer+  y            = 0 :: Integer+  min_x        = 2 :: Integer+  max_x_plus_y = 2 :: Integer+  min_y        = 0 :: Integer+Pareto front #8: Optimal model:+  x            = 0 :: Integer+  y            = 4 :: Integer+  min_x        = 0 :: Integer+  max_x_plus_y = 4 :: Integer+  min_y        = 4 :: Integer+Pareto front #9: Optimal model:+  x            = 3 :: Integer+  y            = 0 :: Integer+  min_x        = 3 :: Integer+  max_x_plus_y = 3 :: Integer+  min_y        = 0 :: Integer+Pareto front #10: Optimal model:+  x            = 2 :: Integer+  y            = 1 :: Integer+  min_x        = 2 :: Integer+  max_x_plus_y = 3 :: Integer+  min_y        = 1 :: Integer+Pareto front #11: Optimal model:+  x            = 3 :: Integer+  y            = 1 :: Integer+  min_x        = 3 :: Integer+  max_x_plus_y = 4 :: Integer+  min_y        = 1 :: Integer+Pareto front #12: Optimal model:+  x            = 4 :: Integer+  y            = 0 :: Integer+  min_x        = 4 :: Integer+  max_x_plus_y = 4 :: Integer+  min_y        = 0 :: Integer+Pareto front #13: Optimal model:+  x            = 5 :: Integer+  y            = 0 :: Integer+  min_x        = 5 :: Integer+  max_x_plus_y = 5 :: Integer+  min_y        = 0 :: Integer+Pareto front #14: Optimal model:+  x            = 4 :: Integer+  y            = 1 :: Integer+  min_x        = 4 :: Integer+  max_x_plus_y = 5 :: Integer+  min_y        = 1 :: Integer+Pareto front #15: Optimal model:+  x            = 5 :: Integer+  y            = 1 :: Integer+  min_x        = 5 :: Integer+  max_x_plus_y = 6 :: Integer+  min_y        = 1 :: Integer+Pareto front #16: Optimal model:+  x            = 1 :: Integer+  y            = 4 :: Integer+  min_x        = 1 :: Integer+  max_x_plus_y = 5 :: Integer+  min_y        = 4 :: Integer+Pareto front #17: Optimal model:+  x            = 2 :: Integer+  y            = 4 :: Integer+  min_x        = 2 :: Integer+  max_x_plus_y = 6 :: Integer+  min_y        = 4 :: Integer+Pareto front #18: Optimal model:+  x            = 3 :: Integer+  y            = 4 :: Integer+  min_x        = 3 :: Integer+  max_x_plus_y = 7 :: Integer+  min_y        = 4 :: Integer+Pareto front #19: Optimal model:+  x            = 4 :: Integer+  y            = 4 :: Integer+  min_x        = 4 :: Integer+  max_x_plus_y = 8 :: Integer+  min_y        = 4 :: Integer+Pareto front #20: Optimal model:+  x            = 5 :: Integer+  y            = 4 :: Integer+  min_x        = 5 :: Integer+  max_x_plus_y = 9 :: Integer+  min_y        = 4 :: Integer+Pareto front #21: Optimal model:+  x            = 0 :: Integer+  y            = 3 :: Integer+  min_x        = 0 :: Integer+  max_x_plus_y = 3 :: Integer+  min_y        = 3 :: Integer+Pareto front #22: Optimal model:+  x            = 1 :: Integer+  y            = 3 :: Integer+  min_x        = 1 :: Integer+  max_x_plus_y = 4 :: Integer+  min_y        = 3 :: Integer+Pareto front #23: Optimal model:+  x            = 2 :: Integer+  y            = 2 :: Integer+  min_x        = 2 :: Integer+  max_x_plus_y = 4 :: Integer+  min_y        = 2 :: Integer+Pareto front #24: Optimal model:+  x            = 3 :: Integer+  y            = 2 :: Integer+  min_x        = 3 :: Integer+  max_x_plus_y = 5 :: Integer+  min_y        = 2 :: Integer+Pareto front #25: Optimal model:+  x            = 2 :: Integer+  y            = 3 :: Integer+  min_x        = 2 :: Integer+  max_x_plus_y = 5 :: Integer+  min_y        = 3 :: Integer+Pareto front #26: Optimal model:+  x            = 3 :: Integer+  y            = 3 :: Integer+  min_x        = 3 :: Integer+  max_x_plus_y = 6 :: Integer+  min_y        = 3 :: Integer+Pareto front #27: Optimal model:+  x            = 4 :: Integer+  y            = 2 :: Integer+  min_x        = 4 :: Integer+  max_x_plus_y = 6 :: Integer+  min_y        = 2 :: Integer+Pareto front #28: Optimal model:+  x            = 5 :: Integer+  y            = 2 :: Integer+  min_x        = 5 :: Integer+  max_x_plus_y = 7 :: Integer+  min_y        = 2 :: Integer+Pareto front #29: Optimal model:+  x            = 4 :: Integer+  y            = 3 :: Integer+  min_x        = 4 :: Integer+  max_x_plus_y = 7 :: Integer+  min_y        = 3 :: Integer+Pareto front #30: Optimal model:+  x            = 5 :: Integer+  y            = 3 :: Integer+  min_x        = 5 :: Integer+  max_x_plus_y = 8 :: Integer+  min_y        = 3 :: Integer
+ SBVTestSuite/GoldFiles/pareto2.gold view
@@ -0,0 +1,182 @@+Pareto front #1: Optimal model:+  x            = 0 :: Integer+  y            = 4 :: Integer+  min_x        = 0 :: Integer+  max_y        = 4 :: Integer+  max_x_plus_y = 4 :: Integer+Pareto front #2: Optimal model:+  x            = 0 :: Integer+  y            = 5 :: Integer+  min_x        = 0 :: Integer+  max_y        = 5 :: Integer+  max_x_plus_y = 5 :: Integer+Pareto front #3: Optimal model:+  x            = 0 :: Integer+  y            = 6 :: Integer+  min_x        = 0 :: Integer+  max_y        = 6 :: Integer+  max_x_plus_y = 6 :: Integer+Pareto front #4: Optimal model:+  x            = 0 :: Integer+  y            = 7 :: Integer+  min_x        = 0 :: Integer+  max_y        = 7 :: Integer+  max_x_plus_y = 7 :: Integer+Pareto front #5: Optimal model:+  x            = 0 :: Integer+  y            = 8 :: Integer+  min_x        = 0 :: Integer+  max_y        = 8 :: Integer+  max_x_plus_y = 8 :: Integer+Pareto front #6: Optimal model:+  x            = 0 :: Integer+  y            = 9 :: Integer+  min_x        = 0 :: Integer+  max_y        = 9 :: Integer+  max_x_plus_y = 9 :: Integer+Pareto front #7: Optimal model:+  x            =  0 :: Integer+  y            = 10 :: Integer+  min_x        =  0 :: Integer+  max_y        = 10 :: Integer+  max_x_plus_y = 10 :: Integer+Pareto front #8: Optimal model:+  x            =  0 :: Integer+  y            = 11 :: Integer+  min_x        =  0 :: Integer+  max_y        = 11 :: Integer+  max_x_plus_y = 11 :: Integer+Pareto front #9: Optimal model:+  x            =  0 :: Integer+  y            = 12 :: Integer+  min_x        =  0 :: Integer+  max_y        = 12 :: Integer+  max_x_plus_y = 12 :: Integer+Pareto front #10: Optimal model:+  x            =  0 :: Integer+  y            = 13 :: Integer+  min_x        =  0 :: Integer+  max_y        = 13 :: Integer+  max_x_plus_y = 13 :: Integer+Pareto front #11: Optimal model:+  x            =  0 :: Integer+  y            = 14 :: Integer+  min_x        =  0 :: Integer+  max_y        = 14 :: Integer+  max_x_plus_y = 14 :: Integer+Pareto front #12: Optimal model:+  x            =  0 :: Integer+  y            = 15 :: Integer+  min_x        =  0 :: Integer+  max_y        = 15 :: Integer+  max_x_plus_y = 15 :: Integer+Pareto front #13: Optimal model:+  x            =  0 :: Integer+  y            = 16 :: Integer+  min_x        =  0 :: Integer+  max_y        = 16 :: Integer+  max_x_plus_y = 16 :: Integer+Pareto front #14: Optimal model:+  x            =  0 :: Integer+  y            = 17 :: Integer+  min_x        =  0 :: Integer+  max_y        = 17 :: Integer+  max_x_plus_y = 17 :: Integer+Pareto front #15: Optimal model:+  x            =  0 :: Integer+  y            = 18 :: Integer+  min_x        =  0 :: Integer+  max_y        = 18 :: Integer+  max_x_plus_y = 18 :: Integer+Pareto front #16: Optimal model:+  x            =  0 :: Integer+  y            = 19 :: Integer+  min_x        =  0 :: Integer+  max_y        = 19 :: Integer+  max_x_plus_y = 19 :: Integer+Pareto front #17: Optimal model:+  x            =  0 :: Integer+  y            = 20 :: Integer+  min_x        =  0 :: Integer+  max_y        = 20 :: Integer+  max_x_plus_y = 20 :: Integer+Pareto front #18: Optimal model:+  x            =  0 :: Integer+  y            = 21 :: Integer+  min_x        =  0 :: Integer+  max_y        = 21 :: Integer+  max_x_plus_y = 21 :: Integer+Pareto front #19: Optimal model:+  x            =  0 :: Integer+  y            = 22 :: Integer+  min_x        =  0 :: Integer+  max_y        = 22 :: Integer+  max_x_plus_y = 22 :: Integer+Pareto front #20: Optimal model:+  x            =  0 :: Integer+  y            = 23 :: Integer+  min_x        =  0 :: Integer+  max_y        = 23 :: Integer+  max_x_plus_y = 23 :: Integer+Pareto front #21: Optimal model:+  x            =  0 :: Integer+  y            = 24 :: Integer+  min_x        =  0 :: Integer+  max_y        = 24 :: Integer+  max_x_plus_y = 24 :: Integer+Pareto front #22: Optimal model:+  x            =  0 :: Integer+  y            = 25 :: Integer+  min_x        =  0 :: Integer+  max_y        = 25 :: Integer+  max_x_plus_y = 25 :: Integer+Pareto front #23: Optimal model:+  x            =  0 :: Integer+  y            = 26 :: Integer+  min_x        =  0 :: Integer+  max_y        = 26 :: Integer+  max_x_plus_y = 26 :: Integer+Pareto front #24: Optimal model:+  x            =  0 :: Integer+  y            = 27 :: Integer+  min_x        =  0 :: Integer+  max_y        = 27 :: Integer+  max_x_plus_y = 27 :: Integer+Pareto front #25: Optimal model:+  x            =  0 :: Integer+  y            = 28 :: Integer+  min_x        =  0 :: Integer+  max_y        = 28 :: Integer+  max_x_plus_y = 28 :: Integer+Pareto front #26: Optimal model:+  x            =  0 :: Integer+  y            = 29 :: Integer+  min_x        =  0 :: Integer+  max_y        = 29 :: Integer+  max_x_plus_y = 29 :: Integer+Pareto front #27: Optimal model:+  x            =  0 :: Integer+  y            = 30 :: Integer+  min_x        =  0 :: Integer+  max_y        = 30 :: Integer+  max_x_plus_y = 30 :: Integer+Pareto front #28: Optimal model:+  x            =  0 :: Integer+  y            = 31 :: Integer+  min_x        =  0 :: Integer+  max_y        = 31 :: Integer+  max_x_plus_y = 31 :: Integer+Pareto front #29: Optimal model:+  x            =  0 :: Integer+  y            = 32 :: Integer+  min_x        =  0 :: Integer+  max_y        = 32 :: Integer+  max_x_plus_y = 32 :: Integer+Pareto front #30: Optimal model:+  x            =  0 :: Integer+  y            = 33 :: Integer+  min_x        =  0 :: Integer+  max_y        = 33 :: Integer+  max_x_plus_y = 33 :: Integer+*** Note: Pareto-front extraction was terminated before stream was ended as requested by the user.+***       There might be other (potentially infinitely more) results.
+ SBVTestSuite/GoldFiles/pbAtLeast.gold view
@@ -0,0 +1,60 @@+** 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] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s11 () (_ BitVec 32) #x00000001)+[GOOD] (define-fun s12 () (_ BitVec 32) #x00000000)+[GOOD] (define-fun s32 () (_ BitVec 32) #x00000005)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () Bool) ; tracks user variable "b0"+[GOOD] (declare-fun s1 () Bool) ; tracks user variable "b1"+[GOOD] (declare-fun s2 () Bool) ; tracks user variable "b2"+[GOOD] (declare-fun s3 () Bool) ; tracks user variable "b3"+[GOOD] (declare-fun s4 () Bool) ; tracks user variable "b4"+[GOOD] (declare-fun s5 () Bool) ; tracks user variable "b5"+[GOOD] (declare-fun s6 () Bool) ; tracks user variable "b6"+[GOOD] (declare-fun s7 () Bool) ; tracks user variable "b7"+[GOOD] (declare-fun s8 () Bool) ; tracks user variable "b8"+[GOOD] (declare-fun s9 () Bool) ; tracks user variable "b9"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s10 () Bool ((_ at-least 5) s0 s1 s2 s3 s4 s5 s6 s7 s8 s9))+[GOOD] (define-fun s13 () (_ BitVec 32) (ite s0 s11 s12))+[GOOD] (define-fun s14 () (_ BitVec 32) (ite s1 s11 s12))+[GOOD] (define-fun s15 () (_ BitVec 32) (bvadd s13 s14))+[GOOD] (define-fun s16 () (_ BitVec 32) (ite s2 s11 s12))+[GOOD] (define-fun s17 () (_ BitVec 32) (bvadd s15 s16))+[GOOD] (define-fun s18 () (_ BitVec 32) (ite s3 s11 s12))+[GOOD] (define-fun s19 () (_ BitVec 32) (bvadd s17 s18))+[GOOD] (define-fun s20 () (_ BitVec 32) (ite s4 s11 s12))+[GOOD] (define-fun s21 () (_ BitVec 32) (bvadd s19 s20))+[GOOD] (define-fun s22 () (_ BitVec 32) (ite s5 s11 s12))+[GOOD] (define-fun s23 () (_ BitVec 32) (bvadd s21 s22))+[GOOD] (define-fun s24 () (_ BitVec 32) (ite s6 s11 s12))+[GOOD] (define-fun s25 () (_ BitVec 32) (bvadd s23 s24))+[GOOD] (define-fun s26 () (_ BitVec 32) (ite s7 s11 s12))+[GOOD] (define-fun s27 () (_ BitVec 32) (bvadd s25 s26))+[GOOD] (define-fun s28 () (_ BitVec 32) (ite s8 s11 s12))+[GOOD] (define-fun s29 () (_ BitVec 32) (bvadd s27 s28))+[GOOD] (define-fun s30 () (_ BitVec 32) (ite s9 s11 s12))+[GOOD] (define-fun s31 () (_ BitVec 32) (bvadd s29 s30))+[GOOD] (define-fun s33 () Bool (bvuge s31 s32))+[GOOD] (define-fun s34 () Bool (= s10 s33))+[GOOD] (define-fun s35 () Bool (not s34))+[GOOD] (assert s35)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/pbAtMost.gold view
@@ -0,0 +1,60 @@+** 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] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s11 () (_ BitVec 32) #x00000001)+[GOOD] (define-fun s12 () (_ BitVec 32) #x00000000)+[GOOD] (define-fun s32 () (_ BitVec 32) #x00000008)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () Bool) ; tracks user variable "b0"+[GOOD] (declare-fun s1 () Bool) ; tracks user variable "b1"+[GOOD] (declare-fun s2 () Bool) ; tracks user variable "b2"+[GOOD] (declare-fun s3 () Bool) ; tracks user variable "b3"+[GOOD] (declare-fun s4 () Bool) ; tracks user variable "b4"+[GOOD] (declare-fun s5 () Bool) ; tracks user variable "b5"+[GOOD] (declare-fun s6 () Bool) ; tracks user variable "b6"+[GOOD] (declare-fun s7 () Bool) ; tracks user variable "b7"+[GOOD] (declare-fun s8 () Bool) ; tracks user variable "b8"+[GOOD] (declare-fun s9 () Bool) ; tracks user variable "b9"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s10 () Bool ((_ at-most 8) s0 s1 s2 s3 s4 s5 s6 s7 s8 s9))+[GOOD] (define-fun s13 () (_ BitVec 32) (ite s0 s11 s12))+[GOOD] (define-fun s14 () (_ BitVec 32) (ite s1 s11 s12))+[GOOD] (define-fun s15 () (_ BitVec 32) (bvadd s13 s14))+[GOOD] (define-fun s16 () (_ BitVec 32) (ite s2 s11 s12))+[GOOD] (define-fun s17 () (_ BitVec 32) (bvadd s15 s16))+[GOOD] (define-fun s18 () (_ BitVec 32) (ite s3 s11 s12))+[GOOD] (define-fun s19 () (_ BitVec 32) (bvadd s17 s18))+[GOOD] (define-fun s20 () (_ BitVec 32) (ite s4 s11 s12))+[GOOD] (define-fun s21 () (_ BitVec 32) (bvadd s19 s20))+[GOOD] (define-fun s22 () (_ BitVec 32) (ite s5 s11 s12))+[GOOD] (define-fun s23 () (_ BitVec 32) (bvadd s21 s22))+[GOOD] (define-fun s24 () (_ BitVec 32) (ite s6 s11 s12))+[GOOD] (define-fun s25 () (_ BitVec 32) (bvadd s23 s24))+[GOOD] (define-fun s26 () (_ BitVec 32) (ite s7 s11 s12))+[GOOD] (define-fun s27 () (_ BitVec 32) (bvadd s25 s26))+[GOOD] (define-fun s28 () (_ BitVec 32) (ite s8 s11 s12))+[GOOD] (define-fun s29 () (_ BitVec 32) (bvadd s27 s28))+[GOOD] (define-fun s30 () (_ BitVec 32) (ite s9 s11 s12))+[GOOD] (define-fun s31 () (_ BitVec 32) (bvadd s29 s30))+[GOOD] (define-fun s33 () Bool (bvule s31 s32))+[GOOD] (define-fun s34 () Bool (= s10 s33))+[GOOD] (define-fun s35 () Bool (not s34))+[GOOD] (assert s35)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/pbEq.gold view
@@ -0,0 +1,68 @@+** 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] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s11 () Int 1)+[GOOD] (define-fun s12 () Int 0)+[GOOD] (define-fun s14 () Int 2)+[GOOD] (define-fun s17 () Int 3)+[GOOD] (define-fun s20 () Int 4)+[GOOD] (define-fun s23 () Int 5)+[GOOD] (define-fun s26 () Int 6)+[GOOD] (define-fun s29 () Int 7)+[GOOD] (define-fun s32 () Int 8)+[GOOD] (define-fun s35 () Int 9)+[GOOD] (define-fun s38 () Int 10)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () Bool) ; tracks user variable "b0"+[GOOD] (declare-fun s1 () Bool) ; tracks user variable "b1"+[GOOD] (declare-fun s2 () Bool) ; tracks user variable "b2"+[GOOD] (declare-fun s3 () Bool) ; tracks user variable "b3"+[GOOD] (declare-fun s4 () Bool) ; tracks user variable "b4"+[GOOD] (declare-fun s5 () Bool) ; tracks user variable "b5"+[GOOD] (declare-fun s6 () Bool) ; tracks user variable "b6"+[GOOD] (declare-fun s7 () Bool) ; tracks user variable "b7"+[GOOD] (declare-fun s8 () Bool) ; tracks user variable "b8"+[GOOD] (declare-fun s9 () Bool) ; tracks user variable "b9"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s10 () Bool ((_ pbeq 7 1 2 3 4 5 6 7 8 9 10) s0 s1 s2 s3 s4 s5 s6 s7 s8 s9))+[GOOD] (define-fun s13 () Int (ite s0 s11 s12))+[GOOD] (define-fun s15 () Int (ite s1 s14 s12))+[GOOD] (define-fun s16 () Int (+ s13 s15))+[GOOD] (define-fun s18 () Int (ite s2 s17 s12))+[GOOD] (define-fun s19 () Int (+ s16 s18))+[GOOD] (define-fun s21 () Int (ite s3 s20 s12))+[GOOD] (define-fun s22 () Int (+ s19 s21))+[GOOD] (define-fun s24 () Int (ite s4 s23 s12))+[GOOD] (define-fun s25 () Int (+ s22 s24))+[GOOD] (define-fun s27 () Int (ite s5 s26 s12))+[GOOD] (define-fun s28 () Int (+ s25 s27))+[GOOD] (define-fun s30 () Int (ite s6 s29 s12))+[GOOD] (define-fun s31 () Int (+ s28 s30))+[GOOD] (define-fun s33 () Int (ite s7 s32 s12))+[GOOD] (define-fun s34 () Int (+ s31 s33))+[GOOD] (define-fun s36 () Int (ite s8 s35 s12))+[GOOD] (define-fun s37 () Int (+ s34 s36))+[GOOD] (define-fun s39 () Int (ite s9 s38 s12))+[GOOD] (define-fun s40 () Int (+ s37 s39))+[GOOD] (define-fun s41 () Bool (= s29 s40))+[GOOD] (define-fun s42 () Bool (= s10 s41))+[GOOD] (define-fun s43 () Bool (not s42))+[GOOD] (assert s43)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/pbExactly.gold view
@@ -0,0 +1,60 @@+** 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] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s11 () (_ BitVec 32) #x00000001)+[GOOD] (define-fun s12 () (_ BitVec 32) #x00000000)+[GOOD] (define-fun s32 () (_ BitVec 32) #x00000005)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () Bool) ; tracks user variable "b0"+[GOOD] (declare-fun s1 () Bool) ; tracks user variable "b1"+[GOOD] (declare-fun s2 () Bool) ; tracks user variable "b2"+[GOOD] (declare-fun s3 () Bool) ; tracks user variable "b3"+[GOOD] (declare-fun s4 () Bool) ; tracks user variable "b4"+[GOOD] (declare-fun s5 () Bool) ; tracks user variable "b5"+[GOOD] (declare-fun s6 () Bool) ; tracks user variable "b6"+[GOOD] (declare-fun s7 () Bool) ; tracks user variable "b7"+[GOOD] (declare-fun s8 () Bool) ; tracks user variable "b8"+[GOOD] (declare-fun s9 () Bool) ; tracks user variable "b9"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s10 () Bool ((_ pbeq 5 1 1 1 1 1 1 1 1 1 1) s0 s1 s2 s3 s4 s5 s6 s7 s8 s9))+[GOOD] (define-fun s13 () (_ BitVec 32) (ite s0 s11 s12))+[GOOD] (define-fun s14 () (_ BitVec 32) (ite s1 s11 s12))+[GOOD] (define-fun s15 () (_ BitVec 32) (bvadd s13 s14))+[GOOD] (define-fun s16 () (_ BitVec 32) (ite s2 s11 s12))+[GOOD] (define-fun s17 () (_ BitVec 32) (bvadd s15 s16))+[GOOD] (define-fun s18 () (_ BitVec 32) (ite s3 s11 s12))+[GOOD] (define-fun s19 () (_ BitVec 32) (bvadd s17 s18))+[GOOD] (define-fun s20 () (_ BitVec 32) (ite s4 s11 s12))+[GOOD] (define-fun s21 () (_ BitVec 32) (bvadd s19 s20))+[GOOD] (define-fun s22 () (_ BitVec 32) (ite s5 s11 s12))+[GOOD] (define-fun s23 () (_ BitVec 32) (bvadd s21 s22))+[GOOD] (define-fun s24 () (_ BitVec 32) (ite s6 s11 s12))+[GOOD] (define-fun s25 () (_ BitVec 32) (bvadd s23 s24))+[GOOD] (define-fun s26 () (_ BitVec 32) (ite s7 s11 s12))+[GOOD] (define-fun s27 () (_ BitVec 32) (bvadd s25 s26))+[GOOD] (define-fun s28 () (_ BitVec 32) (ite s8 s11 s12))+[GOOD] (define-fun s29 () (_ BitVec 32) (bvadd s27 s28))+[GOOD] (define-fun s30 () (_ BitVec 32) (ite s9 s11 s12))+[GOOD] (define-fun s31 () (_ BitVec 32) (bvadd s29 s30))+[GOOD] (define-fun s33 () Bool (= s31 s32))+[GOOD] (define-fun s34 () Bool (= s10 s33))+[GOOD] (define-fun s35 () Bool (not s34))+[GOOD] (assert s35)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/pbGe.gold view
@@ -0,0 +1,68 @@+** 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] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s11 () Int 1)+[GOOD] (define-fun s12 () Int 0)+[GOOD] (define-fun s14 () Int 2)+[GOOD] (define-fun s17 () Int 3)+[GOOD] (define-fun s20 () Int 4)+[GOOD] (define-fun s23 () Int 5)+[GOOD] (define-fun s26 () Int 6)+[GOOD] (define-fun s29 () Int 7)+[GOOD] (define-fun s32 () Int 8)+[GOOD] (define-fun s35 () Int 9)+[GOOD] (define-fun s38 () Int 10)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () Bool) ; tracks user variable "b0"+[GOOD] (declare-fun s1 () Bool) ; tracks user variable "b1"+[GOOD] (declare-fun s2 () Bool) ; tracks user variable "b2"+[GOOD] (declare-fun s3 () Bool) ; tracks user variable "b3"+[GOOD] (declare-fun s4 () Bool) ; tracks user variable "b4"+[GOOD] (declare-fun s5 () Bool) ; tracks user variable "b5"+[GOOD] (declare-fun s6 () Bool) ; tracks user variable "b6"+[GOOD] (declare-fun s7 () Bool) ; tracks user variable "b7"+[GOOD] (declare-fun s8 () Bool) ; tracks user variable "b8"+[GOOD] (declare-fun s9 () Bool) ; tracks user variable "b9"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s10 () Bool ((_ pbge 7 1 2 3 4 5 6 7 8 9 10) s0 s1 s2 s3 s4 s5 s6 s7 s8 s9))+[GOOD] (define-fun s13 () Int (ite s0 s11 s12))+[GOOD] (define-fun s15 () Int (ite s1 s14 s12))+[GOOD] (define-fun s16 () Int (+ s13 s15))+[GOOD] (define-fun s18 () Int (ite s2 s17 s12))+[GOOD] (define-fun s19 () Int (+ s16 s18))+[GOOD] (define-fun s21 () Int (ite s3 s20 s12))+[GOOD] (define-fun s22 () Int (+ s19 s21))+[GOOD] (define-fun s24 () Int (ite s4 s23 s12))+[GOOD] (define-fun s25 () Int (+ s22 s24))+[GOOD] (define-fun s27 () Int (ite s5 s26 s12))+[GOOD] (define-fun s28 () Int (+ s25 s27))+[GOOD] (define-fun s30 () Int (ite s6 s29 s12))+[GOOD] (define-fun s31 () Int (+ s28 s30))+[GOOD] (define-fun s33 () Int (ite s7 s32 s12))+[GOOD] (define-fun s34 () Int (+ s31 s33))+[GOOD] (define-fun s36 () Int (ite s8 s35 s12))+[GOOD] (define-fun s37 () Int (+ s34 s36))+[GOOD] (define-fun s39 () Int (ite s9 s38 s12))+[GOOD] (define-fun s40 () Int (+ s37 s39))+[GOOD] (define-fun s41 () Bool (>= s40 s29))+[GOOD] (define-fun s42 () Bool (= s10 s41))+[GOOD] (define-fun s43 () Bool (not s42))+[GOOD] (assert s43)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/pbLe.gold view
@@ -0,0 +1,68 @@+** 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] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s11 () Int 1)+[GOOD] (define-fun s12 () Int 0)+[GOOD] (define-fun s14 () Int 2)+[GOOD] (define-fun s17 () Int 3)+[GOOD] (define-fun s20 () Int 4)+[GOOD] (define-fun s23 () Int 5)+[GOOD] (define-fun s26 () Int 6)+[GOOD] (define-fun s29 () Int 7)+[GOOD] (define-fun s32 () Int 8)+[GOOD] (define-fun s35 () Int 9)+[GOOD] (define-fun s38 () Int 10)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () Bool) ; tracks user variable "b0"+[GOOD] (declare-fun s1 () Bool) ; tracks user variable "b1"+[GOOD] (declare-fun s2 () Bool) ; tracks user variable "b2"+[GOOD] (declare-fun s3 () Bool) ; tracks user variable "b3"+[GOOD] (declare-fun s4 () Bool) ; tracks user variable "b4"+[GOOD] (declare-fun s5 () Bool) ; tracks user variable "b5"+[GOOD] (declare-fun s6 () Bool) ; tracks user variable "b6"+[GOOD] (declare-fun s7 () Bool) ; tracks user variable "b7"+[GOOD] (declare-fun s8 () Bool) ; tracks user variable "b8"+[GOOD] (declare-fun s9 () Bool) ; tracks user variable "b9"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s10 () Bool ((_ pble 7 1 2 3 4 5 6 7 8 9 10) s0 s1 s2 s3 s4 s5 s6 s7 s8 s9))+[GOOD] (define-fun s13 () Int (ite s0 s11 s12))+[GOOD] (define-fun s15 () Int (ite s1 s14 s12))+[GOOD] (define-fun s16 () Int (+ s13 s15))+[GOOD] (define-fun s18 () Int (ite s2 s17 s12))+[GOOD] (define-fun s19 () Int (+ s16 s18))+[GOOD] (define-fun s21 () Int (ite s3 s20 s12))+[GOOD] (define-fun s22 () Int (+ s19 s21))+[GOOD] (define-fun s24 () Int (ite s4 s23 s12))+[GOOD] (define-fun s25 () Int (+ s22 s24))+[GOOD] (define-fun s27 () Int (ite s5 s26 s12))+[GOOD] (define-fun s28 () Int (+ s25 s27))+[GOOD] (define-fun s30 () Int (ite s6 s29 s12))+[GOOD] (define-fun s31 () Int (+ s28 s30))+[GOOD] (define-fun s33 () Int (ite s7 s32 s12))+[GOOD] (define-fun s34 () Int (+ s31 s33))+[GOOD] (define-fun s36 () Int (ite s8 s35 s12))+[GOOD] (define-fun s37 () Int (+ s34 s36))+[GOOD] (define-fun s39 () Int (ite s9 s38 s12))+[GOOD] (define-fun s40 () Int (+ s37 s39))+[GOOD] (define-fun s41 () Bool (<= s40 s29))+[GOOD] (define-fun s42 () Bool (= s10 s41))+[GOOD] (define-fun s43 () Bool (not s42))+[GOOD] (assert s43)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/pbMutexed.gold view
@@ -0,0 +1,59 @@+** 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] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s11 () (_ BitVec 32) #x00000001)+[GOOD] (define-fun s12 () (_ BitVec 32) #x00000000)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () Bool) ; tracks user variable "b0"+[GOOD] (declare-fun s1 () Bool) ; tracks user variable "b1"+[GOOD] (declare-fun s2 () Bool) ; tracks user variable "b2"+[GOOD] (declare-fun s3 () Bool) ; tracks user variable "b3"+[GOOD] (declare-fun s4 () Bool) ; tracks user variable "b4"+[GOOD] (declare-fun s5 () Bool) ; tracks user variable "b5"+[GOOD] (declare-fun s6 () Bool) ; tracks user variable "b6"+[GOOD] (declare-fun s7 () Bool) ; tracks user variable "b7"+[GOOD] (declare-fun s8 () Bool) ; tracks user variable "b8"+[GOOD] (declare-fun s9 () Bool) ; tracks user variable "b9"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s10 () Bool ((_ at-most 1) s0 s1 s2 s3 s4 s5 s6 s7 s8 s9))+[GOOD] (define-fun s13 () (_ BitVec 32) (ite s0 s11 s12))+[GOOD] (define-fun s14 () (_ BitVec 32) (ite s1 s11 s12))+[GOOD] (define-fun s15 () (_ BitVec 32) (bvadd s13 s14))+[GOOD] (define-fun s16 () (_ BitVec 32) (ite s2 s11 s12))+[GOOD] (define-fun s17 () (_ BitVec 32) (bvadd s15 s16))+[GOOD] (define-fun s18 () (_ BitVec 32) (ite s3 s11 s12))+[GOOD] (define-fun s19 () (_ BitVec 32) (bvadd s17 s18))+[GOOD] (define-fun s20 () (_ BitVec 32) (ite s4 s11 s12))+[GOOD] (define-fun s21 () (_ BitVec 32) (bvadd s19 s20))+[GOOD] (define-fun s22 () (_ BitVec 32) (ite s5 s11 s12))+[GOOD] (define-fun s23 () (_ BitVec 32) (bvadd s21 s22))+[GOOD] (define-fun s24 () (_ BitVec 32) (ite s6 s11 s12))+[GOOD] (define-fun s25 () (_ BitVec 32) (bvadd s23 s24))+[GOOD] (define-fun s26 () (_ BitVec 32) (ite s7 s11 s12))+[GOOD] (define-fun s27 () (_ BitVec 32) (bvadd s25 s26))+[GOOD] (define-fun s28 () (_ BitVec 32) (ite s8 s11 s12))+[GOOD] (define-fun s29 () (_ BitVec 32) (bvadd s27 s28))+[GOOD] (define-fun s30 () (_ BitVec 32) (ite s9 s11 s12))+[GOOD] (define-fun s31 () (_ BitVec 32) (bvadd s29 s30))+[GOOD] (define-fun s32 () Bool (bvule s31 s11))+[GOOD] (define-fun s33 () Bool (= s10 s32))+[GOOD] (define-fun s34 () Bool (not s33))+[GOOD] (assert s34)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/pbStronglyMutexed.gold view
@@ -0,0 +1,59 @@+** 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] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s11 () (_ BitVec 32) #x00000001)+[GOOD] (define-fun s12 () (_ BitVec 32) #x00000000)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () Bool) ; tracks user variable "b0"+[GOOD] (declare-fun s1 () Bool) ; tracks user variable "b1"+[GOOD] (declare-fun s2 () Bool) ; tracks user variable "b2"+[GOOD] (declare-fun s3 () Bool) ; tracks user variable "b3"+[GOOD] (declare-fun s4 () Bool) ; tracks user variable "b4"+[GOOD] (declare-fun s5 () Bool) ; tracks user variable "b5"+[GOOD] (declare-fun s6 () Bool) ; tracks user variable "b6"+[GOOD] (declare-fun s7 () Bool) ; tracks user variable "b7"+[GOOD] (declare-fun s8 () Bool) ; tracks user variable "b8"+[GOOD] (declare-fun s9 () Bool) ; tracks user variable "b9"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s10 () Bool ((_ pbeq 1 1 1 1 1 1 1 1 1 1 1) s0 s1 s2 s3 s4 s5 s6 s7 s8 s9))+[GOOD] (define-fun s13 () (_ BitVec 32) (ite s0 s11 s12))+[GOOD] (define-fun s14 () (_ BitVec 32) (ite s1 s11 s12))+[GOOD] (define-fun s15 () (_ BitVec 32) (bvadd s13 s14))+[GOOD] (define-fun s16 () (_ BitVec 32) (ite s2 s11 s12))+[GOOD] (define-fun s17 () (_ BitVec 32) (bvadd s15 s16))+[GOOD] (define-fun s18 () (_ BitVec 32) (ite s3 s11 s12))+[GOOD] (define-fun s19 () (_ BitVec 32) (bvadd s17 s18))+[GOOD] (define-fun s20 () (_ BitVec 32) (ite s4 s11 s12))+[GOOD] (define-fun s21 () (_ BitVec 32) (bvadd s19 s20))+[GOOD] (define-fun s22 () (_ BitVec 32) (ite s5 s11 s12))+[GOOD] (define-fun s23 () (_ BitVec 32) (bvadd s21 s22))+[GOOD] (define-fun s24 () (_ BitVec 32) (ite s6 s11 s12))+[GOOD] (define-fun s25 () (_ BitVec 32) (bvadd s23 s24))+[GOOD] (define-fun s26 () (_ BitVec 32) (ite s7 s11 s12))+[GOOD] (define-fun s27 () (_ BitVec 32) (bvadd s25 s26))+[GOOD] (define-fun s28 () (_ BitVec 32) (ite s8 s11 s12))+[GOOD] (define-fun s29 () (_ BitVec 32) (bvadd s27 s28))+[GOOD] (define-fun s30 () (_ BitVec 32) (ite s9 s11 s12))+[GOOD] (define-fun s31 () (_ BitVec 32) (bvadd s29 s30))+[GOOD] (define-fun s32 () Bool (= s11 s31))+[GOOD] (define-fun s33 () Bool (= s10 s32))+[GOOD] (define-fun s34 () Bool (not s33))+[GOOD] (assert s34)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/popCount1.gold view
@@ -0,0 +1,138 @@+== BEGIN: "Makefile" ================+# Makefile for popCount. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: popCount_driver++popCount.o: popCount.c popCount.h+	${CC} ${CCFLAGS} -c $< -o $@++popCount_driver.o: popCount_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++popCount_driver: popCount.o popCount_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f popCount_driver+== END: "Makefile" ==================+== BEGIN: "popCount.h" ================+/* Header file for popCount. Automatically generated by SBV. Do not edit! */++#ifndef __popCount__HEADER_INCLUDED__+#define __popCount__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+SWord8 popCount(const SWord64 x);++#endif /* __popCount__HEADER_INCLUDED__ */+== END: "popCount.h" ==================+== BEGIN: "popCount_driver.c" ================+/* Example driver program for popCount. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "popCount.h"++int main(void)+{+  const SWord8 __result = popCount(0x0123456789abcdefULL);++  printf("popCount(0x0123456789abcdefULL) = %"PRIu8"\n", __result);++  return 0;+}+== END: "popCount_driver.c" ==================+== BEGIN: "popCount.c" ================+/* File: "popCount.c". Automatically generated by SBV. Do not edit! */++#include "popCount.h"++SWord8 popCount(const SWord64 x)+{+  const SWord64 s0 = x;+  static const SWord8 table0[] = {+      0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3,+      3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4,+      3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2,+      2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5,+      3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5,+      5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3,+      2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4,+      4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,+      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4,+      4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6,+      5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5,+      5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8+  };+  const SWord64 s11 = s0 & 0x00000000000000ffULL;+  const SWord8  s12 = table0[s11];+  const SWord64 s13 = s0 >> 8;+  const SWord64 s14 = 0x00000000000000ffULL & s13;+  const SWord8  s15 = table0[s14];+  const SWord8  s16 = s12 + s15;+  const SWord64 s17 = s13 >> 8;+  const SWord64 s18 = 0x00000000000000ffULL & s17;+  const SWord8  s19 = table0[s18];+  const SWord8  s20 = s16 + s19;+  const SWord64 s21 = s17 >> 8;+  const SWord64 s22 = 0x00000000000000ffULL & s21;+  const SWord8  s23 = table0[s22];+  const SWord8  s24 = s20 + s23;+  const SWord64 s25 = s21 >> 8;+  const SWord64 s26 = 0x00000000000000ffULL & s25;+  const SWord8  s27 = table0[s26];+  const SWord8  s28 = s24 + s27;+  const SWord64 s29 = s25 >> 8;+  const SWord64 s30 = 0x00000000000000ffULL & s29;+  const SWord8  s31 = table0[s30];+  const SWord8  s32 = s28 + s31;+  const SWord64 s33 = s29 >> 8;+  const SWord64 s34 = 0x00000000000000ffULL & s33;+  const SWord8  s35 = table0[s34];+  const SWord8  s36 = s32 + s35;+  const SWord64 s37 = s33 >> 8;+  const SWord64 s38 = 0x00000000000000ffULL & s37;+  const SWord8  s39 = table0[s38];+  const SWord8  s40 = s36 + s39;++  return s40;+}+== END: "popCount.c" ==================
+ SBVTestSuite/GoldFiles/popCount2.gold view
@@ -0,0 +1,138 @@+== BEGIN: "Makefile" ================+# Makefile for popCount. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: popCount_driver++popCount.o: popCount.c popCount.h+	${CC} ${CCFLAGS} -c $< -o $@++popCount_driver.o: popCount_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++popCount_driver: popCount.o popCount_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f popCount_driver+== END: "Makefile" ==================+== BEGIN: "popCount.h" ================+/* Header file for popCount. Automatically generated by SBV. Do not edit! */++#ifndef __popCount__HEADER_INCLUDED__+#define __popCount__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+SWord8 popCount(const SWord64 x);++#endif /* __popCount__HEADER_INCLUDED__ */+== END: "popCount.h" ==================+== BEGIN: "popCount_driver.c" ================+/* Example driver program for popCount. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "popCount.h"++int main(void)+{+  const SWord8 __result = popCount(0x0123456789abcdefULL);++  printf("popCount(0x0123456789abcdefULL) = %"PRIu8"\n", __result);++  return 0;+}+== END: "popCount_driver.c" ==================+== BEGIN: "popCount.c" ================+/* File: "popCount.c". Automatically generated by SBV. Do not edit! */++#include "popCount.h"++SWord8 popCount(const SWord64 x)+{+  const SWord64 s0 = x;+  static const SWord8 table0[] = {+      0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3,+      3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4,+      3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2,+      2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5,+      3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5,+      5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3,+      2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4,+      4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,+      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4,+      4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6,+      5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5,+      5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8+  };+  const SWord64 s11 = s0 & 0x00000000000000ffULL;+  const SWord8  s12 = s11 >= 256 ? 0 : table0[s11];+  const SWord64 s13 = s0 >> 8;+  const SWord64 s14 = 0x00000000000000ffULL & s13;+  const SWord8  s15 = s14 >= 256 ? 0 : table0[s14];+  const SWord8  s16 = s12 + s15;+  const SWord64 s17 = s13 >> 8;+  const SWord64 s18 = 0x00000000000000ffULL & s17;+  const SWord8  s19 = s18 >= 256 ? 0 : table0[s18];+  const SWord8  s20 = s16 + s19;+  const SWord64 s21 = s17 >> 8;+  const SWord64 s22 = 0x00000000000000ffULL & s21;+  const SWord8  s23 = s22 >= 256 ? 0 : table0[s22];+  const SWord8  s24 = s20 + s23;+  const SWord64 s25 = s21 >> 8;+  const SWord64 s26 = 0x00000000000000ffULL & s25;+  const SWord8  s27 = s26 >= 256 ? 0 : table0[s26];+  const SWord8  s28 = s24 + s27;+  const SWord64 s29 = s25 >> 8;+  const SWord64 s30 = 0x00000000000000ffULL & s29;+  const SWord8  s31 = s30 >= 256 ? 0 : table0[s30];+  const SWord8  s32 = s28 + s31;+  const SWord64 s33 = s29 >> 8;+  const SWord64 s34 = 0x00000000000000ffULL & s33;+  const SWord8  s35 = s34 >= 256 ? 0 : table0[s34];+  const SWord8  s36 = s32 + s35;+  const SWord64 s37 = s33 >> 8;+  const SWord64 s38 = 0x00000000000000ffULL & s37;+  const SWord8  s39 = s38 >= 256 ? 0 : table0[s38];+  const SWord8  s40 = s36 + s39;++  return s40;+}+== END: "popCount.c" ==================
+ SBVTestSuite/GoldFiles/qEnum1.gold view
@@ -0,0 +1,42 @@+** 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-datatypes () ((BinOp (Plus) (Minus) (Times))))+[GOOD] (define-fun BinOp_constrIndex ((x BinOp)) Int+          (ite (= x Plus) 0 (ite (= x Minus) 1 2))+       )+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () BinOp) ; tracks user variable "p"+[GOOD] (declare-fun s1 () BinOp) ; tracks user variable "m"+[GOOD] (declare-fun s2 () BinOp) ; tracks user variable "t"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s3 () Bool (<= (BinOp_constrIndex s0) (BinOp_constrIndex s1)))+[GOOD] (define-fun s4 () Bool (<= (BinOp_constrIndex s1) (BinOp_constrIndex s2)))+[GOOD] (define-fun s5 () Bool (distinct s0 s1 s2))+[GOOD] (assert s3)+[GOOD] (assert s4)+[GOOD] (assert s5)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 Plus))+[SEND] (get-value (s1))+[RECV] ((s1 Minus))+[SEND] (get-value (s2))+[RECV] ((s2 Times))+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/qUninterp1.gold view
@@ -0,0 +1,31 @@+** 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 L 0)  ; N.B. Uninterpreted: L.B: not a nullary constructor+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () L)+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert s_1)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 L!val!0))+*** Solver   : Z3+*** Exit code: ExitSuccess++ FINAL:L!val!0+DONE!
+ SBVTestSuite/GoldFiles/quantified_prove_existsexists_contradiction_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s2 (= s0 s1)))+                   (let ((s3 (distinct s0 s1)))+                   (let ((s4 (and s2 s3)))+                   (and s4 s_2))))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_existsexists_contradiction_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s2 (= s0 s1)))+                   (let ((s3 (distinct s0 s1)))+                   (let ((s4 (and s2 s3)))+                   (not s4))))))+[SEND] (check-sat)+[RECV] sat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_existsexists_satisfiable_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s3 (bvadd s1 s2)))+                   (let ((s4 (= s0 s3)))+                   (and s4 s_2)))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_existsexists_satisfiable_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s3 (bvadd s1 s2)))+                   (let ((s4 (= s0 s3)))+                   (not s4)))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_existsexists_thm_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s2 (bvsub s1 s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= s1 s3)))+                   (and s4 s_2))))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_existsexists_thm_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s2 (bvsub s1 s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= s1 s3)))+                   (not s4))))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_existsforall_contradiction_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s2 (= s0 (s1 s0))))+                   (let ((s3 (distinct s0 (s1 s0))))+                   (let ((s4 (and s2 s3)))+                   (and s4 s_2))))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_existsforall_contradiction_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s2 (= s0 (s1 s0))))+                   (let ((s3 (distinct s0 (s1 s0))))+                   (let ((s4 (and s2 s3)))+                   (not s4))))))+[SEND] (check-sat)+[RECV] sat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_existsforall_satisfiable_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s3 (bvadd (s1 s0) s2)))+                   (let ((s4 (= s0 s3)))+                   (and s4 s_2)))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_existsforall_satisfiable_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s3 (bvadd (s1 s0) s2)))+                   (let ((s4 (= s0 s3)))+                   (not s4)))))+[SEND] (check-sat)+[RECV] sat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_existsforall_thm_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s2 (bvsub (s1 s0) s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= (s1 s0) s3)))+                   (and s4 s_2))))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_existsforall_thm_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s2 (bvsub (s1 s0) s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= (s1 s0) s3)))+                   (not s4))))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallexists_contradiction_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s2 (= s0 s1)))+                   (let ((s3 (distinct s0 s1)))+                   (let ((s4 (and s2 s3)))+                   (and s4 s_2))))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallexists_contradiction_p.gold view
@@ -0,0 +1,31 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s2 (= s0 s1)))+                   (let ((s3 (distinct s0 s1)))+                   (let ((s4 (and s2 s3)))+                   (not s4))))))+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #x00))+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallexists_satisfiable_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s3 (bvadd s1 s2)))+                   (let ((s4 (= s0 s3)))+                   (and s4 s_2)))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallexists_satisfiable_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s3 (bvadd s1 s2)))+                   (let ((s4 (= s0 s3)))+                   (not s4)))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallexists_thm_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s2 (bvsub s1 s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= s1 s3)))+                   (and s4 s_2))))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallexists_thm_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s2 (bvsub s1 s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= s1 s3)))+                   (not s4))))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallforall_contradiction_c.gold view
@@ -0,0 +1,30 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s2 () Bool (= s0 s1))+[GOOD] (define-fun s3 () Bool (distinct s0 s1))+[GOOD] (define-fun s4 () Bool (and s2 s3))+[GOOD] (assert s4)+[GOOD] (assert s_2)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallforall_contradiction_p.gold view
@@ -0,0 +1,33 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s2 () Bool (= s0 s1))+[GOOD] (define-fun s3 () Bool (distinct s0 s1))+[GOOD] (define-fun s4 () Bool (and s2 s3))+[GOOD] (assert (not s4))+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #x00))+[SEND] (get-value (s1))+[RECV] ((s1 #x00))+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallforall_satisfiable_c.gold view
@@ -0,0 +1,30 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s3 () (_ BitVec 8) (bvadd s1 s2))+[GOOD] (define-fun s4 () Bool (= s0 s3))+[GOOD] (assert s4)+[GOOD] (assert s_2)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallforall_satisfiable_p.gold view
@@ -0,0 +1,33 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s3 () (_ BitVec 8) (bvadd s1 s2))+[GOOD] (define-fun s4 () Bool (= s0 s3))+[GOOD] (assert (not s4))+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #xff))+[SEND] (get-value (s1))+[RECV] ((s1 #xff))+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallforall_thm_c.gold view
@@ -0,0 +1,30 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s2 () (_ BitVec 8) (bvsub s1 s0))+[GOOD] (define-fun s3 () (_ BitVec 8) (bvadd s0 s2))+[GOOD] (define-fun s4 () Bool (= s1 s3))+[GOOD] (assert s4)+[GOOD] (assert s_2)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_prove_forallforall_thm_p.gold view
@@ -0,0 +1,29 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s2 () (_ BitVec 8) (bvsub s1 s0))+[GOOD] (define-fun s3 () (_ BitVec 8) (bvadd s0 s2))+[GOOD] (define-fun s4 () Bool (= s1 s3))+[GOOD] (assert (not s4))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsexists_contradiction_c.gold view
@@ -0,0 +1,29 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s2 () Bool (= s0 s1))+[GOOD] (define-fun s3 () Bool (distinct s0 s1))+[GOOD] (define-fun s4 () Bool (and s2 s3))+[GOOD] (assert s4)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsexists_contradiction_p.gold view
@@ -0,0 +1,29 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s2 () Bool (= s0 s1))+[GOOD] (define-fun s3 () Bool (distinct s0 s1))+[GOOD] (define-fun s4 () Bool (and s2 s3))+[GOOD] (assert s4)+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsexists_satisfiable_c.gold view
@@ -0,0 +1,33 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s3 () (_ BitVec 8) (bvadd s1 s2))+[GOOD] (define-fun s4 () Bool (= s0 s3))+[GOOD] (assert s4)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #x01))+[SEND] (get-value (s1))+[RECV] ((s1 #x00))+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsexists_satisfiable_p.gold view
@@ -0,0 +1,33 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s3 () (_ BitVec 8) (bvadd s1 s2))+[GOOD] (define-fun s4 () Bool (= s0 s3))+[GOOD] (assert s4)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #x01))+[SEND] (get-value (s1))+[RECV] ((s1 #x00))+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsexists_thm_c.gold view
@@ -0,0 +1,33 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s2 () (_ BitVec 8) (bvsub s1 s0))+[GOOD] (define-fun s3 () (_ BitVec 8) (bvadd s0 s2))+[GOOD] (define-fun s4 () Bool (= s1 s3))+[GOOD] (assert s4)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #x00))+[SEND] (get-value (s1))+[RECV] ((s1 #x00))+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsexists_thm_p.gold view
@@ -0,0 +1,33 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] (declare-fun s1 () (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s2 () (_ BitVec 8) (bvsub s1 s0))+[GOOD] (define-fun s3 () (_ BitVec 8) (bvadd s0 s2))+[GOOD] (define-fun s4 () Bool (= s1 s3))+[GOOD] (assert s4)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #x00))+[SEND] (get-value (s1))+[RECV] ((s1 #x00))+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsforall_contradiction_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s2 (= s0 s1)))+                   (let ((s3 (distinct s0 s1)))+                   (let ((s4 (and s2 s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsforall_contradiction_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s2 (= s0 s1)))+                   (let ((s3 (distinct s0 s1)))+                   (let ((s4 (and s2 s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsforall_satisfiable_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s3 (bvadd s1 s2)))+                   (let ((s4 (= s0 s3)))+                   s4))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsforall_satisfiable_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s3 (bvadd s1 s2)))+                   (let ((s4 (= s0 s3)))+                   s4))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsforall_thm_c.gold view
@@ -0,0 +1,31 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s2 (bvsub s1 s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= s1 s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #x00))+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_existsforall_thm_p.gold view
@@ -0,0 +1,31 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 8)) ; tracks user variable "x"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s1 (_ BitVec 8)))+                   (let ((s2 (bvsub s1 s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= s1 s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #x00))+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallexists_contradiction_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s2 (= s0 (s1 s0))))+                   (let ((s3 (distinct s0 (s1 s0))))+                   (let ((s4 (and s2 s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallexists_contradiction_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s2 (= s0 (s1 s0))))+                   (let ((s3 (distinct s0 (s1 s0))))+                   (let ((s4 (and s2 s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallexists_satisfiable_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s3 (bvadd (s1 s0) s2)))+                   (let ((s4 (= s0 s3)))+                   s4))))+[SEND] (check-sat)+[RECV] sat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallexists_satisfiable_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s3 (bvadd (s1 s0) s2)))+                   (let ((s4 (= s0 s3)))+                   s4))))+[SEND] (check-sat)+[RECV] sat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallexists_thm_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s2 (bvsub (s1 s0) s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= (s1 s0) s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] sat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallexists_thm_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s1 ((_ BitVec 8)) (_ BitVec 8)) ; tracks user variable "y"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8)))+                   (let ((s2 (bvsub (s1 s0) s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= (s1 s0) s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] sat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallforall_contradiction_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s2 (= s0 s1)))+                   (let ((s3 (distinct s0 s1)))+                   (let ((s4 (and s2 s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallforall_contradiction_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s2 (= s0 s1)))+                   (let ((s3 (distinct s0 s1)))+                   (let ((s4 (and s2 s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallforall_satisfiable_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s3 (bvadd s1 s2)))+                   (let ((s4 (= s0 s3)))+                   s4))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallforall_satisfiable_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 8) #x01)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s3 (bvadd s1 s2)))+                   (let ((s4 (= s0 s3)))+                   s4))))+[SEND] (check-sat)+[RECV] unsat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallforall_thm_c.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s2 (bvsub s1 s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= s1 s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] sat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/quantified_sat_forallforall_thm_p.gold view
@@ -0,0 +1,29 @@+** 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 BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] ; --- skolem constants ---+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (assert (forall ((s0 (_ BitVec 8))+                        (s1 (_ BitVec 8)))+                   (let ((s2 (bvsub s1 s0)))+                   (let ((s3 (bvadd s0 s2)))+                   (let ((s4 (= s1 s3)))+                   s4)))))+[SEND] (check-sat)+[RECV] sat+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/query_z3.gold view
@@ -0,0 +1,60 @@+** 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 QF_BV)+[GOOD] ; --- uninterpreted sorts ---+[GOOD] ; --- literal constants ---+[GOOD] (define-fun s_2 () Bool false)+[GOOD] (define-fun s_1 () Bool true)+[GOOD] (define-fun s2 () (_ BitVec 32) #x00000000)+[GOOD] ; --- skolem constants ---+[GOOD] (declare-fun s0 () (_ BitVec 32)) ; tracks user variable "a"+[GOOD] (declare-fun s1 () (_ BitVec 32)) ; tracks user variable "b"+[GOOD] ; --- constant tables ---+[GOOD] ; --- skolemized tables ---+[GOOD] ; --- arrays ---+[GOOD] ; --- uninterpreted constants ---+[GOOD] ; --- user given axioms ---+[GOOD] ; --- formula ---+[GOOD] (define-fun s3 () Bool (bvsgt s0 s2))+[GOOD] (define-fun s4 () Bool (bvsgt s1 s2))+[GOOD] (assert (! s3 :named |a > 0|))+[GOOD] (assert s4)+[GOOD] (define-fun s5 () (_ BitVec 32) #x00000002)+[GOOD] (define-fun s7 () (_ BitVec 32) #x0000000f)+[GOOD] (define-fun s6 () (_ BitVec 32) (bvadd s0 s5))+[GOOD] (define-fun s8 () Bool (bvsle s6 s7))+[GOOD] (assert s8)+[GOOD] (define-fun s9 () (_ BitVec 32) #x00000003)+[GOOD] (define-fun s10 () Bool (bvslt s0 s9))+[GOOD] (assert s10)+[GOOD] (define-fun s11 () Bool (bvslt s1 s5))+[GOOD] (assert s11)+[GOOD] (define-fun s13 () (_ BitVec 32) #x0000000c)+[GOOD] (define-fun s12 () (_ BitVec 32) (bvadd s0 s1))+[GOOD] (define-fun s14 () Bool (bvslt s12 s13))+[GOOD] (assert (! s14 :named |a+b_<_12|))+[GOOD] (push 1)+[GOOD] (define-fun s15 () Bool (bvslt s0 s5))+[GOOD] (assert s15)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #x00000001))+[GOOD] (pop 1)+[GOOD] (define-fun s16 () (_ BitVec 32) #x00000001)+[GOOD] (define-fun s17 () Bool (bvsgt s0 s16))+[GOOD] (assert (! s17 :named |extra|))+[GOOD] (assert s11)+[SEND] (check-sat)+[RECV] sat+[SEND] (get-value (s0))+[RECV] ((s0 #x00000002))+[SEND] (get-value (s1))+[RECV] ((s1 #x00000001))+*** Solver   : Z3+*** Exit code: ExitSuccess
+ SBVTestSuite/GoldFiles/selChecked.gold view
@@ -0,0 +1,99 @@+== BEGIN: "Makefile" ================+# Makefile for selChecked. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: selChecked_driver++selChecked.o: selChecked.c selChecked.h+	${CC} ${CCFLAGS} -c $< -o $@++selChecked_driver.o: selChecked_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++selChecked_driver: selChecked.o selChecked_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f selChecked_driver+== END: "Makefile" ==================+== BEGIN: "selChecked.h" ================+/* Header file for selChecked. Automatically generated by SBV. Do not edit! */++#ifndef __selChecked__HEADER_INCLUDED__+#define __selChecked__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+SWord8 selChecked(const SWord8 x);++#endif /* __selChecked__HEADER_INCLUDED__ */+== END: "selChecked.h" ==================+== BEGIN: "selChecked_driver.c" ================+/* Example driver program for selChecked. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "selChecked.h"++int main(void)+{+  const SWord8 __result = selChecked(65);++  printf("selChecked(65) = %"PRIu8"\n", __result);++  return 0;+}+== END: "selChecked_driver.c" ==================+== BEGIN: "selChecked.c" ================+/* File: "selChecked.c". Automatically generated by SBV. Do not edit! */++#include "selChecked.h"++SWord8 selChecked(const SWord8 x)+{+  const SWord8 s0 = x;+  const SWord8 s3 = s0 + 2;+  const SWord8 table0[] = {+       1, s3+  };+  const SWord8 s5 = s0 >= 2 ? 3 : table0[s0];++  return s5;+}+== END: "selChecked.c" ==================
+ SBVTestSuite/GoldFiles/selUnchecked.gold view
@@ -0,0 +1,99 @@+== BEGIN: "Makefile" ================+# Makefile for selUnChecked. Automatically generated by SBV. Do not edit!++# include any user-defined .mk file in the current directory.+-include *.mk++CC?=gcc+CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer++all: selUnChecked_driver++selUnChecked.o: selUnChecked.c selUnChecked.h+	${CC} ${CCFLAGS} -c $< -o $@++selUnChecked_driver.o: selUnChecked_driver.c+	${CC} ${CCFLAGS} -c $< -o $@++selUnChecked_driver: selUnChecked.o selUnChecked_driver.o+	${CC} ${CCFLAGS} $^ -o $@++clean:+	rm -f *.o++veryclean: clean+	rm -f selUnChecked_driver+== END: "Makefile" ==================+== BEGIN: "selUnChecked.h" ================+/* Header file for selUnChecked. Automatically generated by SBV. Do not edit! */++#ifndef __selUnChecked__HEADER_INCLUDED__+#define __selUnChecked__HEADER_INCLUDED__++#include <stdio.h>+#include <stdlib.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++/* Entry point prototype: */+SWord8 selUnChecked(const SWord8 x);++#endif /* __selUnChecked__HEADER_INCLUDED__ */+== END: "selUnChecked.h" ==================+== BEGIN: "selUnChecked_driver.c" ================+/* Example driver program for selUnChecked. */+/* Automatically generated by SBV. Edit as you see fit! */++#include <stdio.h>+#include "selUnChecked.h"++int main(void)+{+  const SWord8 __result = selUnChecked(65);++  printf("selUnChecked(65) = %"PRIu8"\n", __result);++  return 0;+}+== END: "selUnChecked_driver.c" ==================+== BEGIN: "selUnChecked.c" ================+/* File: "selUnChecked.c". Automatically generated by SBV. Do not edit! */++#include "selUnChecked.h"++SWord8 selUnChecked(const SWord8 x)+{+  const SWord8 s0 = x;+  const SWord8 s3 = s0 + 2;+  const SWord8 table0[] = {+       1, s3+  };+  const SWord8 s5 = table0[s0];++  return s5;+}+== END: "selUnChecked.c" ==================
+ SBVTestSuite/GoldFiles/squashReals1.gold view
@@ -0,0 +1,2 @@+Satisfiable. Model:+  s0 = root(2, x^2 = 59) = 7.6811457478686081... :: Real
+ SBVTestSuite/GoldFiles/squashReals2.gold view
@@ -0,0 +1,2 @@+Satisfiable. Model:+  s0 = 4.0 :: Real
+ SBVTestSuite/GoldFiles/squashReals3.gold view
@@ -0,0 +1,2 @@+Satisfiable. Model:+  s0 = root(2, x^2 = 59) = 7.68114574786860817576968702173137247... :: Real
+ SBVTestSuite/GoldFiles/squashReals4.gold view
@@ -0,0 +1,2 @@+Satisfiable. Model:+  s0 = 4.0 :: Real
+ SBVTestSuite/GoldFiles/temperature.gold view
@@ -0,0 +1,5 @@+Solution #1:+  s0 = 28 :: Integer+Solution #2:+  s0 = 16 :: Integer+Found 2 different solutions.
+ SBVTestSuite/GoldFiles/tgen_c.gold view
@@ -0,0 +1,73 @@+/* Automatically generated by SBV. Do not edit! */++#include <stdio.h>+#include <inttypes.h>+#include <stdint.h>+#include <stdbool.h>+#include <string.h>+#include <math.h>++/* The boolean type */+typedef bool SBool;++/* The float type */+typedef float SFloat;++/* The double type */+typedef double SDouble;++/* Unsigned bit-vectors */+typedef uint8_t  SWord8 ;+typedef uint16_t SWord16;+typedef uint32_t SWord32;+typedef uint64_t SWord64;++/* Signed bit-vectors */+typedef int8_t  SInt8 ;+typedef int16_t SInt16;+typedef int32_t SInt32;+typedef int64_t SInt64;++typedef struct {+  struct {+    SWord32 i0;+    SWord32 i1;+  } input;+  struct {+    SWord32 o0;+    SWord32 o1;+    SWord32 o2;+  } output;+} CTestTestVector;++CTestTestVector CTest[] = {+      {{0xfcbe0fdb, 0xd321df04}, {0xcfdfeedf, 0x299c30d7, 0x0f03046c}}+    , {{0x7e037b43, 0xf66d083b}, {0x7470837e, 0x87967308, 0x042e8071}}+    , {{0xce482a70, 0x66b7c768}, {0x34fff1d8, 0x67906308, 0xdc5e4d80}}+    , {{0xec1eda04, 0x465a32a9}, {0x32790cad, 0xa5c4a75b, 0xa45ab4a4}}+    , {{0x61f89467, 0x00d8fb06}, {0x62d18f6d, 0x611f9961, 0x3c3c776a}}+    , {{0x30e2d88c, 0x10ea31cd}, {0x41cd0a59, 0x1ff8a6bf, 0x4112341c}}+    , {{0x4bf1b3fd, 0x2124dc8b}, {0x6d169088, 0x2accd772, 0xdf7e265f}}+    , {{0x96885656, 0x60a8c5ca}, {0xf7311c20, 0x35df908c, 0x9a744ddc}}+    , {{0xc2bac856, 0xe5a9367c}, {0xa863fed2, 0xdd1191da, 0xe7812da8}}+    , {{0x8b10b4f2, 0xf010d50f}, {0x7b218a01, 0x9affdfe3, 0x3ba7f42e}}+};++int CTestLength = 10;++/* Stub driver showing the test values, replace with code that uses the test vectors. */+int main(void)+{+  int i;+  for(i = 0; i < CTestLength; ++i)+  {+    printf("%*d. 0x%08"PRIx32"UL 0x%08"PRIx32"UL -> 0x%08"PRIx32"UL 0x%08"PRIx32"UL 0x%08"PRIx32"UL\n", 1, i+           , CTest[i].input.i0+           , CTest[i].input.i1+           , CTest[i].output.o0+           , CTest[i].output.o1+           , CTest[i].output.o2);+  }++  return 0;+}
+ SBVTestSuite/GoldFiles/tgen_forte.gold view
@@ -0,0 +1,14 @@+// Automatically generated by SBV. Do not edit!+let ForteTest =+   let c s = val [_, r] = str_split s "'" in map (\s. s == "1") (explode (string_tl r))+   in [ ((c "32'b11111100101111100000111111011011", c "32'b11010011001000011101111100000100"), (c "32'b11001111110111111110111011011111", c "32'b00101001100111000011000011010111", c "32'b00001111000000110000010001101100"))+      , ((c "32'b01111110000000110111101101000011", c "32'b11110110011011010000100000111011"), (c "32'b01110100011100001000001101111110", c "32'b10000111100101100111001100001000", c "32'b00000100001011101000000001110001"))+      , ((c "32'b11001110010010000010101001110000", c "32'b01100110101101111100011101101000"), (c "32'b00110100111111111111000111011000", c "32'b01100111100100000110001100001000", c "32'b11011100010111100100110110000000"))+      , ((c "32'b11101100000111101101101000000100", c "32'b01000110010110100011001010101001"), (c "32'b00110010011110010000110010101101", c "32'b10100101110001001010011101011011", c "32'b10100100010110101011010010100100"))+      , ((c "32'b01100001111110001001010001100111", c "32'b00000000110110001111101100000110"), (c "32'b01100010110100011000111101101101", c "32'b01100001000111111001100101100001", c "32'b00111100001111000111011101101010"))+      , ((c "32'b00110000111000101101100010001100", c "32'b00010000111010100011000111001101"), (c "32'b01000001110011010000101001011001", c "32'b00011111111110001010011010111111", c "32'b01000001000100100011010000011100"))+      , ((c "32'b01001011111100011011001111111101", c "32'b00100001001001001101110010001011"), (c "32'b01101101000101101001000010001000", c "32'b00101010110011001101011101110010", c "32'b11011111011111100010011001011111"))+      , ((c "32'b10010110100010000101011001010110", c "32'b01100000101010001100010111001010"), (c "32'b11110111001100010001110000100000", c "32'b00110101110111111001000010001100", c "32'b10011010011101000100110111011100"))+      , ((c "32'b11000010101110101100100001010110", c "32'b11100101101010010011011001111100"), (c "32'b10101000011000111111111011010010", c "32'b11011101000100011001000111011010", c "32'b11100111100000010010110110101000"))+      , ((c "32'b10001011000100001011010011110010", c "32'b11110000000100001101010100001111"), (c "32'b01111011001000011000101000000001", c "32'b10011010111111111101111111100011", c "32'b00111011101001111111010000101110"))+      ];
+ SBVTestSuite/GoldFiles/tgen_haskell.gold view
@@ -0,0 +1,18 @@+-- Automatically generated by SBV. Do not edit!++module HaskTest(haskTest) where++import Data.Word++haskTest :: [([Word32], [Word32])]+haskTest = [ ([0xfcbe0fdb, 0xd321df04], [0xcfdfeedf, 0x299c30d7, 0x0f03046c])+           , ([0x7e037b43, 0xf66d083b], [0x7470837e, 0x87967308, 0x042e8071])+           , ([0xce482a70, 0x66b7c768], [0x34fff1d8, 0x67906308, 0xdc5e4d80])+           , ([0xec1eda04, 0x465a32a9], [0x32790cad, 0xa5c4a75b, 0xa45ab4a4])+           , ([0x61f89467, 0x00d8fb06], [0x62d18f6d, 0x611f9961, 0x3c3c776a])+           , ([0x30e2d88c, 0x10ea31cd], [0x41cd0a59, 0x1ff8a6bf, 0x4112341c])+           , ([0x4bf1b3fd, 0x2124dc8b], [0x6d169088, 0x2accd772, 0xdf7e265f])+           , ([0x96885656, 0x60a8c5ca], [0xf7311c20, 0x35df908c, 0x9a744ddc])+           , ([0xc2bac856, 0xe5a9367c], [0xa863fed2, 0xdd1191da, 0xe7812da8])+           , ([0x8b10b4f2, 0xf010d50f], [0x7b218a01, 0x9affdfe3, 0x3ba7f42e])+           ]
+ SBVTestSuite/GoldFiles/timeout1.gold view
@@ -0,0 +1,2 @@+Unknown.+  Reason: canceled
+ SBVTestSuite/SBVDocTest.hs view
@@ -0,0 +1,7 @@+module Main (main) where++import System.FilePath.Glob (glob)+import Test.DocTest (doctest)++main :: IO ()+main = glob "Data/SBV/**/*.hs" >>= doctest
+ SBVTestSuite/SBVHLint.hs view
@@ -0,0 +1,16 @@+module Main (main) where++import Language.Haskell.HLint (hlint)+import System.Exit (exitFailure, exitSuccess)++arguments :: [String]+arguments =+    [ "Data"+    , "SBVTestSuite"+    , "-i", "Use otherwise"+    ]++main :: IO ()+main = do+    hints <- hlint arguments+    if null hints then exitSuccess else exitFailure
+ SBVTestSuite/SBVTest.hs view
@@ -0,0 +1,159 @@+{-# LANGUAGE ScopedTypeVariables #-}+module Main(main) where++import Test.Tasty+import System.Environment (lookupEnv)++import qualified TestSuite.Arrays.Memory+import qualified TestSuite.Basics.AllSat+import qualified TestSuite.Basics.ArithNoSolver+import qualified TestSuite.Basics.ArithSolver+import qualified TestSuite.Basics.BasicTests+import qualified TestSuite.Basics.GenBenchmark+import qualified TestSuite.Basics.Higher+import qualified TestSuite.Basics.Index+import qualified TestSuite.Basics.IteTest+import qualified TestSuite.Basics.ProofTests+import qualified TestSuite.Basics.PseudoBoolean+import qualified TestSuite.Basics.QRem+import qualified TestSuite.Basics.Quantifiers+import qualified TestSuite.Basics.Recursive+import qualified TestSuite.Basics.SquashReals+import qualified TestSuite.Basics.TOut+import qualified TestSuite.BitPrecise.BitTricks+import qualified TestSuite.BitPrecise.Legato+import qualified TestSuite.BitPrecise.MergeSort+import qualified TestSuite.BitPrecise.PrefixSum+import qualified TestSuite.CodeGeneration.AddSub+import qualified TestSuite.CodeGeneration.CgTests+import qualified TestSuite.CodeGeneration.CRC_USB5+import qualified TestSuite.CodeGeneration.Fibonacci+import qualified TestSuite.CodeGeneration.Floats+import qualified TestSuite.CodeGeneration.GCD+import qualified TestSuite.CodeGeneration.PopulationCount+import qualified TestSuite.CodeGeneration.Uninterpreted+import qualified TestSuite.CRC.CCITT+import qualified TestSuite.CRC.CCITT_Unidir+import qualified TestSuite.CRC.GenPoly+import qualified TestSuite.CRC.Parity+import qualified TestSuite.CRC.USB5+import qualified TestSuite.Crypto.AES+import qualified TestSuite.Crypto.RC4+import qualified TestSuite.Existentials.CRCPolynomial+import qualified TestSuite.GenTest.GenTests+import qualified TestSuite.Optimization.AssertSoft+import qualified TestSuite.Optimization.Basics+import qualified TestSuite.Optimization.Combined+import qualified TestSuite.Optimization.ExtensionField+import qualified TestSuite.Optimization.Reals+import qualified TestSuite.Polynomials.Polynomials+import qualified TestSuite.Puzzles.Coins+import qualified TestSuite.Puzzles.Counts+import qualified TestSuite.Puzzles.DogCatMouse+import qualified TestSuite.Puzzles.Euler185+import qualified TestSuite.Puzzles.MagicSquare+import qualified TestSuite.Puzzles.NQueens+import qualified TestSuite.Puzzles.PowerSet+import qualified TestSuite.Puzzles.Sudoku+import qualified TestSuite.Puzzles.Temperature+import qualified TestSuite.Puzzles.U2Bridge+import qualified TestSuite.Queries.BasicQuery+import qualified TestSuite.Queries.Enums+import qualified TestSuite.Queries.FreshVars+import qualified TestSuite.Queries.Int_ABC+import qualified TestSuite.Queries.Int_Boolector+import qualified TestSuite.Queries.Int_CVC4+import qualified TestSuite.Queries.Int_Mathsat+import qualified TestSuite.Queries.Int_Yices+import qualified TestSuite.Queries.Int_Z3+import qualified TestSuite.Queries.Uninterpreted+import qualified TestSuite.Uninterpreted.AUF+import qualified TestSuite.Uninterpreted.Axioms+import qualified TestSuite.Uninterpreted.Function+import qualified TestSuite.Uninterpreted.Sort+import qualified TestSuite.Uninterpreted.Uninterpreted++main :: IO ()+main = do mbTravis <- lookupEnv "SBV_UNDER_TRAVIS"++          isTravis <- case mbTravis of+                        Just "yes" -> do putStrLn "SBVTests: Running on Travis"+                                         return True+                        _          -> do putStrLn "SBVTests: Not running on Travis"+                                         return False++          let testCases = [tc | (canRunOnTravis, tc) <- allTests, not isTravis || canRunOnTravis]++          defaultMain $ testGroup "Tests" testCases++-- If the first  Bool is True, then that test can run on Travis+allTests :: [(Bool, TestTree)]+allTests = [ (True,  TestSuite.Arrays.Memory.tests)+           , (True,  TestSuite.Basics.AllSat.tests)+           , (True,  TestSuite.Basics.ArithNoSolver.tests)+           , (True,  TestSuite.Basics.ArithSolver.tests)+           , (True,  TestSuite.Basics.BasicTests.tests)+           , (True,  TestSuite.Basics.GenBenchmark.tests)+           , (True,  TestSuite.Basics.Higher.tests)+           , (True,  TestSuite.Basics.Index.tests)+           , (True,  TestSuite.Basics.IteTest.tests)+           , (True,  TestSuite.Basics.ProofTests.tests)+           , (True,  TestSuite.Basics.PseudoBoolean.tests)+           , (True,  TestSuite.Basics.QRem.tests)+           , (True,  TestSuite.Basics.Quantifiers.tests)+           , (True,  TestSuite.Basics.Recursive.tests)+           , (True,  TestSuite.Basics.SquashReals.tests)+           , (True,  TestSuite.Basics.TOut.tests)+           , (True,  TestSuite.BitPrecise.BitTricks.tests)+           , (True,  TestSuite.BitPrecise.Legato.tests)+           , (True,  TestSuite.BitPrecise.MergeSort.tests)+           , (True,  TestSuite.BitPrecise.PrefixSum.tests)+           , (True,  TestSuite.CodeGeneration.AddSub.tests)+           , (True,  TestSuite.CodeGeneration.CgTests.tests)+           , (True,  TestSuite.CodeGeneration.CRC_USB5.tests)+           , (True,  TestSuite.CodeGeneration.Fibonacci.tests)+           , (True,  TestSuite.CodeGeneration.Floats.tests)+           , (True,  TestSuite.CodeGeneration.GCD.tests)+           , (True,  TestSuite.CodeGeneration.PopulationCount.tests)+           , (True,  TestSuite.CodeGeneration.Uninterpreted.tests)+           , (True,  TestSuite.CRC.CCITT.tests)+           , (True,  TestSuite.CRC.CCITT_Unidir.tests)+           , (True,  TestSuite.CRC.GenPoly.tests)+           , (True,  TestSuite.CRC.Parity.tests)+           , (True,  TestSuite.CRC.USB5.tests)+           , (True,  TestSuite.Crypto.AES.tests)+           , (True,  TestSuite.Crypto.RC4.tests)+           , (True,  TestSuite.Existentials.CRCPolynomial.tests)+           , (True,  TestSuite.GenTest.GenTests.tests)+           , (True,  TestSuite.Optimization.AssertSoft.tests)+           , (True,  TestSuite.Optimization.Basics.tests)+           , (True,  TestSuite.Optimization.Combined.tests)+           , (True,  TestSuite.Optimization.ExtensionField.tests)+           , (True,  TestSuite.Optimization.Reals.tests)+           , (True,  TestSuite.Polynomials.Polynomials.tests)+           , (True,  TestSuite.Puzzles.Coins.tests)+           , (True,  TestSuite.Puzzles.Counts.tests)+           , (True,  TestSuite.Puzzles.DogCatMouse.tests)+           , (True,  TestSuite.Puzzles.Euler185.tests)+           , (True,  TestSuite.Puzzles.MagicSquare.tests)+           , (True,  TestSuite.Puzzles.NQueens.tests)+           , (True,  TestSuite.Puzzles.PowerSet.tests)+           , (True,  TestSuite.Puzzles.Sudoku.tests)+           , (True,  TestSuite.Puzzles.Temperature.tests)+           , (True,  TestSuite.Puzzles.U2Bridge.tests)+           , (False, TestSuite.Queries.BasicQuery.tests)+           , (True,  TestSuite.Queries.Enums.tests)+           , (True,  TestSuite.Queries.FreshVars.tests)+           , (False, TestSuite.Queries.Int_ABC.tests)+           , (False, TestSuite.Queries.Int_Boolector.tests)+           , (False, TestSuite.Queries.Int_CVC4.tests)+           , (False, TestSuite.Queries.Int_Mathsat.tests)+           , (False, TestSuite.Queries.Int_Yices.tests)+           , (True,  TestSuite.Queries.Int_Z3.tests)+           , (True,  TestSuite.Queries.Uninterpreted.tests)+           , (True,  TestSuite.Uninterpreted.AUF.tests)+           , (True,  TestSuite.Uninterpreted.Axioms.tests)+           , (True,  TestSuite.Uninterpreted.Function.tests)+           , (True,  TestSuite.Uninterpreted.Sort.tests)+           , (True,  TestSuite.Uninterpreted.Uninterpreted.tests)+           ]
+ SBVTestSuite/TestSuite/Arrays/Memory.hs view
@@ -0,0 +1,46 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Arrays.Memory+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.Arrays.Memory+-----------------------------------------------------------------------------++module TestSuite.Arrays.Memory(tests) where++import Utils.SBVTestFramework++type Address = SWord32+type Value   = SWord64+type Memory  = SArray Word32 Word64++-- | read-after-write: If you write a value and read it back, you'll get it+raw :: Address -> Value -> Memory -> SBool+raw a v m = readArray (writeArray m a v) a .== v++-- | write-after-write: If you write to the same location twice, then the first one is ignored+waw :: Address -> Value -> Value -> Memory -> SBool+waw a v1 v2 m0 = m2 .== m3+  where m1 = writeArray m0 a v1+        m2 = writeArray m1 a v2+        m3 = writeArray m0 a v2++-- | Two writes to different locations commute, i.e., can be done in any order+wcommutesGood :: (Address, Value) -> (Address, Value) -> Memory -> SBool+wcommutesGood (a, x) (b, y) m = a ./= b ==> wcommutesBad (a, x) (b, y) m++-- | Two writes do not commute if they can be done to the same location+wcommutesBad :: (Address, Value) -> (Address, Value) -> Memory -> SBool+wcommutesBad (a, x) (b, y) m = writeArray (writeArray m a x) b y .== writeArray (writeArray m b y) a x++tests :: TestTree+tests =+  testGroup "Arrays.Memory"+    [ testCase "raw"           $ assertIsThm   raw+    , testCase "waw"           $ assertIsThm   waw+    , testCase "wcommute-good" $ assertIsThm   wcommutesGood+    , testCase "wcommute-bad"  $ assertIsntThm wcommutesBad+    ]
+ SBVTestSuite/TestSuite/Basics/AllSat.hs view
@@ -0,0 +1,43 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.AllSat+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for basic allsat calls+-----------------------------------------------------------------------------++{-# LANGUAGE DeriveAnyClass     #-}+{-# LANGUAGE DeriveDataTypeable #-}++module TestSuite.Basics.AllSat(tests) where++import Data.Generics+import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "Basics.AllSat"+    [ goldenVsStringShow "allSat1" t1+    , goldenVsStringShow "allSat2" t2+    , goldenVsStringShow "allSat3" $ allSat $ \x -> x .== (0::SFloat)+    , goldenVsStringShow "allSat4" $ allSat $ \x -> x .<  (0::SWord8)+    , goldenVsStringShow "allSat5" $ allSat $ \x y -> x .< y &&& y .< (4::SWord8)+    , goldenVsStringShow "allSat6" $ allSat $ exists "x" >>= \x -> exists "y" >>= \y -> forall "z" >>= \z -> return (x .< (y::SWord8) &&& y .< 3 &&& z .== (z::SWord8))+    ]++newtype Q = Q () deriving (Eq, Ord, Data, Read, Show, SymWord, HasKind)+type SQ = SBV Q++t1 :: IO AllSatResult+t1 = allSat $ do x <- free "x"+                 y <- free "y"+                 return $ x .== (y :: SQ)++t2 :: IO AllSatResult+t2 = allSat $ do x <- free "x"+                 y <- free "y"+                 z <- free "z"+                 return $ x .== (y :: SQ) &&& z .== (z :: SQ)
+ SBVTestSuite/TestSuite/Basics/ArithNoSolver.hs view
@@ -0,0 +1,485 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.ArithNoSolver+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for basic concrete arithmetic, i.e., testing all+-- the constant folding based arithmetic implementation in SBV+-----------------------------------------------------------------------------++{-# LANGUAGE Rank2Types    #-}+{-# LANGUAGE TupleSections #-}++module TestSuite.Basics.ArithNoSolver(tests) where++import Data.SBV.Internals+import Data.Maybe(fromJust, fromMaybe)+import Utils.SBVTestFramework+import qualified Data.Binary.IEEE754 as DB (wordToFloat, wordToDouble, floatToWord, doubleToWord)++ghcBitSize :: Bits a => a -> Int+ghcBitSize x = fromMaybe (error "SBV.ghcBitSize: Unexpected non-finite usage!") (bitSizeMaybe x)++-- Test suite+tests :: TestTree+tests = testGroup "Arith.NoSolver" $+           genReals+        ++ genFloats+        ++ genQRems+        ++ genBinTest  "+"             (+)+        ++ genBinTest  "-"             (-)+        ++ genBinTest  "*"             (*)+        ++ genUnTest   "negate"        negate+        ++ genUnTest   "abs"           abs+        ++ genUnTest   "signum"        signum+        ++ genBinTest  ".&."           (.&.)+        ++ genBinTest  ".|."           (.|.)+        ++ genBoolTest "<"             (<)  (.<)+        ++ genBoolTest "<="            (<=) (.<=)+        ++ genBoolTest ">"             (>)  (.>)+        ++ genBoolTest ">="            (>=) (.>=)+        ++ genBoolTest "=="            (==) (.==)+        ++ genBoolTest "/="            (/=) (./=)+        ++ genBinTest  "xor"           xor+        ++ genUnTest   "complement"    complement+        ++ genIntTest  "shift"         shift+        ++ genIntTest  "rotate"        rotate+        ++ genIntTestS "setBit"        setBit+        ++ genIntTestS "clearBit"      clearBit+        ++ genIntTestS "complementBit" complementBit+        ++ genIntTest  "shift"         shift+        ++ genIntTestS "shiftL"        shiftL+        ++ genIntTestS "shiftR"        shiftR+        ++ genIntTest  "rotate"        rotate+        ++ genIntTestS "rotateL"       rotateL+        ++ genIntTestS "rotateR"       rotateR+        ++ genBlasts+        ++ genIntCasts++genBinTest :: String -> (forall a. (Num a, Bits a) => a -> a -> a) -> [TestTree]+genBinTest nm op = map mkTest $+        zipWith pair [(show x, show y, x `op` y) | x <- w8s,  y <- w8s ] [x `op` y | x <- sw8s,  y <- sw8s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- w16s, y <- w16s] [x `op` y | x <- sw16s, y <- sw16s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- w32s, y <- w32s] [x `op` y | x <- sw32s, y <- sw32s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- w64s, y <- w64s] [x `op` y | x <- sw64s, y <- sw64s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- i8s,  y <- i8s ] [x `op` y | x <- si8s,  y <- si8s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- i16s, y <- i16s] [x `op` y | x <- si16s, y <- si16s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- i32s, y <- i32s] [x `op` y | x <- si32s, y <- si32s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- i64s, y <- i64s] [x `op` y | x <- si64s, y <- si64s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- iUBs, y <- iUBs] [x `op` y | x <- siUBs, y <- siUBs]+  where pair (x, y, a) b = (x, y, show (fromIntegral a `asTypeOf` b) == show b)+        mkTest (x, y, s) = testCase ("arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y) (s `showsAs` "True")++genBoolTest :: String -> (forall a. Ord a => a -> a -> Bool) -> (forall a. OrdSymbolic a => a -> a -> SBool) -> [TestTree]+genBoolTest nm op opS = map mkTest $+        zipWith pair [(show x, show y, x `op` y) | x <- w8s,  y <- w8s ] [x `opS` y | x <- sw8s,  y <- sw8s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- w16s, y <- w16s] [x `opS` y | x <- sw16s, y <- sw16s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- w32s, y <- w32s] [x `opS` y | x <- sw32s, y <- sw32s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- w64s, y <- w64s] [x `opS` y | x <- sw64s, y <- sw64s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- i8s,  y <- i8s ] [x `opS` y | x <- si8s,  y <- si8s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- i16s, y <- i16s] [x `opS` y | x <- si16s, y <- si16s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- i32s, y <- i32s] [x `opS` y | x <- si32s, y <- si32s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- i64s, y <- i64s] [x `opS` y | x <- si64s, y <- si64s]+     ++ zipWith pair [(show x, show y, x `op` y) | x <- iUBs, y <- iUBs] [x `opS` y | x <- siUBs, y <- siUBs]+  where pair (x, y, a) b = (x, y, Just a == unliteral b)+        mkTest (x, y, s) = testCase ("arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y) (s `showsAs` "True")++genUnTest :: String -> (forall a. (Num a, Bits a) => a -> a) -> [TestTree]+genUnTest nm op = map mkTest $+        zipWith pair [(show x, op x) | x <- w8s ] [op x | x <- sw8s ]+     ++ zipWith pair [(show x, op x) | x <- w16s] [op x | x <- sw16s]+     ++ zipWith pair [(show x, op x) | x <- w32s] [op x | x <- sw32s]+     ++ zipWith pair [(show x, op x) | x <- w64s] [op x | x <- sw64s]+     ++ zipWith pair [(show x, op x) | x <- i8s ] [op x | x <- si8s ]+     ++ zipWith pair [(show x, op x) | x <- i16s] [op x | x <- si16s]+     ++ zipWith pair [(show x, op x) | x <- i32s] [op x | x <- si32s]+     ++ zipWith pair [(show x, op x) | x <- i64s] [op x | x <- si64s]+     ++ zipWith pair [(show x, op x) | x <- iUBs] [op x | x <- siUBs]+  where pair (x, a) b = (x, show (fromIntegral a `asTypeOf` b) == show b)+        mkTest (x, s) = testCase ("arithCF-" ++ nm ++ "." ++ x) (s `showsAs` "True")++genIntTest :: String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [TestTree]+genIntTest nm op = map mkTest $+        zipWith pair [("u8",  show x, show y, x `op` y) | x <- w8s,  y <- is] [x `op` y | x <- sw8s,  y <- is]+     ++ zipWith pair [("u16", show x, show y, x `op` y) | x <- w16s, y <- is] [x `op` y | x <- sw16s, y <- is]+     ++ zipWith pair [("u32", show x, show y, x `op` y) | x <- w32s, y <- is] [x `op` y | x <- sw32s, y <- is]+     ++ zipWith pair [("u64", show x, show y, x `op` y) | x <- w64s, y <- is] [x `op` y | x <- sw64s, y <- is]+     ++ zipWith pair [("s8",  show x, show y, x `op` y) | x <- i8s,  y <- is] [x `op` y | x <- si8s,  y <- is]+     ++ zipWith pair [("s16", show x, show y, x `op` y) | x <- i16s, y <- is] [x `op` y | x <- si16s, y <- is]+     ++ zipWith pair [("s32", show x, show y, x `op` y) | x <- i32s, y <- is] [x `op` y | x <- si32s, y <- is]+     ++ zipWith pair [("s64", show x, show y, x `op` y) | x <- i64s, y <- is] [x `op` y | x <- si64s, y <- is]+     ++ zipWith pair [("iUB", show x, show y, x `op` y) | x <- iUBs, y <- is] [x `op` y | x <- siUBs, y <- is]+  where pair (t, x, y, a) b       = (t, x, y, show a, show b, show (fromIntegral a `asTypeOf` b) == show b)+        mkTest (t, x, y, a, b, s) = testCase ("arithCF-" ++ nm ++ "." ++ t ++ "_" ++ x ++ "_" ++ y ++ "_" ++ a ++ "_" ++ b) (s `showsAs` "True")+        is = [-10 .. 10]++genIntTestS :: String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [TestTree]+genIntTestS nm op = map mkTest $+        zipWith pair [("u8",  show x, show y, x `op` y) | x <- w8s,  y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw8s,  y <- [0 .. (ghcBitSize x - 1)]]+     ++ zipWith pair [("u16", show x, show y, x `op` y) | x <- w16s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw16s, y <- [0 .. (ghcBitSize x - 1)]]+     ++ zipWith pair [("u32", show x, show y, x `op` y) | x <- w32s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw32s, y <- [0 .. (ghcBitSize x - 1)]]+     ++ zipWith pair [("u64", show x, show y, x `op` y) | x <- w64s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw64s, y <- [0 .. (ghcBitSize x - 1)]]+     ++ zipWith pair [("s8",  show x, show y, x `op` y) | x <- i8s,  y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si8s,  y <- [0 .. (ghcBitSize x - 1)]]+     ++ zipWith pair [("s16", show x, show y, x `op` y) | x <- i16s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si16s, y <- [0 .. (ghcBitSize x - 1)]]+     ++ zipWith pair [("s32", show x, show y, x `op` y) | x <- i32s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si32s, y <- [0 .. (ghcBitSize x - 1)]]+     ++ zipWith pair [("s64", show x, show y, x `op` y) | x <- i64s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si64s, y <- [0 .. (ghcBitSize x - 1)]]+     ++ zipWith pair [("iUB", show x, show y, x `op` y) | x <- iUBs, y <- [0 .. 10]]              [x `op` y | x <- siUBs, y <- [0 .. 10             ]]+  where pair (t, x, y, a) b       = (t, x, y, show a, show b, show (fromIntegral a `asTypeOf` b) == show b)+        mkTest (t, x, y, a, b, s) = testCase ("arithCF-" ++ nm ++ "." ++ t ++ "_" ++ x ++ "_" ++ y ++ "_" ++ a ++ "_" ++ b) (s `showsAs` "True")++genBlasts :: [TestTree]+genBlasts = map mkTest $+             [(show x, fromBitsLE (blastLE x) .== x) | x <- sw8s ]+          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw8s ]+          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si8s ]+          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si8s ]+          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- sw16s]+          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw16s]+          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si16s]+          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si16s]+          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- sw32s]+          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw32s]+          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si32s]+          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si32s]+          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- sw64s]+          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw64s]+          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si64s]+          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si64s]+  where mkTest (x, r) = testCase ("blast-" ++ x) (r `showsAs` "True")++genIntCasts :: [TestTree]+genIntCasts = map mkTest $  cast w8s ++ cast w16s ++ cast w32s ++ cast w64s+                         ++ cast i8s ++ cast i16s ++ cast i32s ++ cast i64s+                         ++ cast iUBs+   where mkTest (x, r) = testCase ("intCast-" ++ x) (r `showsAs` "True")+         lhs x = sFromIntegral (literal x)+         rhs x = literal (fromIntegral x)+         cast :: forall a. (Show a, Integral a, SymWord a) => [a] -> [(String, SBool)]+         cast xs = toWords xs ++ toInts xs+         toWords xs =  [(show x, lhs x .== (rhs x :: SWord8 ))  | x <- xs]+                    ++ [(show x, lhs x .== (rhs x :: SWord16))  | x <- xs]+                    ++ [(show x, lhs x .== (rhs x :: SWord32))  | x <- xs]+                    ++ [(show x, lhs x .== (rhs x :: SWord64))  | x <- xs]+         toInts  xs =  [(show x, lhs x .== (rhs x :: SInt8 ))   | x <- xs]+                    ++ [(show x, lhs x .== (rhs x :: SInt16))   | x <- xs]+                    ++ [(show x, lhs x .== (rhs x :: SInt32))   | x <- xs]+                    ++ [(show x, lhs x .== (rhs x :: SInt64))   | x <- xs]+                    ++ [(show x, lhs x .== (rhs x :: SInteger)) | x <- xs]++genQRems :: [TestTree]+genQRems = map mkTest $+        zipWith pair [("divMod",  show x, show y, x `divMod0`  y) | x <- w8s,  y <- w8s ] [x `sDivMod`  y | x <- sw8s,  y <- sw8s ]+     ++ zipWith pair [("divMod",  show x, show y, x `divMod0`  y) | x <- w16s, y <- w16s] [x `sDivMod`  y | x <- sw16s, y <- sw16s]+     ++ zipWith pair [("divMod",  show x, show y, x `divMod0`  y) | x <- w32s, y <- w32s] [x `sDivMod`  y | x <- sw32s, y <- sw32s]+     ++ zipWith pair [("divMod",  show x, show y, x `divMod0`  y) | x <- w64s, y <- w64s] [x `sDivMod`  y | x <- sw64s, y <- sw64s]+     ++ zipWith pair [("divMod",  show x, show y, x `divMod1`  y) | x <- i8s,  y <- i8s ] [x `sDivMod`  y | x <- si8s,  y <- si8s ]+     ++ zipWith pair [("divMod",  show x, show y, x `divMod1`  y) | x <- i16s, y <- i16s] [x `sDivMod`  y | x <- si16s, y <- si16s]+     ++ zipWith pair [("divMod",  show x, show y, x `divMod1`  y) | x <- i32s, y <- i32s] [x `sDivMod`  y | x <- si32s, y <- si32s]+     ++ zipWith pair [("divMod",  show x, show y, x `divMod1`  y) | x <- i64s, y <- i64s] [x `sDivMod`  y | x <- si64s, y <- si64s]+     ++ zipWith pair [("divMod",  show x, show y, x `divMod0`  y) | x <- iUBs, y <- iUBs] [x `sDivMod`  y | x <- siUBs, y <- siUBs]+     ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w8s,  y <- w8s ] [x `sQuotRem` y | x <- sw8s,  y <- sw8s ]+     ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w16s, y <- w16s] [x `sQuotRem` y | x <- sw16s, y <- sw16s]+     ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w32s, y <- w32s] [x `sQuotRem` y | x <- sw32s, y <- sw32s]+     ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w64s, y <- w64s] [x `sQuotRem` y | x <- sw64s, y <- sw64s]+     ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i8s,  y <- i8s ] [x `sQuotRem` y | x <- si8s,  y <- si8s ]+     ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i16s, y <- i16s] [x `sQuotRem` y | x <- si16s, y <- si16s]+     ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i32s, y <- i32s] [x `sQuotRem` y | x <- si32s, y <- si32s]+     ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i64s, y <- i64s] [x `sQuotRem` y | x <- si64s, y <- si64s]+     ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- iUBs, y <- iUBs] [x `sQuotRem` y | x <- siUBs, y <- siUBs]+  where pair (nm, x, y, (r1, r2)) (e1, e2)   = (nm, x, y, show (fromIntegral r1 `asTypeOf` e1, fromIntegral r2 `asTypeOf` e2) == show (e1, e2))+        mkTest (nm, x, y, s) = testCase ("arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y) (s `showsAs` "True")+        -- Haskell's divMod and quotRem differs from SBV's in two ways:+        --     - when y is 0, Haskell throws an exception, SBV sets the result to 0; like in division+        --     - Haskell overflows if x == minBound and y == -1 for bounded signed types; but SBV returns minBound, 0; which is more meaningful+        -- NB. There was a ticket filed against the second anomaly above, See: https://ghc.haskell.org/trac/ghc/ticket/8695+        -- But the Haskell folks decided not to fix it. Sigh..+        overflow x y = x == minBound && y == -1+        divMod0  x y = if y == 0       then (0, x) else x `divMod`   y+        divMod1  x y = if overflow x y then (x, 0) else x `divMod0`  y+        quotRem0 x y = if y == 0       then (0, x) else x `quotRem`  y+        quotRem1 x y = if overflow x y then (x, 0) else x `quotRem0` y++genReals :: [TestTree]+genReals = map mkTest $+        map ("+",)  (zipWith pair [(show x, show y, x +  y) | x <- rs, y <- rs        ] [x +   y | x <- srs,  y <- srs                       ])+     ++ map ("-",)  (zipWith pair [(show x, show y, x -  y) | x <- rs, y <- rs        ] [x -   y | x <- srs,  y <- srs                       ])+     ++ map ("*",)  (zipWith pair [(show x, show y, x *  y) | x <- rs, y <- rs        ] [x *   y | x <- srs,  y <- srs                       ])+     ++ map ("<",)  (zipWith pair [(show x, show y, x <  y) | x <- rs, y <- rs        ] [x .<  y | x <- srs,  y <- srs                       ])+     ++ map ("<=",) (zipWith pair [(show x, show y, x <= y) | x <- rs, y <- rs        ] [x .<= y | x <- srs,  y <- srs                       ])+     ++ map (">",)  (zipWith pair [(show x, show y, x >  y) | x <- rs, y <- rs        ] [x .>  y | x <- srs,  y <- srs                       ])+     ++ map (">=",) (zipWith pair [(show x, show y, x >= y) | x <- rs, y <- rs        ] [x .>= y | x <- srs,  y <- srs                       ])+     ++ map ("==",) (zipWith pair [(show x, show y, x == y) | x <- rs, y <- rs        ] [x .== y | x <- srs,  y <- srs                       ])+     ++ map ("/=",) (zipWith pair [(show x, show y, x /= y) | x <- rs, y <- rs        ] [x ./= y | x <- srs,  y <- srs                       ])+     ++ map ("/",)  (zipWith pair [(show x, show y, x /  y) | x <- rs, y <- rs, y /= 0] [x / y   | x <- srs,  y <- srs, unliteral y /= Just 0])+  where pair (x, y, a) b   = (x, y, Just a == unliteral b)+        mkTest (nm, (x, y, s)) = testCase ("arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y) (s `showsAs` "True")++genFloats :: [TestTree]+genFloats = bTests ++ uTests ++ fpTests1 ++ fpTests2 ++ converts+  where bTests = map mkTest2 $  floatRun2  "+"  (+)  (+)   comb+                             ++ doubleRun2 "+"  (+)  (+)   comb++                             ++ floatRun2  "-"  (-)  (-)   comb+                             ++ doubleRun2 "-"  (-)  (-)   comb++                             ++ floatRun2  "*"  (*)  (*)   comb+                             ++ doubleRun2 "*"  (*)  (*)   comb++                             ++ floatRun2  "/"  (/)  (/)   comb+                             ++ doubleRun2 "/"  (/)  (/)   comb++                             ++ floatRun2  "<"  (<)  (.<)  combB+                             ++ doubleRun2 "<"  (<)  (.<)  combB++                             ++ floatRun2  "<=" (<=) (.<=) combB+                             ++ doubleRun2 "<=" (<=) (.<=) combB++                             ++ floatRun2  ">"  (>)  (.>)  combB+                             ++ doubleRun2 ">"  (>)  (.>)  combB++                             ++ floatRun2  ">=" (>=) (.>=) combB+                             ++ doubleRun2 ">=" (>=) (.>=) combB++                             ++ floatRun2  "==" (==) (.==) combB+                             ++ doubleRun2 "==" (==) (.==) combB++                             ++ floatRun2  "/=" (/=) (./=) combN+                             ++ doubleRun2 "/=" (/=) (./=) combN++        fpTests1 = map mkTest1 $  floatRun1   "abs"               abs                abs               comb1+                               ++ floatRun1   "fpAbs"             abs                fpAbs             comb1+                               ++ doubleRun1  "abs"               abs                abs               comb1+                               ++ doubleRun1  "fpAbs"             abs                fpAbs             comb1++                               ++ floatRun1   "negate"            negate             negate            comb1+                               ++ floatRun1   "fpNeg"             negate             fpNeg             comb1+                               ++ doubleRun1  "negate"            negate             negate            comb1+                               ++ doubleRun1  "fpNeg"             negate             fpNeg             comb1++                               ++ floatRun1M  "fpSqrt"            sqrt               fpSqrt            comb1+                               ++ doubleRun1M "fpSqrt"            sqrt               fpSqrt            comb1++                               ++ floatRun1M  "fpRoundToIntegral" fpRoundToIntegralH fpRoundToIntegral comb1+                               ++ doubleRun1M "fpRoundToIntegral" fpRoundToIntegralH fpRoundToIntegral comb1++                               ++ floatRun1   "signum"            signum             signum            comb1+                               ++ doubleRun1  "signum"            signum             signum            comb1++        -- TODO. Can't possibly test fma, unless we FFI out to C. Leave it out for the time being+        fpTests2 = map mkTest2 $  floatRun2M  "fpAdd"           (+)              fpAdd           comb+                               ++ doubleRun2M "fpAdd"           (+)              fpAdd           comb++                               ++ floatRun2M  "fpSub"           (-)              fpSub           comb+                               ++ doubleRun2M "fpSub"           (-)              fpSub           comb++                               ++ floatRun2M  "fpMul"           (*)              fpMul           comb+                               ++ doubleRun2M "fpMul"           (*)              fpMul           comb++                               ++ floatRun2M  "fpDiv"           (/)              fpDiv           comb+                               ++ doubleRun2M "fpDiv"           (/)              fpDiv           comb++                               ++ floatRunMM  "fpMin"           fpMinH           fpMin           comb+                               ++ doubleRunMM "fpMin"           fpMinH           fpMin           comb++                               ++ floatRunMM  "fpMax"           fpMaxH           fpMax           comb+                               ++ doubleRunMM "fpMax"           fpMaxH           fpMax           comb++                               ++ floatRun2   "fpRem"           fpRemH           fpRem           comb+                               ++ doubleRun2  "fpRem"           fpRemH           fpRem           comb++                               ++ floatRun2   "fpIsEqualObject" fpIsEqualObjectH fpIsEqualObject combE+                               ++ doubleRun2  "fpIsEqualObject" fpIsEqualObjectH fpIsEqualObject combE++        converts =  map cvtTest  [("toFP_Int8_ToFloat",     show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- i8s ]+                 ++ map cvtTest  [("toFP_Int16_ToFloat",    show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- i16s]+                 ++ map cvtTest  [("toFP_Int32_ToFloat",    show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- i32s]+                 ++ map cvtTest  [("toFP_Int64_ToFloat",    show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- i64s]+                 ++ map cvtTest  [("toFP_Word8_ToFloat",    show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- w8s ]+                 ++ map cvtTest  [("toFP_Word16_ToFloat",   show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- w16s]+                 ++ map cvtTest  [("toFP_Word32_ToFloat",   show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- w32s]+                 ++ map cvtTest  [("toFP_Word64_ToFloat",   show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- w64s]+                 ++ map cvtTest  [("toFP_Float_ToFloat",    show x, toSFloat  sRNE (literal x),                  literal x ) | x <- fs  ]+                 ++ map cvtTest  [("toFP_Double_ToFloat",   show x, toSFloat  sRNE (literal x),           literal (fp2fp x)) | x <- ds  ]+                 ++ map cvtTest  [("toFP_Integer_ToFloat",  show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- iUBs]+                 ++ map cvtTest  [("toFP_Real_ToFloat",     show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- rs  ]++                 ++ map cvtTest  [("toFP_Int8_ToDouble",    show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i8s ]+                 ++ map cvtTest  [("toFP_Int16_ToDouble",   show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i16s]+                 ++ map cvtTest  [("toFP_Int32_ToDouble",   show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i32s]+                 ++ map cvtTest  [("toFP_Int64_ToDouble",   show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i64s]+                 ++ map cvtTest  [("toFP_Word8_ToDouble",   show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w8s ]+                 ++ map cvtTest  [("toFP_Word16_ToDouble",  show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w16s]+                 ++ map cvtTest  [("toFP_Word32_ToDouble",  show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w32s]+                 ++ map cvtTest  [("toFP_Word64_ToDouble",  show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w64s]+                 ++ map cvtTest  [("toFP_Float_ToDouble",   show x, toSDouble sRNE (literal x),           literal (fp2fp x)) | x <- fs  ]+                 ++ map cvtTest  [("toFP_Double_ToDouble",  show x, toSDouble sRNE (literal x),                   literal x) | x <- ds  ]+                 ++ map cvtTest  [("toFP_Integer_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- iUBs]+                 ++ map cvtTest  [("toFP_Real_ToDouble",    show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- rs  ]++                 ++ map cvtTestI [("fromFP_Float_ToInt8",    show x, (fromSFloat sRNE :: SFloat -> SInt8)    (literal x), ((fromIntegral :: Integer -> SInt8)    . fpRound0) x) | x <- fs]+                 ++ map cvtTestI [("fromFP_Float_ToInt16",   show x, (fromSFloat sRNE :: SFloat -> SInt16)   (literal x), ((fromIntegral :: Integer -> SInt16)   . fpRound0) x) | x <- fs]+                 ++ map cvtTestI [("fromFP_Float_ToInt32",   show x, (fromSFloat sRNE :: SFloat -> SInt32)   (literal x), ((fromIntegral :: Integer -> SInt32)   . fpRound0) x) | x <- fs]+                 ++ map cvtTestI [("fromFP_Float_ToInt64",   show x, (fromSFloat sRNE :: SFloat -> SInt64)   (literal x), ((fromIntegral :: Integer -> SInt64)   . fpRound0) x) | x <- fs]+                 ++ map cvtTestI [("fromFP_Float_ToWord8",   show x, (fromSFloat sRNE :: SFloat -> SWord8)   (literal x), ((fromIntegral :: Integer -> SWord8)   . fpRound0) x) | x <- fs]+                 ++ map cvtTestI [("fromFP_Float_ToWord16",  show x, (fromSFloat sRNE :: SFloat -> SWord16)  (literal x), ((fromIntegral :: Integer -> SWord16)  . fpRound0) x) | x <- fs]+                 ++ map cvtTestI [("fromFP_Float_ToWord32",  show x, (fromSFloat sRNE :: SFloat -> SWord32)  (literal x), ((fromIntegral :: Integer -> SWord32)  . fpRound0) x) | x <- fs]+                 ++ map cvtTestI [("fromFP_Float_ToWord64",  show x, (fromSFloat sRNE :: SFloat -> SWord64)  (literal x), ((fromIntegral :: Integer -> SWord64)  . fpRound0) x) | x <- fs]+                 ++ map cvtTest  [("fromFP_Float_ToFloat",   show x, (fromSFloat sRNE :: SFloat -> SFloat)   (literal x),                                            literal x) | x <- fs]+                 ++ map cvtTest  [("fromFP_Float_ToDouble",  show x, (fromSFloat sRNE :: SFloat -> SDouble)  (literal x),                                 (literal .  fp2fp) x) | x <- fs]+                 ++ map cvtTestI [("fromFP_Float_ToInteger", show x, (fromSFloat sRNE :: SFloat -> SInteger) (literal x), ((fromIntegral :: Integer -> SInteger) . fpRound0) x) | x <- fs]+                 ++ map cvtTestI [("fromFP_Float_ToReal",    show x, (fromSFloat sRNE :: SFloat -> SReal)    (literal x),                          (fromRational . fpRatio0) x) | x <- fs]++                 ++ map cvtTestI [("fromFP_Double_ToInt8",    show x, (fromSDouble sRNE :: SDouble -> SInt8)    (literal x), ((fromIntegral :: Integer -> SInt8)    . fpRound0) x) | x <- ds]+                 ++ map cvtTestI [("fromFP_Double_ToInt16",   show x, (fromSDouble sRNE :: SDouble -> SInt16)   (literal x), ((fromIntegral :: Integer -> SInt16)   . fpRound0) x) | x <- ds]+                 ++ map cvtTestI [("fromFP_Double_ToInt32",   show x, (fromSDouble sRNE :: SDouble -> SInt32)   (literal x), ((fromIntegral :: Integer -> SInt32)   . fpRound0) x) | x <- ds]+                 ++ map cvtTestI [("fromFP_Double_ToInt64",   show x, (fromSDouble sRNE :: SDouble -> SInt64)   (literal x), ((fromIntegral :: Integer -> SInt64)   . fpRound0) x) | x <- ds]+                 ++ map cvtTestI [("fromFP_Double_ToWord8",   show x, (fromSDouble sRNE :: SDouble -> SWord8)   (literal x), ((fromIntegral :: Integer -> SWord8)   . fpRound0) x) | x <- ds]+                 ++ map cvtTestI [("fromFP_Double_ToWord16",  show x, (fromSDouble sRNE :: SDouble -> SWord16)  (literal x), ((fromIntegral :: Integer -> SWord16)  . fpRound0) x) | x <- ds]+                 ++ map cvtTestI [("fromFP_Double_ToWord32",  show x, (fromSDouble sRNE :: SDouble -> SWord32)  (literal x), ((fromIntegral :: Integer -> SWord32)  . fpRound0) x) | x <- ds]+                 ++ map cvtTestI [("fromFP_Double_ToWord64",  show x, (fromSDouble sRNE :: SDouble -> SWord64)  (literal x), ((fromIntegral :: Integer -> SWord64)  . fpRound0) x) | x <- ds]+                 ++ map cvtTest  [("fromFP_Double_ToFloat",   show x, (fromSDouble sRNE :: SDouble -> SFloat)   (literal x),                                (literal  .  fp2fp) x) | x <- ds]+                 ++ map cvtTest  [("fromFP_Double_ToDouble",  show x, (fromSDouble sRNE :: SDouble -> SDouble)  (literal x),                                            literal x) | x <- ds]+                 ++ map cvtTestI [("fromFP_Double_ToInteger", show x, (fromSDouble sRNE :: SDouble -> SInteger) (literal x), ((fromIntegral :: Integer -> SInteger) . fpRound0) x) | x <- ds]+                 ++ map cvtTestI [("fromFP_Double_ToReal",    show x, (fromSDouble sRNE :: SDouble -> SReal)    (literal x),                          (fromRational . fpRatio0) x) | x <- ds]++                 ++ map cvtTest  [("reinterp_Word32_Float",  show x, sWord32AsSFloat  (literal x), literal (DB.wordToFloat  x)) | x <- w32s]+                 ++ map cvtTest  [("reinterp_Word64_Double", show x, sWord64AsSDouble (literal x), literal (DB.wordToDouble x)) | x <- w64s]++                 ++ map cvtTestI [("reinterp_Float_Word32",  show x, sFloatAsSWord32  (literal x), literal (DB.floatToWord x))  | x <- fs, not (isNaN x)] -- Not unique for NaN+                 ++ map cvtTestI [("reinterp_Double_Word64", show x, sDoubleAsSWord64 (literal x), literal (DB.doubleToWord x)) | x <- ds, not (isNaN x)] -- Not unique for NaN++        floatRun1   nm f g cmb = map (nm,) [cmb (x,    f x,   extract (g                         (literal x)))             | x <- fs]+        doubleRun1  nm f g cmb = map (nm,) [cmb (x,    f x,   extract (g                         (literal x)))             | x <- ds]+        floatRun1M  nm f g cmb = map (nm,) [cmb (x,    f x,   extract (g sRNE (literal x)))                                | x <- fs]+        doubleRun1M nm f g cmb = map (nm,) [cmb (x,    f x,   extract (g sRNE (literal x)))                                | x <- ds]+        floatRun2   nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g                         (literal x) (literal y))) | x <- fs, y <- fs]+        doubleRun2  nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g                         (literal x) (literal y))) | x <- ds, y <- ds]+        floatRun2M  nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g sRNE (literal x) (literal y))) | x <- fs, y <- fs]+        doubleRun2M nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g sRNE (literal x) (literal y))) | x <- ds, y <- ds]+        floatRunMM  nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g                         (literal x) (literal y))) | x <- fs, y <- fs, not (alt0 x y || alt0 y x)]+        doubleRunMM nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g                         (literal x) (literal y))) | x <- ds, y <- ds, not (alt0 x y || alt0 y x)]+        -- fpMin/fpMax: skip +0/-0 case as this is underspecified+        alt0 x y = isNegativeZero x && y == 0 && not (isNegativeZero y)+        uTests = map mkTest1 $  concatMap (checkPred fs sfs) predicates+                             ++ concatMap (checkPred ds sds) predicates+        extract :: SymWord a => SBV a -> a+        extract = fromJust . unliteral++        comb  (x, y, a, b) = (show x, show y, same a b)+        combB (x, y, a, b) = (show x, show y, checkNaN f x y a b) where f v w = not (v || w)  -- All comparisons except /=: Both should be False if we have a NaN argument+        combN (x, y, a, b) = (show x, show y, checkNaN f x y a b) where f v w =      v && w   -- /=: Both should be True+        combE (x, y, a, b) = (show x, show y, a == b)+        comb1 (x, a, b)    = (show x, same a b)+        same a b = (isNaN a &&& isNaN b) || (a == b)+        checkNaN f x y a b+          | isNaN x || isNaN y = f a b+          | True               = a == b++        cvtTest  (nm, x, a, b)  = testCase ("arithCF-" ++ nm ++ "." ++ x) (same (extract a) (extract b) `showsAs` "True")+        cvtTestI (nm, x, a, b)  = testCase ("arithCF-" ++ nm ++ "." ++ x) ((a == b) `showsAs` "True")++        mkTest1 (nm, (x, s))    = testCase ("arithCF-" ++ nm ++ "." ++ x) (s `showsAs` "True")+        mkTest2 (nm, (x, y, s)) = testCase ("arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y) (s `showsAs` "True")++        checkPred :: Show a => [a] -> [SBV a] -> (String, SBV a -> SBool, a -> Bool) -> [(String, (String, Bool))]+        checkPred xs sxs (n, ps, p) = zipWith (chk n) (map (\x -> (x, p x)) xs) (map ps sxs)+          where chk nm (x, v) sv = (nm, (show x, Just v == unliteral sv))++        predicates :: IEEEFloating a => [(String, SBV a -> SBool, a -> Bool)]+        predicates = [ ("fpIsNormal",       fpIsNormal,        fpIsNormalizedH)+                     , ("fpIsSubnormal",    fpIsSubnormal,     isDenormalized)+                     , ("fpIsZero",         fpIsZero,          (== 0))+                     , ("fpIsInfinite",     fpIsInfinite,      isInfinite)+                     , ("fpIsNaN",          fpIsNaN,           isNaN)+                     , ("fpIsNegative",     fpIsNegative,      \x -> x < 0  ||      isNegativeZero x)+                     , ("fpIsPositive",     fpIsPositive,      \x -> x >= 0 && not (isNegativeZero x))+                     , ("fpIsNegativeZero", fpIsNegativeZero,  isNegativeZero)+                     , ("fpIsPositiveZero", fpIsPositiveZero,  \x -> x == 0 && not (isNegativeZero x))+                     , ("fpIsPoint",        fpIsPoint,         \x -> not (isNaN x || isInfinite x))+                     ]++-- Concrete test data+xsUnsigned :: (Num a, Bounded a) => [a]+xsUnsigned = take 5 (iterate (1+) minBound) ++ take 5 (iterate (\x -> x-1) maxBound)++xsSigned :: (Num a, Enum a, Bounded a) => [a]+xsSigned   = xsUnsigned ++ [-5 .. 5]++w8s :: [Word8]+w8s = xsUnsigned++sw8s :: [SWord8]+sw8s = xsUnsigned++w16s :: [Word16]+w16s = xsUnsigned++sw16s :: [SWord16]+sw16s = xsUnsigned++w32s :: [Word32]+w32s = xsUnsigned++sw32s :: [SWord32]+sw32s = xsUnsigned++w64s :: [Word64]+w64s = xsUnsigned++sw64s :: [SWord64]+sw64s = xsUnsigned++i8s :: [Int8]+i8s = xsSigned++si8s :: [SInt8]+si8s = xsSigned++i16s :: [Int16]+i16s = xsSigned++si16s :: [SInt16]+si16s = xsSigned++i32s :: [Int32]+i32s = xsSigned++si32s :: [SInt32]+si32s = xsSigned++i64s :: [Int64]+i64s = xsSigned++si64s :: [SInt64]+si64s = xsSigned++iUBs :: [Integer]+iUBs = [-1000000 .. -999995] ++ [-5 .. 5] ++ [999995 ..  1000000]++siUBs :: [SInteger]+siUBs = map literal iUBs++rs :: [AlgReal]+rs = [fromRational (i % d) | i <- nums, d <- dens]+ where nums = [-1000000 .. -999998] ++ [-2 .. 2] ++ [999998 ..  1000001]+       dens = [2 .. 5] ++ [98 .. 102] ++ [999998 .. 1000000]++srs :: [SReal]+srs = map literal rs++fs :: [Float]+fs = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan+ where xs = [nan, infinity, 0, 0.5, 0.68302244, 0.5268265, 0.10283524, 5.8336496e-2, 1.0e-45]++sfs :: [SFloat]+sfs = map literal fs++ds :: [Double]+ds = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan+ where xs = [nan, infinity, 0, 0.5, 2.516632060108026e-2, 0.8601891300751106, 7.518897767550192e-2, 1.1656043286207285e-2, 5.0e-324]++sds :: [SDouble]+sds = map literal ds
+ SBVTestSuite/TestSuite/Basics/ArithSolver.hs view
@@ -0,0 +1,483 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.ArithSolver+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for basic non-concrete arithmetic, i.e., testing all+-- basic arithmetic reasoning using an SMT solver without any+-- constant folding.+-----------------------------------------------------------------------------++{-# LANGUAGE Rank2Types    #-}++module TestSuite.Basics.ArithSolver(tests) where++import Data.Maybe (fromMaybe)+import qualified Data.Binary.IEEE754 as DB (wordToFloat, wordToDouble, floatToWord, doubleToWord)++import Data.SBV.Internals+import Utils.SBVTestFramework++ghcBitSize :: Bits a => a -> Int+ghcBitSize x = fromMaybe (error "SBV.ghcBitSize: Unexpected non-finite usage!") (bitSizeMaybe x)++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.ArithSolver"+   (    genReals+     ++ genFloats+     ++ genDoubles+     ++ genFPConverts+     ++ genQRems+     ++ genBinTest  True   "+"                (+)+     ++ genBinTest  True   "-"                (-)+     ++ genBinTest  True   "*"                (*)+     ++ genUnTest   True   "negate"           negate+     ++ genUnTest   True   "abs"              abs+     ++ genUnTest   True   "signum"           signum+     ++ genBinTest  False  ".&."              (.&.)+     ++ genBinTest  False  ".|."              (.|.)+     ++ genBoolTest        "<"                (<)  (.<)+     ++ genBoolTest        "<="               (<=) (.<=)+     ++ genBoolTest        ">"                (>)  (.>)+     ++ genBoolTest        ">="               (>=) (.>=)+     ++ genBoolTest        "=="               (==) (.==)+     ++ genBoolTest        "/="               (/=) (./=)+     ++ genBinTest  False  "xor"              xor+     ++ genUnTest   False  "complement"       complement+     ++ genIntTest         "shift"            shift+     ++ genIntTest         "rotate"           rotate+     ++ genIntTestS False  "setBit"           setBit+     ++ genIntTestS False  "clearBit"         clearBit+     ++ genIntTestS False  "complementBit"    complementBit+     ++ genIntTest         "shift"            shift+     ++ genIntTestS True   "shiftL"           shiftL+     ++ genIntTestS True   "shiftR"           shiftR+     ++ genIntTest         "rotate"           rotate+     ++ genIntTestS True   "rotateL"          rotateL+     ++ genIntTestS True   "rotateR"          rotateR+     ++ genBlasts+     ++ genIntCasts)++genBinTest :: Bool -> String -> (forall a. (Num a, Bits a) => a -> a -> a) -> [TestTree]+genBinTest unboundedOK nm op = map mkTest $  [(show x, show y, mkThm2 x y (x `op` y)) | x <- w8s,  y <- w8s ]+                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- w16s]+                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- w32s]+                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- w64s]+                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i8s,  y <- i8s ]+                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- i16s]+                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- i32s]+                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- i64s]+                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | unboundedOK, x <- iUBs, y <- iUBs]+  where mkTest (x, y, t) = testCase ("genBinTest.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y) (assert t)+        mkThm2 x y r = isTheorem $ do [a, b] <- mapM free ["x", "y"]+                                      constrain $ a .== literal x+                                      constrain $ b .== literal y+                                      return $ literal r .== a `op` b++genBoolTest :: String -> (forall a. Ord a => a -> a -> Bool) -> (forall a. OrdSymbolic a => a -> a -> SBool) -> [TestTree]+genBoolTest nm op opS = map mkTest $  [(show x, show y, mkThm2 x y (x `op` y)) | x <- w8s,  y <- w8s ]+                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- w16s]+                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- w32s]+                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- w64s]+                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i8s,  y <- i8s ]+                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- i16s]+                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- i32s]+                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- i64s]+                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- iUBs, y <- iUBs]+  where mkTest (x, y, t) = testCase ("genBoolTest.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y) (assert t)+        mkThm2 x y r = isTheorem $ do [a, b] <- mapM free ["x", "y"]+                                      constrain $ a .== literal x+                                      constrain $ b .== literal y+                                      return $ literal r .== a `opS` b++genUnTest :: Bool -> String -> (forall a. (Num a, Bits a) => a -> a) -> [TestTree]+genUnTest unboundedOK nm op = map mkTest $  [(show x, mkThm x (op x)) | x <- w8s ]+                                         ++ [(show x, mkThm x (op x)) | x <- w16s]+                                         ++ [(show x, mkThm x (op x)) | x <- w32s]+                                         ++ [(show x, mkThm x (op x)) | x <- w64s]+                                         ++ [(show x, mkThm x (op x)) | x <- i8s ]+                                         ++ [(show x, mkThm x (op x)) | x <- i16s]+                                         ++ [(show x, mkThm x (op x)) | x <- i32s]+                                         ++ [(show x, mkThm x (op x)) | x <- i64s]+                                         ++ [(show x, mkThm x (op x)) | unboundedOK, x <- iUBs]+  where mkTest (x, t) = testCase ("genUnTest.arithmetic-" ++ nm ++ "." ++ x) (assert t)+        mkThm x r = isTheorem $ do a <- free "x"+                                   constrain $ a .== literal x+                                   return $ literal r .== op a++genIntTest :: String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [TestTree]+genIntTest nm op = map mkTest $  [("u8",  show x, show y, mkThm2 x y (x `op` y)) | x <- w8s,  y <- is]+                              ++ [("u16", show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- is]+                              ++ [("u32", show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- is]+                              ++ [("u64", show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- is]+                              ++ [("s8",  show x, show y, mkThm2 x y (x `op` y)) | x <- i8s,  y <- is]+                              ++ [("s16", show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- is]+                              ++ [("s32", show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- is]+                              ++ [("s64", show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- is]+                              ++ [("iUB", show x, show y, mkThm2 x y (x `op` y)) | x <- iUBs, y <- is]+  where mkTest (l, x, y, t) = testCase ("genIntTest.arithmetic-" ++ nm ++ "." ++ l ++ "_" ++ x ++ "_" ++ y) (assert t)+        is = [-10 .. 10]+        mkThm2 x y r = isTheorem $ do a <- free "x"+                                      constrain $ a .== literal x+                                      return $ literal r .== a `op` y+++genIntTestS :: Bool -> String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [TestTree]+genIntTestS unboundedOK nm op = map mkTest $  [("u8",  show x, show y, mkThm2 x y (x `op` y)) | x <- w8s,  y <- [0 .. (ghcBitSize x - 1)]]+                                           ++ [("u16", show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- [0 .. (ghcBitSize x - 1)]]+                                           ++ [("u32", show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- [0 .. (ghcBitSize x - 1)]]+                                           ++ [("u64", show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- [0 .. (ghcBitSize x - 1)]]+                                           ++ [("s8",  show x, show y, mkThm2 x y (x `op` y)) | x <- i8s,  y <- [0 .. (ghcBitSize x - 1)]]+                                           ++ [("s16", show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- [0 .. (ghcBitSize x - 1)]]+                                           ++ [("s32", show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- [0 .. (ghcBitSize x - 1)]]+                                           ++ [("s64", show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- [0 .. (ghcBitSize x - 1)]]+                                           ++ [("iUB", show x, show y, mkThm2 x y (x `op` y)) | unboundedOK, x <- iUBs, y <- [0 .. 10]]+  where mkTest (l, x, y, t) = testCase ("genIntTestS.arithmetic-" ++ nm ++ "." ++ l ++ "_" ++ x ++ "_" ++ y) (assert t)+        mkThm2 x y r = isTheorem $ do a <- free "x"+                                      constrain $ a .== literal x+                                      return $ literal r .== a `op` y++genBlasts :: [TestTree]+genBlasts = map mkTest $  [(show x, mkThm fromBitsLE blastLE x) | x <- w8s ]+                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w8s ]+                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i8s ]+                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i8s ]+                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- w16s]+                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w16s]+                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i16s]+                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i16s]+                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- w32s]+                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w32s]+                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i32s]+                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i32s]+                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- w64s]+                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w64s]+                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i64s]+                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i64s]+  where mkTest (x, t) = testCase ("genBlasts.blast-" ++ show x) (assert t)+        mkThm from to v = isTheorem $ do a <- free "x"+                                         constrain $ a .== literal v+                                         return $ a .== from (to a)++genIntCasts :: [TestTree]+genIntCasts = map mkTest $  cast w8s ++ cast w16s ++ cast w32s ++ cast w64s+                         ++ cast i8s ++ cast i16s ++ cast i32s ++ cast i64s+                         ++ cast iUBs+   where mkTest (x, t) = testCase ("sIntCast-" ++ x) (assert t)+         cast :: forall a. (Show a, Integral a, SymWord a) => [a] -> [(String, IO Bool)]+         cast xs = toWords xs ++ toInts xs+         toWords xs =  [(show x, mkThm x (fromIntegral x :: Word8 ))  | x <- xs]+                    ++ [(show x, mkThm x (fromIntegral x :: Word16))  | x <- xs]+                    ++ [(show x, mkThm x (fromIntegral x :: Word32))  | x <- xs]+                    ++ [(show x, mkThm x (fromIntegral x :: Word64))  | x <- xs]+         toInts  xs =  [(show x, mkThm x (fromIntegral x :: Int8 ))   | x <- xs]+                    ++ [(show x, mkThm x (fromIntegral x :: Int16))   | x <- xs]+                    ++ [(show x, mkThm x (fromIntegral x :: Int32))   | x <- xs]+                    ++ [(show x, mkThm x (fromIntegral x :: Int64))   | x <- xs]+                    ++ [(show x, mkThm x (fromIntegral x :: Integer)) | x <- xs]+         mkThm v res = isTheorem $ do a <- free "x"+                                      constrain $ a .== literal v+                                      return $ literal res .== sFromIntegral a++genReals :: [TestTree]+genReals = map mkTest $  [("+",  show x, show y, mkThm2 (+)   x y (x +  y)) | x <- rs, y <- rs        ]+                      ++ [("-",  show x, show y, mkThm2 (-)   x y (x -  y)) | x <- rs, y <- rs        ]+                      ++ [("*",  show x, show y, mkThm2 (*)   x y (x *  y)) | x <- rs, y <- rs        ]+                      ++ [("/",  show x, show y, mkThm2 (/)   x y (x /  y)) | x <- rs, y <- rs, y /= 0]+                      ++ [("<",  show x, show y, mkThm2 (.<)  x y (x <  y)) | x <- rs, y <- rs        ]+                      ++ [("<=", show x, show y, mkThm2 (.<=) x y (x <= y)) | x <- rs, y <- rs        ]+                      ++ [(">",  show x, show y, mkThm2 (.>)  x y (x >  y)) | x <- rs, y <- rs        ]+                      ++ [(">=", show x, show y, mkThm2 (.>=) x y (x >= y)) | x <- rs, y <- rs        ]+                      ++ [("==", show x, show y, mkThm2 (.==) x y (x == y)) | x <- rs, y <- rs        ]+                      ++ [("/=", show x, show y, mkThm2 (./=) x y (x /= y)) | x <- rs, y <- rs        ]+  where mkTest (nm, x, y, t) = testCase ("genReals.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y) (assert t)+        mkThm2 op x y r = isTheorem $ do [a, b] <- mapM free ["x", "y"]+                                         constrain $ a .== literal x+                                         constrain $ b .== literal y+                                         return $ literal r .== a `op` b++genFloats :: [TestTree]+genFloats = genIEEE754 "genFloats" fs++genDoubles :: [TestTree]+genDoubles = genIEEE754 "genDoubles" ds++genIEEE754 :: (IEEEFloating a, Show a) => String -> [a] -> [TestTree]+genIEEE754 origin vs =  map tst1 [("pred_"   ++ nm, x, y)    | (nm, x, y)    <- preds]+                     ++ map tst1 [("unary_"  ++ nm, x, y)    | (nm, x, y)    <- uns]+                     ++ map tst2 [("binary_" ++ nm, x, y, r) | (nm, x, y, r) <- bins]+  where uns =     [("abs",               show x, mkThm1 abs                   x  (abs x))                | x <- vs]+               ++ [("negate",            show x, mkThm1 negate                x  (negate x))             | x <- vs]+               ++ [("signum",            show x, mkThm1 signum                x  (signum x))             | x <- vs]+               ++ [("fpAbs",             show x, mkThm1 fpAbs                 x  (abs x))                | x <- vs]+               ++ [("fpNeg",             show x, mkThm1 fpNeg                 x  (negate x))             | x <- vs]+               ++ [("fpSqrt",            show x, mkThm1 (m fpSqrt)            x  (sqrt   x))             | x <- vs]+               ++ [("fpRoundToIntegral", show x, mkThm1 (m fpRoundToIntegral) x  (fpRoundToIntegralH x)) | x <- vs]++        bins =    [("+",      show x,  show y, mkThm2        (+)       x y (x +  y))   | x <- vs, y <- vs]+               ++ [("-",      show x,  show y, mkThm2        (-)       x y (x -  y))   | x <- vs, y <- vs]+               ++ [("*",      show x,  show y, mkThm2        (*)       x y (x *  y))   | x <- vs, y <- vs]+               ++ [("/",      show x,  show y, mkThm2        (/)       x y (x /  y))   | x <- vs, y <- vs]+               ++ [("<",      show x,  show y, mkThm2C False (.<)      x y (x <  y))   | x <- vs, y <- vs]+               ++ [("<=",     show x,  show y, mkThm2C False (.<=)     x y (x <= y))   | x <- vs, y <- vs]+               ++ [(">",      show x,  show y, mkThm2C False (.>)      x y (x >  y))   | x <- vs, y <- vs]+               ++ [(">=",     show x,  show y, mkThm2C False (.>=)     x y (x >= y))   | x <- vs, y <- vs]+               ++ [("==",     show x,  show y, mkThm2C False (.==)     x y (x == y))   | x <- vs, y <- vs]+               ++ [("/=",     show x,  show y, mkThm2C True  (./=)     x y (x /= y))   | x <- vs, y <- vs]+               -- TODO. Can't possibly test fma, unless we FFI out to C. Leave it out for the time being+               ++ [("fpAdd",           show x, show y, mkThm2  (m fpAdd)        x y ((+)              x y)) | x <- vs, y <- vs]+               ++ [("fpSub",           show x, show y, mkThm2  (m fpSub)        x y ((-)              x y)) | x <- vs, y <- vs]+               ++ [("fpMul",           show x, show y, mkThm2  (m fpMul)        x y ((*)              x y)) | x <- vs, y <- vs]+               ++ [("fpDiv",           show x, show y, mkThm2  (m fpDiv)        x y ((/)              x y)) | x <- vs, y <- vs]+               ++ [("fpMin",           show x, show y, mkThm2  fpMin            x y (fpMinH           x y)) | x <- vs, y <- vs, not (alt0 x y || alt0 y x)]+               ++ [("fpMax",           show x, show y, mkThm2  fpMax            x y (fpMaxH           x y)) | x <- vs, y <- vs, not (alt0 x y || alt0 y x)]+               ++ [("fpIsEqualObject", show x, show y, mkThm2P fpIsEqualObject  x y (fpIsEqualObjectH x y)) | x <- vs, y <- vs]+               ++ [("fpRem",           show x, show y, mkThm2  fpRem            x y (fpRemH           x y)) | x <- vsFPRem, y <- vsFPRem]++        -- TODO: For doubles fpRem takes too long, so we only do a subset+        vsFPRem+          | origin == "genDoubles" = [nan, infinity, 0, 0.5, -infinity, -0, -0.5]+          | True                   = vs++        -- fpMin/fpMax: skip +0/-0 case as this is underspecified+        alt0 x y = isNegativeZero x && y == 0 && not (isNegativeZero y)++        m f = f sRNE++        preds =   [(pn, show x, mkThmP ps x (pc x)) | (pn, ps, pc) <- predicates, x <- vs]+        tst2 (nm, x, y, t) = testCase (origin ++ ".arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y) (assert t)+        tst1 (nm, x,    t) = testCase (origin ++ ".arithmetic-" ++ nm ++ "." ++ x) (assert t)++        eqF v val+          | isNaN          val        = constrain $ fpIsNaN v+          | isNegativeZero val        = constrain $ fpIsNegativeZero v+          | val == 0                  = constrain $ fpIsPositiveZero v+          | isInfinite val && val > 0 = constrain $ fpIsInfinite v &&& fpIsPositive v+          | isInfinite val && val < 0 = constrain $ fpIsInfinite v &&& fpIsNegative v+          | True                      = constrain $ v .== literal val++        -- Quickly pick which solver to use. Currently z3 or mathSAT supports FP+        fpProver :: SMTConfig+        fpProver = z3 -- mathSAT++        fpThm :: Provable a => a -> IO Bool+        fpThm = isTheoremWith fpProver++        mkThmP op x r = fpThm $ do a <- free "x"+                                   eqF a x+                                   return $ literal r .== op a++        mkThm2P op x y r = fpThm $ do [a, b] <- mapM free ["x", "y"]+                                      eqF a x+                                      eqF b y+                                      return $ literal r .== a `op` b++        mkThm1 op x r = fpThm $ do a <- free "x"+                                   eqF a x+                                   return $ literal r `fpIsEqualObject` op a++        mkThm2 op x y r = fpThm $ do [a, b] <- mapM free ["x", "y"]+                                     eqF a x+                                     eqF b y+                                     return $ literal r `fpIsEqualObject` (a `op` b)++        mkThm2C neq op x y r = fpThm $ do [a, b] <- mapM free ["x", "y"]+                                          eqF a x+                                          eqF b y+                                          return $ if isNaN x || isNaN y+                                                   then (if neq then a `op` b else bnot (a `op` b))+                                                   else literal r .== a `op` b++        predicates :: (IEEEFloating a) => [(String, SBV a -> SBool, a -> Bool)]+        predicates = [ ("fpIsNormal",       fpIsNormal,        fpIsNormalizedH)+                     , ("fpIsSubnormal",    fpIsSubnormal,     isDenormalized)+                     , ("fpIsZero",         fpIsZero,          (== 0))+                     , ("fpIsInfinite",     fpIsInfinite,      isInfinite)+                     , ("fpIsNaN",          fpIsNaN,           isNaN)+                     , ("fpIsNegative",     fpIsNegative,      \x -> x < 0  ||      isNegativeZero x)+                     , ("fpIsPositive",     fpIsPositive,      \x -> x >= 0 && not (isNegativeZero x))+                     , ("fpIsNegativeZero", fpIsNegativeZero,  isNegativeZero)+                     , ("fpIsPositiveZero", fpIsPositiveZero,  \x -> x == 0 && not (isNegativeZero x))+                     , ("fpIsPoint",        fpIsPoint,         \x -> not (isNaN x || isInfinite x))+                     ]++genFPConverts :: [TestTree]+genFPConverts = map tst1 [("fpCast_" ++ nm, x, y) | (nm, x, y) <- converts]+  where converts =   [("toFP_Int8_ToFloat",     show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i8s ]+                 ++  [("toFP_Int16_ToFloat",    show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i16s]+                 ++  [("toFP_Int32_ToFloat",    show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i32s]+                 ++  [("toFP_Int64_ToFloat",    show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i64s]+                 ++  [("toFP_Word8_ToFloat",    show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w8s ]+                 ++  [("toFP_Word16_ToFloat",   show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w16s]+                 ++  [("toFP_Word32_ToFloat",   show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w32s]+                 ++  [("toFP_Word64_ToFloat",   show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w64s]+                 ++  [("toFP_Float_ToFloat",    show x, mkThm1 (m toSFloat) x                           x  ) | x <- fs  ]+                 ++  [("toFP_Double_ToFloat",   show x, mkThm1 (m toSFloat) x (                   fp2fp x )) | x <- ds  ]+                 ++  [("toFP_Integer_ToFloat",  show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- iUBs]+                 ++  [("toFP_Real_ToFloat",     show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- rs  ]++                 ++  [("toFP_Int8_ToDouble",    show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i8s ]+                 ++  [("toFP_Int16_ToDouble",   show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i16s]+                 ++  [("toFP_Int32_ToDouble",   show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i32s]+                 ++  [("toFP_Int64_ToDouble",   show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i64s]+                 ++  [("toFP_Word8_ToDouble",   show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w8s ]+                 ++  [("toFP_Word16_ToDouble",  show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w16s]+                 ++  [("toFP_Word32_ToDouble",  show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w32s]+                 ++  [("toFP_Word64_ToDouble",  show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w64s]+                 ++  [("toFP_Float_ToDouble",   show x, mkThm1 (m toSDouble) x (                   fp2fp x )) | x <- fs  ]+                 ++  [("toFP_Double_ToDouble",  show x, mkThm1 (m toSDouble) x                           x )  | x <- ds  ]+                 ++  [("toFP_Integer_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- iUBs]+                 ++  [("toFP_Real_ToDouble",    show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- rs  ]++                 ++  [("fromFP_Float_ToInt8",    show x, mkThmC' (m fromSFloat :: SFloat -> SInt8)    x (((fromIntegral :: Integer -> Int8)    . fpRound0) x)) | x <- fs]+                 ++  [("fromFP_Float_ToInt16",   show x, mkThmC' (m fromSFloat :: SFloat -> SInt16)   x (((fromIntegral :: Integer -> Int16)   . fpRound0) x)) | x <- fs]+                 ++  [("fromFP_Float_ToInt32",   show x, mkThmC' (m fromSFloat :: SFloat -> SInt32)   x (((fromIntegral :: Integer -> Int32)   . fpRound0) x)) | x <- fs]+                 ++  [("fromFP_Float_ToInt64",   show x, mkThmC' (m fromSFloat :: SFloat -> SInt64)   x (((fromIntegral :: Integer -> Int64)   . fpRound0) x)) | x <- fs]+                 ++  [("fromFP_Float_ToWord8",   show x, mkThmC' (m fromSFloat :: SFloat -> SWord8)   x (((fromIntegral :: Integer -> Word8)   . fpRound0) x)) | x <- fs]+                 ++  [("fromFP_Float_ToWord16",  show x, mkThmC' (m fromSFloat :: SFloat -> SWord16)  x (((fromIntegral :: Integer -> Word16)  . fpRound0) x)) | x <- fs]+                 ++  [("fromFP_Float_ToWord32",  show x, mkThmC' (m fromSFloat :: SFloat -> SWord32)  x (((fromIntegral :: Integer -> Word32)  . fpRound0) x)) | x <- fs]+                 ++  [("fromFP_Float_ToWord64",  show x, mkThmC' (m fromSFloat :: SFloat -> SWord64)  x (((fromIntegral :: Integer -> Word64)  . fpRound0) x)) | x <- fs]+                 ++  [("fromFP_Float_ToFloat",   show x, mkThm1  (m fromSFloat :: SFloat -> SFloat)   x                                                    x ) | x <- fs]+                 ++  [("fromFP_Float_ToDouble",  show x, mkThm1  (m fromSFloat :: SFloat -> SDouble)  x (                                           fp2fp  x)) | x <- fs]+                 -- Neither Z3 nor MathSAT support Float->Integer/Float->Real conversion for the time being; so comment out.+                 -- See GitHub issue: #191+                 -- ++  [("fromFP_Float_ToInteger", show x, mkThmC' (m fromSFloat :: SFloat -> SInteger) x (((fromIntegral :: Integer -> Integer) . fpRound0) x)) | x <- fs]+                 -- ++  [("fromFP_Float_ToReal",    show x, mkThmC' (m fromSFloat :: SFloat -> SReal)    x (                        (fromRational . fpRatio0) x)) | x <- fs]++                 ++  [("fromFP_Double_ToInt8",    show x, mkThmC' (m fromSDouble :: SDouble -> SInt8)    x (((fromIntegral :: Integer -> Int8)    . fpRound0) x)) | x <- ds]+                 ++  [("fromFP_Double_ToInt16",   show x, mkThmC' (m fromSDouble :: SDouble -> SInt16)   x (((fromIntegral :: Integer -> Int16)   . fpRound0) x)) | x <- ds]+                 ++  [("fromFP_Double_ToInt32",   show x, mkThmC' (m fromSDouble :: SDouble -> SInt32)   x (((fromIntegral :: Integer -> Int32)   . fpRound0) x)) | x <- ds]+                 ++  [("fromFP_Double_ToInt64",   show x, mkThmC' (m fromSDouble :: SDouble -> SInt64)   x (((fromIntegral :: Integer -> Int64)   . fpRound0) x)) | x <- ds]+                 ++  [("fromFP_Double_ToWord8",   show x, mkThmC' (m fromSDouble :: SDouble -> SWord8)   x (((fromIntegral :: Integer -> Word8)   . fpRound0) x)) | x <- ds]+                 ++  [("fromFP_Double_ToWord16",  show x, mkThmC' (m fromSDouble :: SDouble -> SWord16)  x (((fromIntegral :: Integer -> Word16)  . fpRound0) x)) | x <- ds]+                 ++  [("fromFP_Double_ToWord32",  show x, mkThmC' (m fromSDouble :: SDouble -> SWord32)  x (((fromIntegral :: Integer -> Word32)  . fpRound0) x)) | x <- ds]+                 ++  [("fromFP_Double_ToWord64",  show x, mkThmC' (m fromSDouble :: SDouble -> SWord64)  x (((fromIntegral :: Integer -> Word64)  . fpRound0) x)) | x <- ds]+                 ++  [("fromFP_Double_ToFloat",   show x, mkThm1  (m fromSDouble :: SDouble -> SFloat)   x (                                            fp2fp x)) | x <- ds]+                 ++  [("fromFP_Double_ToDouble",  show x, mkThm1  (m fromSDouble :: SDouble -> SDouble)  x                                                    x ) | x <- ds]+                 -- Neither Z3 nor MathSAT support Float->Integer/Float->Real conversion for the time being; so comment out.+                 -- See GitHub issue: #191+                 -- ++  [("fromFP_Double_ToInteger", show x, mkThmC' (m fromSDouble :: SDouble -> SInteger) x (((fromIntegral :: Integer -> Integer) . fpRound0) x)) | x <- ds]+                 -- ++  [("fromFP_Double_ToReal",    show x, mkThmC' (m fromSDouble :: SDouble -> SReal)    x (                        (fromRational . fpRatio0) x)) | x <- ds]++                 ++  [("reinterp_Word32_Float",  show x, mkThmC sWord32AsSFloat  x (DB.wordToFloat  x)) | x <- w32s]+                 ++  [("reinterp_Word64_Double", show x, mkThmC sWord64AsSDouble x (DB.wordToDouble x)) | x <- w64s]++                 ++  [("reinterp_Float_Word32",  show x, mkThmP sFloatAsSWord32  x (DB.floatToWord x))  | x <- fs, not (isNaN x)] -- Not unique for NaN+                 ++  [("reinterp_Double_Word64", show x, mkThmP sDoubleAsSWord64 x (DB.doubleToWord x)) | x <- ds, not (isNaN x)] -- Not unique for NaN++        m f = f sRNE++        tst1 (nm, x, t) = testCase ("fpConverts.arithmetic-" ++ nm ++ "." ++ x) (assert t)++        eqF v val+          | isNaN          val        = constrain $ fpIsNaN v+          | isNegativeZero val        = constrain $ fpIsNegativeZero v+          | val == 0                  = constrain $ fpIsPositiveZero v+          | isInfinite val && val > 0 = constrain $ fpIsInfinite v &&& fpIsPositive v+          | isInfinite val && val < 0 = constrain $ fpIsInfinite v &&& fpIsNegative v+          | True                      = constrain $ v .== literal val++        -- Quickly pick which solver to use. Currently z3 or mathSAT supports FP+        fpProver :: SMTConfig+        fpProver = z3 -- mathSAT++        fpThm :: Provable a => a -> IO Bool+        fpThm = isTheoremWith fpProver++        mkThmP op x r = fpThm $ do a <- free "x"+                                   eqF a x+                                   return $ literal r .== op a++        mkThm1 op x r = fpThm $ do a <- free "x"+                                   eqF a x+                                   return $ literal r `fpIsEqualObject` op a++        mkThmC op x r = fpThm $ do a <- free "x"+                                   constrain $ a .== literal x+                                   return $ literal r `fpIsEqualObject` op a++        mkThmC' op x r = fpThm $ do a <- free "x"+                                    eqF a x+                                    return $ literal r .== op a++genQRems :: [TestTree]+genQRems = map mkTest $  [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- w8s,  y <- w8s ]+                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- w16s, y <- w16s]+                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- w32s, y <- w32s]+                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- w64s, y <- w64s]+                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- i8s,  y <- i8s , noOverflow x y]+                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- i16s, y <- i16s, noOverflow x y]+                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- i32s, y <- i32s, noOverflow x y]+                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- i64s, y <- i64s, noOverflow x y]+                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- iUBs, y <- iUBs]+                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w8s,  y <- w8s ]+                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w16s, y <- w16s]+                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w32s, y <- w32s]+                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w64s, y <- w64s]+                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i8s,  y <- i8s , noOverflow x y]+                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i16s, y <- i16s, noOverflow x y]+                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i32s, y <- i32s, noOverflow x y]+                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i64s, y <- i64s, noOverflow x y]+                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- iUBs, y <- iUBs]+  where divMod'  x y = if y == 0 then (0, x) else x `divMod`  y+        quotRem' x y = if y == 0 then (0, x) else x `quotRem` y+        mkTest (nm, x, y, t) = testCase ("genQRems.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y) (assert t)+        mkThm2 op x y (e1, e2) = isTheorem $ do [a, b] <- mapM free ["x", "y"]+                                                constrain $ a .== literal x+                                                constrain $ b .== literal y+                                                return $ (literal e1, literal e2) .== a `op` b+        -- Haskell's divMod and quotRem overflows if x == minBound and y == -1 for signed types; so avoid that case+        noOverflow x y = not (x == minBound && y == -1)++-- Concrete test data+xsSigned, xsUnsigned :: (Num a, Bounded a) => [a]+xsUnsigned = [0, 1, maxBound - 1, maxBound]+xsSigned   = xsUnsigned ++ [minBound, minBound + 1, -1]++w8s :: [Word8]+w8s = xsUnsigned++w16s :: [Word16]+w16s = xsUnsigned++w32s :: [Word32]+w32s = xsUnsigned++w64s :: [Word64]+w64s = xsUnsigned++i8s :: [Int8]+i8s = xsSigned++i16s :: [Int16]+i16s = xsSigned++i32s :: [Int32]+i32s = xsSigned++i64s :: [Int64]+i64s = xsSigned++iUBs :: [Integer]+iUBs = [-1000000] ++ [-1 .. 1] ++ [1000000]++rs :: [AlgReal]+rs = [fromRational (i % d) | i <- is, d <- dens]+ where is   = [-1000000] ++ [-1 .. 1] ++ [10000001]+       dens = [5,100,1000000]++-- Admittedly paltry test-cases for float/double+fs :: [Float]+fs = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan+   where xs = [nan, infinity, 0, 0.5, 0.68302244, 0.5268265, 0.10283524, 5.8336496e-2, 1.0e-45]++ds :: [Double]+ds = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan+  where xs = [nan, infinity, 0, 0.5, 2.516632060108026e-2, 0.8601891300751106, 5.0e-324]++{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
+ SBVTestSuite/TestSuite/Basics/BasicTests.hs view
@@ -0,0 +1,81 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.BasicTests+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.Basics.BasicTests+-----------------------------------------------------------------------------++{-# LANGUAGE Rank2Types          #-}+{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.Basics.BasicTests(tests) where++import Data.SBV.Internals+import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "Basics.BasicTests"+   [ testCase "basic-0.1" $ test0 f1 `showsAs` "5"+   , testCase "basic-0.2" $ test0 f2 `showsAs` "5"+   , testCase "basic-0.3" $ test0 f3 `showsAs` "25"+   , testCase "basic-0.4" $ test0 f4 `showsAs` "25"+   , testCase "basic-0.5" $ test0 f5 `showsAs` "4"+   , goldenVsStringShow "basic-1_1" $ test1 f1+   , goldenVsStringShow "basic-1_2" $ test1 f2+   , goldenVsStringShow "basic-1_3" $ test1 f3+   , goldenVsStringShow "basic-1_4" $ test1 f4+   , goldenVsStringShow "basic-1_5" $ test1 f5+   , goldenVsStringShow "basic-2_1" $ test2 f1+   , goldenVsStringShow "basic-2_2" $ test2 f2+   , goldenVsStringShow "basic-2_3" $ test2 f3+   , goldenVsStringShow "basic-2_4" $ test2 f4+   , goldenVsStringShow "basic-2_5" $ test2 f5+   , goldenVsStringShow "basic-3_1" $ test3 f1+   , goldenVsStringShow "basic-3_2" $ test3 f2+   , goldenVsStringShow "basic-3_3" $ test3 f3+   , goldenVsStringShow "basic-3_4" $ test3 f4+   , goldenVsStringShow "basic-3_5" $ test3 f5+   , goldenVsStringShow "basic-4_1" $ test4 f1+   , goldenVsStringShow "basic-4_2" $ test4 f2+   , goldenVsStringShow "basic-4_3" $ test4 f3+   , goldenVsStringShow "basic-4_4" $ test4 f4+   , goldenVsStringShow "basic-4_5" $ test4 f5+   , goldenVsStringShow "basic-5_1" $ test5 f1+   , goldenVsStringShow "basic-5_2" $ test5 f2+   , goldenVsStringShow "basic-5_3" $ test5 f3+   , goldenVsStringShow "basic-5_4" $ test5 f4+   , goldenVsStringShow "basic-5_5" $ test5 f5+   ]++test0 :: (forall a. Num a => (a -> a -> a)) -> Word8+test0 f = f (3 :: Word8) 2++test1, test2, test3, test4, test5 :: (forall a. Num a => (a -> a -> a)) -> IO Result+test1 f = runSAT $ do let x = literal (3 :: Word8)+                          y = literal (2 :: Word8)+                      output $ f x y+test2 f = runSAT $ do let x = literal (3 :: Word8)+                      y :: SWord8 <- forall "y"+                      output $ f x y+test3 f = runSAT $ do x :: SWord8 <- forall "x"+                      y :: SWord8 <- forall "y"+                      output $ f x y+test4 f = runSAT $ do x :: SWord8 <- forall "x"+                      output $ f x x+test5 f = runSAT $ do x :: SWord8 <- forall "x"+                      let r = f x x+                      q :: SWord8 <- forall "q"+                      _ <- output q+                      output r++f1, f2, f3, f4, f5 :: Num a => a -> a -> a+f1 x y = (x+y)*(x-y)+f2 x y = (x*x)-(y*y)+f3 x y = (x+y)*(x+y)+f4 x y = let z = x + y in z * z+f5 x _ = x + 1
+ SBVTestSuite/TestSuite/Basics/GenBenchmark.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.GenBenchmark+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test the generateSMTBenchmark function.+-----------------------------------------------------------------------------++module TestSuite.Basics.GenBenchmark(tests)  where++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.genBenchmark"+    [ goldenString "genBenchMark1" $ gen False (\x -> x .== (x+1::SWord8))+    , goldenString "genBenchMark2" $ gen True  (\x -> x .== (x+1::SWord8))+    ]+    where gen b f = do r <- generateSMTBenchmark b f+                       -- the first line is time-stamp, get rid of it so test+                       -- is repeatable+                       return $ unlines $ tail $ lines r
+ SBVTestSuite/TestSuite/Basics/Higher.hs view
@@ -0,0 +1,53 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.Higher+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.Basics.Higher+-----------------------------------------------------------------------------++module TestSuite.Basics.Higher(tests) where++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "Basics.Higher"+    [ goldenVsStringShow "higher-1" (f11 === f11)+    , goldenVsStringShow "higher-2" (f12 === f12)+    , goldenVsStringShow "higher-3" (f21 === f21)+    , goldenVsStringShow "higher-4" (f22 === f22)+    , goldenVsStringShow "higher-5" (f31 === f31)+    , goldenVsStringShow "higher-6" (f32 === f32)+    , goldenVsStringShow "higher-7" (f33 === f33)+    , goldenVsStringShow "higher-8" double+    , goldenVsStringShow "higher-9" onlyFailsFor128+    ]+ where double          = (2*) === (\x -> x+(x::SWord8))+       onlyFailsFor128 = (2*) === (\x -> ite (x .== 128) 5 (x+(x::SWord8)))++type B = SWord8++f11 :: B -> B+f11 x = x++f12 :: B -> (B, B)+f12 x = (x, x)++f21 :: (B, B) -> B+f21 (x, y) = x + y++f22 :: (B, B) -> (B, B)+f22 (x, y) = (x, y)++f31 :: B -> B -> B+f31 x y = x + y++f32 :: B -> B -> (B, B)+f32 x y = (x, y)++f33 :: B -> B -> B -> (B, B, B)+f33 x y z = (x, y, z)
+ SBVTestSuite/TestSuite/Basics/Index.hs view
@@ -0,0 +1,76 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.Index+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.Basics.Index+-----------------------------------------------------------------------------++module TestSuite.Basics.Index(tests) where++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "Basics.Index"+    (zipWith+      mkTest+      [f x | f <- [test1, test2, test3], x <- [0..13]]+      [(0::Int)..])++mkTest :: IO Bool -> Int -> TestTree+mkTest tst i =+  testCase ("index-" ++ show i)+    (assert tst)++-- prove that the "select" primitive is working correctly+test1 :: Int -> IO Bool+test1 n = isTheorem $ do+            elts <- mkForallVars n+            err  <- forall_+            ind  <- forall_+            ind2 <- forall_+            let r1 = (select :: [SWord8] -> SWord8 -> SInt8 -> SWord8) elts err ind+                r2 = (select :: [SWord8] -> SWord8 -> SWord8 -> SWord8) elts err ind2+                r3 = slowSearch elts err ind+                r4 = slowSearch elts err ind2+            return $ r1 .== r3 &&& r2 .== r4+ where slowSearch elts err i = ite (i .< 0) err (go elts i)+         where go []     _      = err+               go (x:xs) curInd = ite (curInd .== 0) x (go xs (curInd - 1))++test2 :: Int -> IO Bool+test2 n = isTheorem $ do+            elts1 <- mkForallVars n+            elts2 <- mkForallVars n+            let elts = zip elts1 elts2+            err1  <- forall_+            err2  <- forall_+            let err = (err1, err2)+            ind  <- forall_+            ind2 <- forall_+            let r1 = (select :: [(SWord8, SWord8)] -> (SWord8, SWord8) -> SInt8 -> (SWord8, SWord8)) elts err ind+                r2 = (select :: [(SWord8, SWord8)] -> (SWord8, SWord8) -> SWord8 -> (SWord8, SWord8)) elts err ind2+                r3 = slowSearch elts err ind+                r4 = slowSearch elts err ind2+            return $ r1 .== r3 &&& r2 .== r4+ where slowSearch elts err i = ite (i .< 0) err (go elts i)+         where go []     _      = err+               go (x:xs) curInd = ite (curInd .== 0) x (go xs (curInd - 1))++test3 :: Int -> IO Bool+test3 n = isTheorem $ do+            eltsI <- mkForallVars n+            let elts = map Left eltsI+            errI  <- forall_+            let err = Left errI+            ind  <- forall_+            let r1 = (select :: [Either SWord8 SWord8] -> Either SWord8 SWord8 -> SInt8 -> Either SWord8 SWord8) elts err ind+                r2 = slowSearch elts err ind+            return $ r1 .== r2+ where slowSearch elts err i = ite (i .< 0) err (go elts i)+         where go []     _      = err+               go (x:xs) curInd = ite (curInd .== 0) x (go xs (curInd - 1))
+ SBVTestSuite/TestSuite/Basics/IteTest.hs view
@@ -0,0 +1,36 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.IteTest+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test various incarnations of laziness in ite+-----------------------------------------------------------------------------++module TestSuite.Basics.IteTest(tests)  where++import Utils.SBVTestFramework++chk1 :: (SBool -> SBool -> SBool -> SBool) -> SWord8 -> SBool+chk1 cond x = cond (x .== x) true undefined++chk2 :: (SBool -> [SBool] -> [SBool] -> [SBool]) -> SWord8 -> SBool+chk2 cond x = head (cond (x .== x) [true] [undefined])++chk3 :: (SBool -> (SBool, SBool) -> (SBool, SBool)  -> (SBool, SBool)) -> SWord8 -> SBool+chk3 cond x = fst (cond (x .== x) (true, undefined::SBool) (undefined, undefined))++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.Ite"+    [ goldenVsStringShow "iteTest1" (rs (chk1 ite))+    , goldenVsStringShow "iteTest2" (rs (chk2 ite))+    , goldenVsStringShow "iteTest3" (rs (chk3 ite))+    , testCase "iteTest4" (assertIsThm (chk1 iteLazy))+    , testCase "iteTest5" (assertIsThm (chk2 iteLazy))+    , testCase "iteTest6" (assertIsThm (chk3 iteLazy))+    ]+ where rs f = runSAT $ forAll ["x"] f
+ SBVTestSuite/TestSuite/Basics/ProofTests.hs view
@@ -0,0 +1,51 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.ProofTests+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.Basics.ProofTests+-----------------------------------------------------------------------------++module TestSuite.Basics.ProofTests(tests)  where++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "Basics.Proof"+    [ testCase "proofs-1" (assertIsThm f1eqf2)+    , testCase "proofs-2" (assertIsntThm f1eqf3)+    , testCase "proofs-3" (assertIsThm f3eqf4)+    , testCase "proofs-4" (assertIsThm f1Single)+    , testCase "proofs-5" (assertIsSat (f1 `xyEq` f2))+    , testCase "proofs-6" (assertIsSat (f1 `xyEq` f3))+    , testCase "proofs-7" (assertIsntSat (exists "x" >>= \x -> return (x .== x + (1 :: SWord16))))+    , testCase "proofs-8" (assertIsSat (exists "x" >>= \x -> return (x :: SBool)))+    , testCase "proofs-9" (assertIsSat (exists "x" >>= \x -> return x :: Predicate))+    ]++xyEq :: (EqSymbolic a, SymWord a1) => (SBV a1 -> SBV Word8 -> a) -> (SBV a1 -> SWord8 -> a) -> Symbolic SBool+func1 `xyEq` func2 = do x <- exists_+                        y <- exists_+                        return $ func1 x y .== func2 x (y :: SWord8)++f1, f2, f3, f4 :: Num a => a -> a -> a+f1 x y = (x+y)*(x-y)+f2 x y = (x*x)-(y*y)+f3 x y = (x+y)*(x+y)+f4 x y = x*x + 2*x*y + y*y++f1eqf2 :: Predicate+f1eqf2 = forAll_ $ \x y -> f1 x y .== f2 x (y :: SWord8)++f1eqf3 :: Predicate+f1eqf3 = forAll ["x", "y"] $ \x y -> f1 x y .== f3 x (y :: SWord8)++f3eqf4 :: Predicate+f3eqf4 = forAll_ $ \x y -> f3 x y .== f4 x (y :: SWord8)++f1Single :: Predicate+f1Single = forAll_ $ \x -> f1 x x .== (0 :: SWord16)
+ SBVTestSuite/TestSuite/Basics/PseudoBoolean.hs view
@@ -0,0 +1,72 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.PseudoBoolean+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test the pseudo-boolean functions+-----------------------------------------------------------------------------++module TestSuite.Basics.PseudoBoolean(tests)  where++import Data.SBV.Control+import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.pseudoBoolean" [+      goldenCapturedIO "pbAtMost"          $ \rf -> checkWith z3{redirectVerbose=Just rf} propPbAtMost+    , goldenCapturedIO "pbAtLeast"         $ \rf -> checkWith z3{redirectVerbose=Just rf} propPbAtLeast+    , goldenCapturedIO "pbExactly"         $ \rf -> checkWith z3{redirectVerbose=Just rf} propPbExactly+    , goldenCapturedIO "pbLe"              $ \rf -> checkWith z3{redirectVerbose=Just rf} propPbLe+    , goldenCapturedIO "pbGe"              $ \rf -> checkWith z3{redirectVerbose=Just rf} propPbGe+    , goldenCapturedIO "pbEq"              $ \rf -> checkWith z3{redirectVerbose=Just rf} propPbEq+    , goldenCapturedIO "pbMutexed"         $ \rf -> checkWith z3{redirectVerbose=Just rf} propPbMutexed+    , goldenCapturedIO "pbStronglyMutexed" $ \rf -> checkWith z3{redirectVerbose=Just rf} propPbStronglyMutexed+    ]++-- to test interactively, use:+--    checkWith z3 propPbAtLeast++checkWith :: SMTConfig -> ([SBool] -> SBool) -> IO ()+checkWith cfg spec = runSMTWith cfg{verbose=True} $ do+        bs <- sBools $ map (\i -> "b" ++ show i) [0..(9::Int)]+        constrain $ bnot (spec bs)+        query $ do cs <- checkSat+                   case cs of+                     Unsat -> return ()+                     Sat   -> getModel         >>= \r -> error $ "Failed! Expected Unsat, got SAT:\n" ++ show (SatResult (Satisfiable cfg r))+                     Unk   -> getUnknownReason >>= \r -> error $ "Failed! Expected Unsat, got UNK:\n" ++ show r++propPbAtMost :: [SBool] -> SBool+propPbAtMost bs = pbAtMost bs 8 .== (sum (map oneIf bs) .<= (8::SWord32))++propPbAtLeast :: [SBool] -> SBool+propPbAtLeast bs = pbAtLeast bs 5 .== (sum (map oneIf bs) .>= (5::SWord32))++propPbExactly :: [SBool] -> SBool+propPbExactly bs = pbExactly bs 5 .== (sum (map oneIf bs) .== (5::SWord32))++propPbLe :: [SBool] -> SBool+propPbLe bs = pbLe ibs 7 .== (sum (map valIf ibs) .<= (7::SInteger))+  where ibs = zip [1..] bs+        valIf (i, b) = ite b (literal (fromIntegral i)) 0++propPbGe :: [SBool] -> SBool+propPbGe bs = pbGe ibs 7 .== (sum (map valIf ibs) .>= (7::SInteger))+  where ibs = zip [1..] bs+        valIf (i, b) = ite b (literal (fromIntegral i)) 0++propPbEq :: [SBool] -> SBool+propPbEq bs = pbEq ibs 7 .== (sum (map valIf ibs) .== (7::SInteger))+  where ibs = zip [1..] bs+        valIf (i, b) = ite b (literal (fromIntegral i)) 0++propPbMutexed :: [SBool] -> SBool+propPbMutexed bs = pbMutexed bs .== (sum (map oneIf bs) .<= (1::SWord32))++propPbStronglyMutexed :: [SBool] -> SBool+propPbStronglyMutexed bs = pbStronglyMutexed bs .== (sum (map oneIf bs) .== (1::SWord32))
+ SBVTestSuite/TestSuite/Basics/QRem.hs view
@@ -0,0 +1,33 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.QRem+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.Basics.QRem+-----------------------------------------------------------------------------++module TestSuite.Basics.QRem(tests) where++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "Basics.QRem"+    [ testCase "qremW8" (assertIsThm (qrem :: SWord8   -> SWord8   -> SBool))+    , testCase "qremI8" (assertIsThm (qrem :: SInt8    -> SInt8    -> SBool))+    , testCase "qremI"  (assertIsThm (qrem :: SInteger -> SInteger -> SBool))+    ]++-- check: if (a, b) = x `quotRem` y then x = y*a + b+-- same is also true for divMod+-- being careful about y = 0. When divisor is 0, then quotient is+-- defined to be 0 and the remainder is the numerator+qrem :: (Num a, EqSymbolic a, SDivisible a) => a -> a -> SBool+qrem x y = ite (y .== 0)+               ((0, x) .== (q, r) &&& (0, x) .== (d, m))+               (x .== y * q + r &&& x .== y * d + m)+  where (q, r) = x `sQuotRem` y+        (d, m) = x `sDivMod` y
+ SBVTestSuite/TestSuite/Basics/Quantifiers.hs view
@@ -0,0 +1,46 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.Quantifiers+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Various combinations of quantifiers+-----------------------------------------------------------------------------++module TestSuite.Basics.Quantifiers(tests) where++import Control.Monad (void)++import Utils.SBVTestFramework++tests :: TestTree+tests = testGroup "Basics.Quantifiers" $ concatMap mkGoal goals ++ concatMap mkPred preds+   where mkGoal (g, nm) = [ goldenCapturedIO ("quantified_sat"   ++ "_" ++ nm) $ \rf -> void $ satWith   z3{verbose=True, redirectVerbose=Just rf} g+                          , goldenCapturedIO ("quantified_prove" ++ "_" ++ nm) $ \rf -> void $ proveWith z3{verbose=True, redirectVerbose=Just rf} g+                          ]+         mkPred (p, nm) = [ goldenCapturedIO ("quantified_sat"   ++ "_" ++ nm) $ \rf -> void $ satWith   z3{verbose=True, redirectVerbose=Just rf} p+                          , goldenCapturedIO ("quantified_prove" ++ "_" ++ nm) $ \rf -> void $ proveWith z3{verbose=True, redirectVerbose=Just rf} p+                          ]++         qs   = [(exists, "exists"), (forall, "forall")]++         acts = [ (\x y -> x + (y - x) .== y  , "thm")+                , (\x y -> x .== y &&& x ./= y, "contradiction")+                , (\x y -> x .== y + 1        , "satisfiable")+                ]++         goals = [(t1 q1 q2 a, nq1 ++ nq2 ++ "_" ++ an ++ "_c") | (q1, nq1) <- qs+                                                                , (q2, nq2) <- qs+                                                                , (a,  an)  <- acts ]++         preds = [(t2 q1 q2 a, nq1 ++ nq2 ++ "_" ++ an ++ "_p") | (q1, nq1) <- qs+                                                                , (q2, nq2) <- qs+                                                                , (a,  an)  <- acts ]++         t1 :: (String -> Symbolic SWord8) -> (String -> Symbolic SWord8) -> (SWord8 -> SWord8 -> SBool) -> Goal+         t1 q1 q2 act = q1 "x" >>= \x -> q2 "y" >>= \y -> constrain $ act x y++         t2 :: (String -> Symbolic SWord8) -> (String -> Symbolic SWord8) -> (SWord8 -> SWord8 -> SBool) -> Predicate+         t2 q1 q2 act = q1 "x" >>= \x -> q2 "y" >>= \y -> return    $ act x y
+ SBVTestSuite/TestSuite/Basics/Recursive.hs view
@@ -0,0 +1,58 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.Recursive+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Some recursive definitions.+-----------------------------------------------------------------------------++module TestSuite.Basics.Recursive(tests) where++import Utils.SBVTestFramework++import Control.Monad.Reader (ask)+import Control.Monad.Trans  (liftIO)+import qualified Data.SBV.Dynamic as D++-- This is recursive and suffers from the termination problem.+-- But we can still prove a few things about it!+mgcd :: SWord8 -> SWord8 -> SWord8+mgcd a b = ite (b .== 0) a (mgcd b (a `sMod` b))++-- Same construction, expressed in terms of the dynamic interface+mgcdDyn :: Int -> IO ThmResult+mgcdDyn i = D.proveWith z3 $ do++              let var8 :: String -> Symbolic D.SVal+                  var8 nm = ask >>= liftIO . D.svMkSymVar (Just D.ALL) word8 (Just nm)++                  word8   = KBounded False 8+                  zero8   = D.svInteger word8 0++                  gcdDyn a b = D.svIte (b `D.svEqual` zero8) a (gcdDyn b (a `D.svRem` b))++              x <- var8 "x"++              let prop0 = gcdDyn zero8 x `D.svEqual` x+                  prop1 = gcdDyn x zero8 `D.svEqual` x++              return $  if i == 0 then prop0 else prop1++checkThm :: ThmResult -> Assertion+checkThm r = assert isThm+  where isThm = case r of+                  ThmResult Unsatisfiable{} -> return True :: IO Bool+                  ThmResult Satisfiable{}   -> return False+                  _                         -> error "checkThm: Unexpected result!"++-- Test suite+tests :: TestTree+tests = testGroup "Basics.Recursive"+   [ testCase "recursive1"    $ assertIsThm $ \x -> mgcd    0 x .== x+   , testCase "recursive2"    $ assertIsThm $ \x -> mgcd    x 0 .== x+   , testCase "recursiveDyn1" $ checkThm =<< mgcdDyn 0+   , testCase "recursiveDyn2" $ checkThm =<< mgcdDyn 1+   ]
+ SBVTestSuite/TestSuite/Basics/SquashReals.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.SquashReals+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test the "squash" reals feature+-----------------------------------------------------------------------------++module TestSuite.Basics.SquashReals(tests) where++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.Reals.Squash"+    [ goldenVsStringShow "squashReals1" $ sat                            (\x -> x .>= 0 &&& x*x .== (59::SReal))+    , goldenVsStringShow "squashReals2" $ sat                            (\x -> x .>= 0 &&& x*x .== (16::SReal))+    , goldenVsStringShow "squashReals3" $ satWith z3{printRealPrec = 35} (\x -> x .>= 0 &&& x*x .== (59::SReal))+    , goldenVsStringShow "squashReals4" $ satWith z3{printRealPrec = 35} (\x -> x .>= 0 &&& x*x .== (16::SReal))+    ]
+ SBVTestSuite/TestSuite/Basics/TOut.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Basics.TOut+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test the basic timeout mechanism+-----------------------------------------------------------------------------++module TestSuite.Basics.TOut(tests)  where++import Data.SBV.Examples.Puzzles.Euler185++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.timeout"+    [ goldenVsStringShow "timeout1" (sat (setTimeOut 1000 >> euler185))+    ]
+ SBVTestSuite/TestSuite/BitPrecise/BitTricks.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.BitPrecise.BitTricks+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.BitPrecise.BitTricks+-----------------------------------------------------------------------------++module TestSuite.BitPrecise.BitTricks(tests) where++import Data.SBV.Examples.BitPrecise.BitTricks++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "BitPrecise.BitTricks"+    [ testCase "fast min" (assertIsThm fastMinCorrect)+    , testCase "fast max" (assertIsThm fastMaxCorrect)+    , testCase "opposite signs" (assertIsThm oppositeSignsCorrect)+    , testCase "conditional set clear" (assertIsThm conditionalSetClearCorrect)+    , testCase "power of two" (assertIsThm powerOfTwoCorrect)+    ]
+ SBVTestSuite/TestSuite/BitPrecise/Legato.hs view
@@ -0,0 +1,43 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.BitPrecise.Legato+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.BitPrecise.Legato+-----------------------------------------------------------------------------++module TestSuite.BitPrecise.Legato(tests) where++import Data.SBV.Internals+import Data.SBV.Examples.BitPrecise.Legato++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "BitPrecise.Legato" [+   goldenVsStringShow "legato"   legatoPgm+ , goldenVsStringShow "legato_c" legatoC+ ]+ where legatoPgm = runSAT $ do+                       addrX   <- free "addrX"+                       x       <- free "x"+                       addrY   <- free "addrY"+                       y       <- free "y"+                       addrLow <- free "addrLow"+                       regX    <- free "regX"+                       regA    <- free "regA"+                       flagC   <- free "flagC"+                       flagZ   <- free "flagZ"+                       output $ legatoIsCorrect (mkSFunArray (const 0)) (addrX, x) (addrY, y) addrLow (regX, regA, flagC, flagZ)+       legatoC = compileToC' "legatoMult" $ do+                    cgSetDriverValues [87, 92]+                    cgPerformRTCs True+                    x <- cgInput "x"+                    y <- cgInput "y"+                    let (hi, lo) = runLegato (0, x) (1, y) 2 (initMachine (mkSFunArray (const 0)) (0, 0, false, false))+                    cgOutput "hi" hi+                    cgOutput "lo" lo
+ SBVTestSuite/TestSuite/BitPrecise/MergeSort.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.BitPrecise.MergeSort+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.BitPrecise.MergeSort+-----------------------------------------------------------------------------++module TestSuite.BitPrecise.MergeSort(tests) where++import Data.SBV.Internals+import Data.SBV.Examples.BitPrecise.MergeSort++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "BitPrecise.MergeSort" [+   goldenVsStringShow "merge" mergeC+ ]+ where mergeC = compileToC' "merge" $ do+                   cgSetDriverValues [10, 6, 4, 82, 71]+                   xs <- cgInputArr 5 "xs"+                   cgOutputArr "ys" (mergeSort xs)
+ SBVTestSuite/TestSuite/BitPrecise/PrefixSum.hs view
@@ -0,0 +1,25 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.BitPrecise.PrefixSum+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.PrefixSum.PrefixSum+-----------------------------------------------------------------------------++module TestSuite.BitPrecise.PrefixSum(tests) where++import Data.SBV.Examples.BitPrecise.PrefixSum++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "BitPrecise.PrefixSum"+    [+        testCase "prefixSum1" (assertIsThm (flIsCorrect  8 (0, (+))))+      , testCase "prefixSum2" (assertIsThm (flIsCorrect 16 (0, smax)))+    ]
+ SBVTestSuite/TestSuite/CRC/CCITT.hs view
@@ -0,0 +1,53 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CRC.CCITT+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.CRC.CCITT+-----------------------------------------------------------------------------++module TestSuite.CRC.CCITT(tests) where++import Data.SBV.Tools.Polynomial++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "CRC.CCITT"+  [ goldenVsStringShow "ccitt" crcPgm+  ]+  where crcPgm = runSAT $ forAll_ crcGood >>= output++-- We don't have native support for 48 bits in Data.SBV+-- So, represent as 32 high-bits and 16 low+type SWord48 = (SWord32, SWord16)++extendData :: SWord48 -> SWord64+extendData (h, l) = h # l # 0++mkFrame :: SWord48 -> SWord64+mkFrame msg@(h, l) = h # l # crc_48_16 msg++crc_48_16 :: SWord48 -> SWord16+crc_48_16 msg = res+  where msg64, divisor :: SWord64+        msg64   = extendData msg+        divisor = polynomial [16, 12, 5, 0]+        crc64 = pMod msg64 divisor+        (_, res) = split (snd (split crc64))++diffCount :: SWord64 -> SWord64 -> SWord8+diffCount x y = count $ zipWith (.==) (blastLE x) (blastLE y)+  where count []     = 0+        count (b:bs) = let r = count bs in ite b r (1+r)++-- Claim: If there is an undetected corruption, it must be at least at 4 bits; i.e. HD is 4+crcGood :: SWord48 -> SWord48 -> SBool+crcGood sent received =+     sent ./= received ==> diffCount frameSent frameReceived .> 3+   where frameSent     = mkFrame sent+         frameReceived = mkFrame received
+ SBVTestSuite/TestSuite/CRC/CCITT_Unidir.hs view
@@ -0,0 +1,60 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CRC.CCITT_Unidir+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.CRC.CCITT_Unidir+-----------------------------------------------------------------------------++module TestSuite.CRC.CCITT_Unidir(tests) where++import Data.SBV.Tools.Polynomial+import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "CCITT_Unidir"+    [   testCase "ccitHDis3" (assertIsThm (crcUniGood 3))+      , testCase "ccitHDis4" (assertIsntThm (crcUniGood 4))+    ]++-- We don't have native support for 48 bits in Data.SBV+-- So, represent as 32 high-bits and 16 low+type SWord48 = (SWord32, SWord16)++extendData :: SWord48 -> SWord64+extendData (h, l) = h # l # 0++mkFrame :: SWord48 -> SWord64+mkFrame msg@(h, l) = h # l # crc_48_16 msg++crc_48_16 :: SWord48 -> SWord16+crc_48_16 msg = res+  where msg64, divisor :: SWord64+        msg64   = extendData msg+        divisor = polynomial [16, 12, 5, 0]+        crc64 = pMod msg64 divisor+        (_, res) = split (snd (split crc64))++diffCount :: [SBool] -> [SBool] -> SWord8+diffCount xs ys = count $ zipWith (.==) xs ys+  where count []     = 0+        count (b:bs) = let r = count bs in ite b r (1+r)++-- returns true if there's a 0->1 error (1->0 is ok)+nonUnidir :: [SBool] -> [SBool] -> SBool+nonUnidir []     _      = false+nonUnidir _      []     = false+nonUnidir (a:as) (b:bs) = (bnot a &&& b) ||| nonUnidir as bs++crcUniGood :: SWord8 -> SWord48 -> SWord48 -> SBool+crcUniGood hd sent received =+     sent ./= received ==> nonUnidir frameSent frameReceived ||| diffCount frameSent frameReceived .> hd+   where frameSent     = blastLE $ mkFrame sent+         frameReceived = blastLE $ mkFrame received++{-# ANN crc_48_16 ("HLint: ignore Use camelCase" :: String) #-}
+ SBVTestSuite/TestSuite/CRC/GenPoly.hs view
@@ -0,0 +1,64 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CRC.GenPoly+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.CRC.GenPoly+-----------------------------------------------------------------------------++module TestSuite.CRC.GenPoly(tests) where++import Data.SBV.Tools.Polynomial+import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "CRC.GenPoly"+    [ testCase "crcGoodE" (assertIsSat crcGoodE)+    , testCase "crcGood"  (assertIsntThm (crcGood 3 12))+    ]++crcGoodE :: Symbolic SBool+crcGoodE = do+  x1 <- exists_+  x2 <- exists_+  y1 <- exists_+  y2 <- exists_+  return (crcGood 3 0 (x1,x2) (y1,y2))++-- We don't have native support for 48 bits in Data.SBV+-- So, represent as 32 high-bits and 16 low+type SWord48 = (SWord32, SWord16)++extendData :: SWord48 -> SWord64+extendData (h, l) = h # l # 0++mkFrame :: SWord64 -> SWord48 -> SWord64+mkFrame poly msg@(h, l) = h # l # crc_48_16 msg poly++crc_48_16 :: SWord48 -> SWord64 -> SWord16+crc_48_16 msg poly = res+  where msg64 = extendData msg+        crc64 = pMod msg64 poly+        (_, res) = split (snd (split crc64))++diffCount :: SWord64 -> SWord64 -> SWord8+diffCount x y = count $ zipWith (.==) (blastLE x) (blastLE y)+  where count []     = 0+        count (b:bs) = let r = count bs in ite b r (1+r)++crcGood :: SWord8 -> SWord16 -> SWord48 -> SWord48 -> SBool+crcGood hd divisor sent received =+     sent ./= received ==> diffCount frameSent frameReceived .> hd+   where frameSent     = mkFrame poly sent+         frameReceived = mkFrame poly received+         poly          = mkPoly divisor++mkPoly :: SWord16 -> SWord64+mkPoly d = 0 # 1 # d++{-# ANN crc_48_16 ("HLint: ignore Use camelCase" :: String) #-}
+ SBVTestSuite/TestSuite/CRC/Parity.hs view
@@ -0,0 +1,36 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CRC.Parity+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.CRC.Parity+-----------------------------------------------------------------------------++module TestSuite.CRC.Parity(tests) where++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "CRC.Parity"+    [ testCase "parity" (assertIsThm parityOK)+    ]++parity :: SWord64 -> SBool+parity x = bnot (isOdd cnt)+  where cnt :: SWord8+        cnt = sum $ map oneIf $ blastLE x++isOdd :: SWord8 -> SBool+isOdd = lsb++-- Example suggested by Lee Pike+-- If x and y differ in odd-number of bits, then their parities are flipped+parityOK :: SWord64 -> SWord64 -> SBool+parityOK x y = isOdd cnt ==> px .== bnot py+  where cnt = sum $ map oneIf $ zipWith (./=) (blastLE x) (blastLE y)+        px  = parity x+        py  = parity y
+ SBVTestSuite/TestSuite/CRC/USB5.hs view
@@ -0,0 +1,59 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CRC.USB5+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.CRC.USB5+-----------------------------------------------------------------------------++module TestSuite.CRC.USB5(tests) where++import Data.SBV.Tools.Polynomial+import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "CRC.USB5"+    [ testCase "usbGood" (assertIsThm usbGood)+    ]++newtype SWord11 = S11 SWord16++instance EqSymbolic SWord11 where+  S11 w .== S11 w' = w .== w'++mkSWord11 :: SWord16 -> SWord11+mkSWord11 w = S11 (w .&. 0x07FF)++extendData :: SWord11 -> SWord16+extendData (S11 w) = w `shiftL` 5++mkFrame :: SWord11 -> SWord16+mkFrame w = extendData w .|. crc_11_16 w++-- crc returns 16 bits, but the first 11 are always 0+crc_11_16 :: SWord11 -> SWord16+crc_11_16 msg = crc16 .&. 0x1F -- just get the last 5 bits+  where divisor :: SWord16+        divisor = polynomial [5, 2, 0]+        crc16 = pMod (extendData msg) divisor++diffCount :: SWord16 -> SWord16 -> SWord8+diffCount x y = count $ zipWith (.==) (blastLE x) (blastLE y)+  where count []     = 0+        count (b:bs) = let r = count bs in ite b r (1+r)++-- Claim: If there is an undetected corruption, it must be at least at 3 bits+usbGood :: SWord16 -> SWord16 -> SBool+usbGood sent16 received16 =+    sent ./= received ==> diffCount frameSent frameReceived .>= 3+   where sent     = mkSWord11 sent16+         received = mkSWord11 received16+         frameSent     = mkFrame sent+         frameReceived = mkFrame received++{-# ANN crc_11_16 ("HLint: ignore Use camelCase" :: String) #-}
+ SBVTestSuite/TestSuite/CodeGeneration/AddSub.hs view
@@ -0,0 +1,31 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CodeGeneration.AddSub+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.CodeGeneration.AddSub+-----------------------------------------------------------------------------++module TestSuite.CodeGeneration.AddSub(tests) where++import Data.SBV.Internals+import Data.SBV.Examples.CodeGeneration.AddSub++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "CodeGen.addSub" [+   goldenVsStringShow "addSub" code+ ]+ where code = compileToC' "addSub" $ do+                cgSetDriverValues [76, 92]+                cgPerformRTCs True+                x <- cgInput "x"+                y <- cgInput "y"+                let (s, d) = addSub x y+                cgOutput "sum" s+                cgOutput "dif" d
+ SBVTestSuite/TestSuite/CodeGeneration/CRC_USB5.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CodeGeneration.CRC_USB5+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.CodeGeneration.CRC_USB5+-----------------------------------------------------------------------------++module TestSuite.CodeGeneration.CRC_USB5(tests) where++import Data.SBV.Internals+import Data.SBV.Examples.CodeGeneration.CRC_USB5++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "CRC.CodeGen" [+   goldenVsStringShow "crcUSB5_1" $ genC crcUSB+ , goldenVsStringShow "crcUSB5_2" $ genC crcUSB'+ ]+ where genC f = compileToC' "crcUSB5" $ do+                   cgSetDriverValues [0xFEDC]+                   msg <- cgInput "msg"+                   cgReturn $ f msg
+ SBVTestSuite/TestSuite/CodeGeneration/CgTests.hs view
@@ -0,0 +1,41 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CodeGeneration.CgTests+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for code-generation features+-----------------------------------------------------------------------------++{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.CodeGeneration.CgTests(tests) where++import Data.SBV.Internals++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "CodeGeneration.CgTests" [+   goldenVsStringShow "selChecked"   $ genSelect True  "selChecked"+ , goldenVsStringShow "selUnchecked" $ genSelect False "selUnChecked"+ , goldenVsStringShow "codeGen1"       foo+ ]+ where genSelect b n = compileToC' n $ do+                         cgSetDriverValues [65]+                         cgPerformRTCs b+                         let sel :: SWord8 -> SWord8+                             sel x = select [1, x+2] 3 x+                         x <- cgInput "x"+                         cgReturn $ sel x+       foo = compileToC' "foo" $ do+                        cgSetDriverValues $ repeat 0+                        (x::SInt16)    <- cgInput "x"+                        (ys::[SInt64]) <- cgInputArr 45 "xArr"+                        cgOutput "z" (5 :: SWord16)+                        cgOutputArr "zArr" (replicate 7 (x+1))+                        cgOutputArr "yArr" ys+                        cgReturn (x*2)
+ SBVTestSuite/TestSuite/CodeGeneration/Fibonacci.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CodeGeneration.Fibonacci+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.CodeGeneration.Fibonacci+-----------------------------------------------------------------------------++module TestSuite.CodeGeneration.Fibonacci(tests) where++import Data.SBV.Internals+import Data.SBV.Examples.CodeGeneration.Fibonacci++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "CodeGeneration.Fibonacci" [+   goldenVsStringShow "fib1" $ tst [12] "fib1" (fib1 64)+ , goldenVsStringShow "fib2" $ tst [20] "fib2" (fib2 64)+ ]+ where tst vs nm f = compileToC' nm $ do cgPerformRTCs True+                                         cgSetDriverValues vs+                                         n <- cgInput "n"+                                         cgReturn $ f n
+ SBVTestSuite/TestSuite/CodeGeneration/Floats.hs view
@@ -0,0 +1,163 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CodeGeneration.Floats+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test-suite for generating floating-point related C code+-----------------------------------------------------------------------------++module TestSuite.CodeGeneration.Floats(tests) where++import Data.SBV.Internals++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "CodeGeneration.Floats" [+   goldenVsStringShow "floats_cgen" code+ ]+ where code  = compileToCLib' "floatCodeGen" cases++       setup = do cgSRealType CgLongDouble+                  cgIntegerSize 64+                  cgSetDriverValues [42, 43, 44]++       test1 nm f = (nm, do setup+                            a <- cgInput "a"+                            cgReturn (f a))++       test2 nm f = (nm, do setup+                            a <- cgInput "a"+                            b <- cgInput "b"+                            cgReturn (f a b))++       test3 nm f = (nm, do setup+                            a <- cgInput "a"+                            b <- cgInput "b"+                            c <- cgInput "c"+                            cgReturn (f a b c))++       cases = [+            test1 "toFP_Int8_ToFloat"       (toSFloat sRoundNearestTiesToEven  :: SInt8    -> SFloat)+          , test1 "toFP_Int16_ToFloat"      (toSFloat sRoundNearestTiesToEven  :: SInt16   -> SFloat)+          , test1 "toFP_Int32_ToFloat"      (toSFloat sRoundNearestTiesToEven  :: SInt32   -> SFloat)+          , test1 "toFP_Int64_ToFloat"      (toSFloat sRoundNearestTiesToEven  :: SInt64   -> SFloat)+          , test1 "toFP_Word8_ToFloat"      (toSFloat sRoundNearestTiesToEven  :: SWord8   -> SFloat)+          , test1 "toFP_Word16_ToFloat"     (toSFloat sRoundNearestTiesToEven  :: SWord16  -> SFloat)+          , test1 "toFP_Word32_ToFloat"     (toSFloat sRoundNearestTiesToEven  :: SWord32  -> SFloat)+          , test1 "toFP_Word64_ToFloat"     (toSFloat sRoundNearestTiesToEven  :: SWord64  -> SFloat)+          , test1 "toFP_Float_ToFloat"      (toSFloat sRoundNearestTiesToEven  :: SFloat   -> SFloat)+          , test1 "toFP_Double_ToFloat"     (toSFloat sRoundNearestTiesToEven  :: SDouble  -> SFloat)+          , test1 "toFP_Integer_ToFloat"    (toSFloat sRoundNearestTiesToEven  :: SInteger -> SFloat)+          , test1 "toFP_Real_ToFloat"       (toSFloat sRoundNearestTiesToEven  :: SReal    -> SFloat)++          , test1 "toFP_Int8_ToDouble"      (toSDouble sRoundNearestTiesToEven :: SInt8    -> SDouble)+          , test1 "toFP_Int16_ToDouble"     (toSDouble sRoundNearestTiesToEven :: SInt16   -> SDouble)+          , test1 "toFP_Int32_ToDouble"     (toSDouble sRoundNearestTiesToEven :: SInt32   -> SDouble)+          , test1 "toFP_Int64_ToDouble"     (toSDouble sRoundNearestTiesToEven :: SInt64   -> SDouble)+          , test1 "toFP_Word8_ToDouble"     (toSDouble sRoundNearestTiesToEven :: SWord8   -> SDouble)+          , test1 "toFP_Word16_ToDouble"    (toSDouble sRoundNearestTiesToEven :: SWord16  -> SDouble)+          , test1 "toFP_Word32_ToDouble"    (toSDouble sRoundNearestTiesToEven :: SWord32  -> SDouble)+          , test1 "toFP_Word64_ToDouble"    (toSDouble sRoundNearestTiesToEven :: SWord64  -> SDouble)+          , test1 "toFP_Float_ToDouble"     (toSDouble sRoundNearestTiesToEven :: SFloat   -> SDouble)+          , test1 "toFP_Double_ToDouble"    (toSDouble sRoundNearestTiesToEven :: SDouble  -> SDouble)+          , test1 "toFP_Integer_ToDouble"   (toSDouble sRoundNearestTiesToEven :: SInteger -> SDouble)+          , test1 "toFP_Real_ToDouble"      (toSDouble sRoundNearestTiesToEven :: SReal    -> SDouble)++          , test1 "fromFP_Float_ToInt8"     (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt8)+          , test1 "fromFP_Float_ToInt16"    (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt16)+          , test1 "fromFP_Float_ToInt32"    (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt32)+          , test1 "fromFP_Float_ToInt64"    (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt64)+          , test1 "fromFP_Float_ToWord8"    (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord8)+          , test1 "fromFP_Float_ToWord16"   (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord16)+          , test1 "fromFP_Float_ToWord32"   (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord32)+          , test1 "fromFP_Float_ToWord64"   (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord64)+          , test1 "fromFP_Float_ToFloat"    (fromSFloat sRoundNearestTiesToEven :: SFloat -> SFloat)+          , test1 "fromFP_Float_ToDouble"   (fromSFloat sRoundNearestTiesToEven :: SFloat -> SDouble)+          , test1 "fromFP_Float_ToInteger"  (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInteger)+          , test1 "fromFP_Float_ToReal"     (fromSFloat sRoundNearestTiesToEven :: SFloat -> SReal)++          , test1 "fromFP_DoubleTo_Int8"    (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt8)+          , test1 "fromFP_DoubleTo_Int16"   (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt16)+          , test1 "fromFP_DoubleTo_Int32"   (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt32)+          , test1 "fromFP_DoubleTo_Int64"   (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt64)+          , test1 "fromFP_DoubleTo_Word8"   (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord8)+          , test1 "fromFP_DoubleTo_Word16"  (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord16)+          , test1 "fromFP_DoubleTo_Word32"  (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord32)+          , test1 "fromFP_DoubleTo_Word64"  (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord64)+          , test1 "fromFP_DoubleTo_Float"   (fromSDouble sRoundNearestTiesToEven :: SDouble -> SFloat)+          , test1 "fromFP_DoubleTo_Double"  (fromSDouble sRoundNearestTiesToEven :: SDouble -> SDouble)+          , test1 "fromFP_DoubleTo_Integer" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInteger)+          , test1 "fromFP_DoubleTo_Real"    (fromSDouble sRoundNearestTiesToEven :: SDouble -> SReal)++          , test1 "fromFP_SWord32_SFloat"   (sWord32AsSFloat  :: SWord32 -> SFloat)+          , test1 "fromFP_SWord64_SDouble"  (sWord64AsSDouble :: SWord64 -> SDouble)+          , test1 "fromFP_SFloat_SWord32"   (sFloatAsSWord32  :: SFloat  -> SWord32)+          , test1 "fromFP_SDouble_SWord64"  (sDoubleAsSWord64 :: SDouble -> SWord64)++          , test1 "f_FP_Abs"                (abs    :: SFloat -> SFloat)+          , test1 "d_FP_Abs"                (abs    :: SDouble -> SDouble)++          , test1 "f_FP_Neg"                (negate :: SFloat -> SFloat)+          , test1 "d_FP_Neg"                (negate :: SDouble -> SDouble)++          , test2 "f_FP_Add"                (fpAdd  sRoundNearestTiesToEven :: SFloat  -> SFloat  -> SFloat)+          , test2 "d_FP_Add"                (fpAdd  sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble)++          , test2 "f_FP_Sub"                (fpSub  sRoundNearestTiesToEven :: SFloat  -> SFloat  -> SFloat)+          , test2 "d_FP_Sub"                (fpSub  sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble)++          , test2 "f_FP_Mul"                (fpMul  sRoundNearestTiesToEven :: SFloat  -> SFloat  -> SFloat)+          , test2 "d_FP_Mul"                (fpMul  sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble)++          , test2 "f_FP_Div"                (fpDiv  sRoundNearestTiesToEven :: SFloat  -> SFloat  -> SFloat)+          , test2 "d_FP_Div"                (fpDiv  sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble)++          , test3 "f_FP_FMA"                (fpFMA  sRoundNearestTiesToEven :: SFloat  -> SFloat  -> SFloat  -> SFloat)+          , test3 "d_FP_FMA"                (fpFMA  sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble -> SDouble)++          , test1 "f_FP_Sqrt"               (fpSqrt sRoundNearestTiesToEven :: SFloat  -> SFloat)+          , test1 "d_FP_Sqrt"               (fpSqrt sRoundNearestTiesToEven :: SDouble -> SDouble)++          , test2 "f_FP_Rem"                (fpRem  :: SFloat  -> SFloat  -> SFloat)+          , test2 "d_FP_Rem"                (fpRem  :: SDouble -> SDouble -> SDouble)++          , test1 "f_FP_RoundToIntegral"    (fpRoundToIntegral sRoundNearestTiesToEven :: SFloat  -> SFloat)+          , test1 "d_FP_RoundToIntegral"    (fpRoundToIntegral sRoundNearestTiesToEven :: SDouble -> SDouble)++          , test2 "f_FP_Min"                (fpMin :: SFloat  -> SFloat  -> SFloat)+          , test2 "d_FP_Min"                (fpMin :: SDouble -> SDouble -> SDouble)++          , test2 "f_FP_Max"                (fpMax :: SFloat  -> SFloat  -> SFloat)+          , test2 "d_FP_Max"                (fpMax :: SDouble -> SDouble -> SDouble)++          , test2 "f_FP_IsEqualObject"      (fpIsEqualObject :: SFloat  -> SFloat  -> SBool)+          , test2 "d_FP_IsEqualObject"      (fpIsEqualObject :: SDouble -> SDouble -> SBool)++          , test1 "f_FP_IsNormal"           (fpIsNormal :: SFloat  -> SBool)+          , test1 "d_FP_IsNormal"           (fpIsNormal :: SDouble -> SBool)++          , test1 "f_FP_IsZero"             (fpIsZero :: SFloat  -> SBool)+          , test1 "d_FP_IsZero"             (fpIsZero :: SDouble -> SBool)++          , test1 "f_FP_IsSubnormal"        (fpIsSubnormal :: SFloat  -> SBool)+          , test1 "d_FP_IsSubnormal"        (fpIsSubnormal :: SDouble -> SBool)++          , test1 "f_FP_IsInfinite"         (fpIsInfinite :: SFloat  -> SBool)+          , test1 "d_FP_IsInfinite"         (fpIsInfinite :: SDouble -> SBool)++          , test1 "f_FP_IsNaN"              (fpIsNaN :: SFloat  -> SBool)+          , test1 "d_FP_IsNaN"              (fpIsNaN :: SDouble -> SBool)++          , test1 "f_FP_IsNegative"         (fpIsNegative :: SFloat  -> SBool)+          , test1 "d_FP_IsNegative"         (fpIsNegative :: SDouble -> SBool)++          , test1 "f_FP_IsPositive"         (fpIsPositive :: SFloat  -> SBool)+          , test1 "d_FP_IsPositive"         (fpIsPositive :: SDouble -> SBool)+          ]++{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
+ SBVTestSuite/TestSuite/CodeGeneration/GCD.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CodeGeneration.GCD+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.CodeGeneration.GCD+-----------------------------------------------------------------------------++module TestSuite.CodeGeneration.GCD(tests) where++import Data.SBV.Internals+import Data.SBV.Examples.CodeGeneration.GCD++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "CodeGeneration.GCD" [+   goldenVsStringShow "gcd" gcdC+ ]+ where gcdC = compileToC' "sgcd" $ do+                cgSetDriverValues [55,154]+                x <- cgInput "x"+                y <- cgInput "y"+                cgReturn $ sgcd x y
+ SBVTestSuite/TestSuite/CodeGeneration/PopulationCount.hs view
@@ -0,0 +1,29 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CodeGeneration.PopulationCount+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.CodeGeneration.PopulationCount+-----------------------------------------------------------------------------++module TestSuite.CodeGeneration.PopulationCount(tests) where++import Data.SBV.Internals+import Data.SBV.Examples.CodeGeneration.PopulationCount++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "CodeGeneration.PopulationCount" [+   goldenVsStringShow "popCount1" $ genC False+ , goldenVsStringShow "popCount2" $ genC True+ ]+ where genC b = compileToC' "popCount" $ do+                  cgSetDriverValues [0x0123456789ABCDEF]+                  cgPerformRTCs b+                  x <- cgInput "x"+                  cgReturn $ popCountFast x
+ SBVTestSuite/TestSuite/CodeGeneration/Uninterpreted.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.CodeGeneration.Uninterpreted+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.CodeGeneration.Uninterpreted+-----------------------------------------------------------------------------++module TestSuite.CodeGeneration.Uninterpreted(tests) where++import Data.SBV.Internals+import Data.SBV.Examples.CodeGeneration.Uninterpreted++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "CodeGeneration.Uninterpreted" [+   goldenVsStringShow "cgUninterpret"  genC+ ]+ where genC = compileToC' "tstShiftLeft" $ do+                  cgSetDriverValues [1, 2, 3]+                  [x, y, z] <- cgInputArr 3 "vs"+                  cgReturn $ tstShiftLeft x y z
+ SBVTestSuite/TestSuite/Crypto/AES.hs view
@@ -0,0 +1,34 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Crypto.AES+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Crypto.AES+-----------------------------------------------------------------------------++module TestSuite.Crypto.AES(tests) where++import Data.SBV.Internals+import Data.SBV.Examples.Crypto.AES++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "Crypto.AES" [+   goldenVsStringShow "aes128Enc" $ compileToC'    "aes128Enc" (aes128EncDec True)+ , goldenVsStringShow "aes128Dec" $ compileToC'    "aes128Dec" (aes128EncDec False)+ , goldenVsStringShow "aes128Lib" $ compileToCLib' "aes128Lib" aes128Comps+ ]+ where aes128EncDec d = do pt  <- cgInputArr 4 "pt"+                           key <- cgInputArr 4 "key"+                           cgSetDriverValues $ repeat 0+                           let (encKs, decKs) = aesKeySchedule key+                               res | d    = aesEncrypt pt encKs+                                   | True = aesDecrypt pt decKs+                           cgOutputArr "ct" res+       aes128Comps = [(f, setVals c) | (f, c) <- aes128LibComponents]+       setVals c = cgSetDriverValues (repeat 0) >> c
+ SBVTestSuite/TestSuite/Crypto/RC4.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Crypto.RC4+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Crypto.RC4+-----------------------------------------------------------------------------++module TestSuite.Crypto.RC4(tests) where++import Data.SBV.Tools.STree+import Data.SBV.Examples.Crypto.RC4++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "Crypto.RC4"+    [ testCase "rc4swap" (assertIsThm readWrite)+    ]++readWrite :: SBV Word8 -> SBV Word8 -> SBV Bool+readWrite i j = readSTree (writeSTree initS i j) i .== j
+ SBVTestSuite/TestSuite/Existentials/CRCPolynomial.hs view
@@ -0,0 +1,31 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Existentials.CRCPolynomial+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Existentials.CRCPolynomial+-----------------------------------------------------------------------------++module TestSuite.Existentials.CRCPolynomial(tests) where++import Data.SBV.Examples.Existentials.CRCPolynomial++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "Existentials.CRCPolynomial" [+  goldenVsStringShow "crcPolyExist" pgm+ ]+ where pgm = runSAT $ do+                p <- exists "poly"+                s <- do sh <- forall "sh"+                        sl <- forall "sl"+                        return (sh, sl)+                r <- do rh <- forall "rh"+                        rl <- forall "rl"+                        return (rh, rl)+                output $ sTestBit p 0 &&& crcGood 4 p s r
+ SBVTestSuite/TestSuite/GenTest/GenTests.hs view
@@ -0,0 +1,32 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.GenTest.GenTests+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test-suite for generating tests+-----------------------------------------------------------------------------++module TestSuite.GenTest.GenTests(tests) where++import Data.SBV.Tools.GenTest++import System.Random++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "GenTest.GenTests"+   [ goldenCapturedIO "tgen_haskell" $ render (Haskell "haskTest")+   , goldenCapturedIO "tgen_c"       $ render (C       "CTest")+   , goldenCapturedIO "tgen_forte"   $ render (Forte   "ForteTest" True ([32,32], [32,32,32]))+   ]+ where simple = genTest 10 $ do x <- sWord32 "x"+                                y <- sWord32 "y"+                                return (x+y, x-y, x*y)+       render s f = do setStdGen (mkStdGen 0)  -- make sure we always get the same results!+                       r <- renderTest s <$> simple+                       writeFile f r
+ SBVTestSuite/TestSuite/Optimization/AssertSoft.hs view
@@ -0,0 +1,48 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Optimization.AssertSoft+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for optimization routines, soft assertions+-----------------------------------------------------------------------------++module TestSuite.Optimization.AssertSoft(tests) where++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Optimization.AssertSoft"+    [ goldenVsStringShow "assertSoft1" (optimize Lexicographic assertSoft1)+    , goldenVsStringShow "assertSoft2" (optimize Lexicographic assertSoft2)+    ]++assertSoft1 :: Goal+assertSoft1 = do x <- sInteger "x"+                 y <- sInteger "y"++                 let a1 = x .> 0+                     a2 = x .< y+                     a3 = x+y .<= 0++                 constrain $ a1 .== a3+                 constrain $ a3 ||| a2++                 assertSoft "as1" a3        (Penalty  3 Nothing)+                 assertSoft "as2" (bnot a3) (Penalty  5 Nothing)+                 assertSoft "as3" (bnot a1) (Penalty 10 Nothing)+                 assertSoft "as4" (bnot a2) (Penalty  3 Nothing)++assertSoft2 :: Goal+assertSoft2 = do a1 <- sBool "a1"+                 a2 <- sBool "a2"+                 a3 <- sBool "a3"++                 assertSoft "as_a1" a1                    (Penalty  0.1 Nothing)+                 assertSoft "as_a2" a2                    (Penalty  1.0 Nothing)+                 assertSoft "as_a3" a3                    (Penalty  1   Nothing)+                 assertSoft "as_a4" (bnot a1 ||| bnot a2) (Penalty 3.2 Nothing)
+ SBVTestSuite/TestSuite/Optimization/Basics.hs view
@@ -0,0 +1,41 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Optimization.Basics+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for optimization routines+-----------------------------------------------------------------------------++module TestSuite.Optimization.Basics(tests) where++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Optimization.Basics"+    [ goldenVsStringShow "optBasics1" (optimize Lexicographic optBasics1)+    , goldenVsStringShow "optBasics2" (optimize Lexicographic optBasics2)+    ]++optBasics1 :: Goal+optBasics1 = do x <- sInteger "x"+                y <- sInteger "y"++                constrain $ x .< 2+                constrain $ y - x .< 1++                maximize "x_plus_y" $ x+y++optBasics2 :: Goal+optBasics2 = do x <- sInteger "x"+                y <- sInteger "y"++                constrain $ x .< 4+                constrain $ y - x .< 1+                constrain $ y .> 1++                minimize "x_plus_y" $ x+y
+ SBVTestSuite/TestSuite/Optimization/Combined.hs view
@@ -0,0 +1,90 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Optimization.Combined+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for optimization routines, combined objectives+-----------------------------------------------------------------------------++module TestSuite.Optimization.Combined(tests) where++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Optimization.Combined"+    [ goldenVsStringShow "combined1" (optimize Lexicographic      combined1)+    , goldenVsStringShow "combined2" (optimize Lexicographic      combined2)+    , goldenVsStringShow "pareto1"   (optimize (Pareto Nothing)   pareto1)+    , goldenVsStringShow "pareto2"   (optimize (Pareto (Just 30)) pareto2)+    , goldenVsStringShow "boxed1"    (optimize Independent        boxed1)+    ]++combined1 :: Goal+combined1 = do x <- sInteger "x"+               y <- sInteger "y"+               z <- sInteger "z"++               constrain $ x .< z+               constrain $ y .< z+               constrain $ z .< 5+               constrain $ x ./= y++               maximize "max_x" x+               maximize "max_y" y++combined2 :: Goal+combined2 = do a <- sBool "a"+               b <- sBool "b"+               c <- sBool "c"++               assertSoft "soft_a" a (Penalty 1 (Just "A"))+               assertSoft "soft_b" b (Penalty 2 (Just "B"))+               assertSoft "soft_c" c (Penalty 3 (Just "A"))++               constrain $ a .== c+               constrain $ bnot (a &&& b)++pareto1 :: Goal+pareto1 = do x <- sInteger "x"+             y <- sInteger "y"++             constrain $ 5 .>= x+             constrain $ x .>= 0+             constrain $ 4 .>= y+             constrain $ y .>= 0++             minimize "min_x"            x+             maximize "max_x_plus_y"   $ x + y+             minimize "min_y"            y++pareto2 :: Goal+pareto2 = do x <- sInteger "x"+             y <- sInteger "y"++             constrain $ 5 .>= x+             constrain $ x .>= 0++             minimize "min_x"            x+             maximize "max_y"            y+             minimize "max_x_plus_y"   $ x + y++boxed1 :: Goal+boxed1 = do x <- sReal "x"+            y <- sReal "y"++            constrain $ 5 .>= x-y+            constrain $ x .>= 0+            constrain $ 4 .>= y+            constrain $ y .> 0++            minimize "min_x"        x+            maximize "max_x_plus_y" (x + y)+            minimize "min_y"        y+            maximize "max_y"        y++{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
+ SBVTestSuite/TestSuite/Optimization/ExtensionField.hs view
@@ -0,0 +1,53 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Optimization.ExtensionField+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for optimization routines, extension field+-----------------------------------------------------------------------------++module TestSuite.Optimization.ExtensionField(tests) where++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Optimization.ExtensionField"+    [ goldenVsStringShow "optExtField1" (optimize Lexicographic optExtField1)+    , goldenVsStringShow "optExtField2" (optimize Lexicographic optExtField2)+    , goldenVsStringShow "optExtField3" (optimize Lexicographic optExtField3)+    ]++optExtField1 :: Goal+optExtField1 = do x <- sInteger "x"+                  y <- sInteger "y"++                  constrain $ x .< 4+                  constrain $ y - x .> 1++                  maximize "x_plus_y" $ x+y++optExtField2 :: Goal+optExtField2 = do x <- sInteger "x"+                  y <- sInteger "y"++                  constrain $ x .< 4+                  constrain $ y - x .< 1+                  constrain $ y .< 1++                  minimize "x_plus_y" $ x+y++optExtField3 :: Goal+optExtField3 = do x <- sReal "x"+                  y <- sReal "y"++                  constrain $ x .< 4+                  constrain $ y .< 5++                  maximize "x_plus_y" $ x + y++{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
+ SBVTestSuite/TestSuite/Optimization/Reals.hs view
@@ -0,0 +1,38 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Optimization.Reals+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for optimization routines, reals+-----------------------------------------------------------------------------++module TestSuite.Optimization.Reals(tests) where++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Optimization.Reals"+    [ goldenVsStringShow "optReal1" (optimize Lexicographic p)+    ]++p :: Goal+p = do x <- sReal "x"+       y <- sReal "y"+       z <- sReal "z"+       w <- sReal "w"++       constrain $ x .>= 0+       constrain $ y .>= 0+       constrain $ z .>= 0+       constrain $ w .>= 0++       constrain $ x + y + z + w .<= 40+       constrain $ 2 * x + y - z - w .>= 10+       constrain $ w - y .>= 10++       maximize "p" $ 0.5 * x + 3 * y + z + 4 * w
+ SBVTestSuite/TestSuite/Polynomials/Polynomials.hs view
@@ -0,0 +1,25 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Polynomials.Polynomials+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Polynomials.Polynomials+-----------------------------------------------------------------------------++module TestSuite.Polynomials.Polynomials(tests) where++import Data.SBV.Examples.Polynomials.Polynomials++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Polynomials.Polynomials"+    [ testCase "polynomial-1" (assertIsThm multUnit)+    , testCase "polynomial-2" (assertIsThm multComm)+    , testCase "polynomial-3" (assertIsThm polyDivMod)+    ]
+ SBVTestSuite/TestSuite/Puzzles/Coins.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Puzzles.Coins+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Puzzles.Coins+-----------------------------------------------------------------------------++module TestSuite.Puzzles.Coins(tests) where++import Data.SBV.Examples.Puzzles.Coins++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "Puzzles.Coins" [+  goldenVsStringShow "coins" coinsPgm+ ]+ where coinsPgm = runSAT $ do cs <- mapM mkCoin [1..6]+                              mapM_ constrain [c s | s <- combinations cs, length s >= 2, c <- [c1, c2, c3, c4, c5, c6]]+                              constrain $ bAnd $ zipWith (.>=) cs (tail cs)+                              output $ sum cs .== 115
+ SBVTestSuite/TestSuite/Puzzles/Counts.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Puzzles.Counts+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Puzzles.Counts+-----------------------------------------------------------------------------++module TestSuite.Puzzles.Counts(tests) where++import Data.SBV.Examples.Puzzles.Counts++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests = testGroup "Puzzles.Counts" [+  goldenVsStringShow "counts" countPgm+ ]+ where countPgm = runSAT $ forAll_ puzzle' >>= output+       puzzle' d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 = puzzle [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9]
+ SBVTestSuite/TestSuite/Puzzles/DogCatMouse.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Puzzles.DogCatMouse+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Puzzles.DogCatMouse+-----------------------------------------------------------------------------++module TestSuite.Puzzles.DogCatMouse(tests) where++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Puzzles.DogCatMouse"+    [ goldenVsStringShow "dogCatMouse" (allSat p)+    ]+ where p = do [dog, cat, mouse] <- sIntegers ["dog", "cat", "mouse"]+              solve [ dog   .>= 1                                   -- at least one dog+                    , cat   .>= 1                                   -- at least one cat+                    , mouse .>= 1                                   -- at least one mouse+                    , dog + cat + mouse .== 100                     -- buy precisely 100 animals+                    , 1500 * dog + 100 * cat + 25 * mouse .== 10000 -- spend exactly 100 dollars (use cents since we don't have fractions)+                    ]
+ SBVTestSuite/TestSuite/Puzzles/Euler185.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Puzzles.Euler185+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Puzzles.Euler185+-----------------------------------------------------------------------------++module TestSuite.Puzzles.Euler185(tests) where++import Data.SBV.Examples.Puzzles.Euler185++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Puzzles.Euler185"+    [ goldenVsStringShow "euler185" (allSat euler185)+    ]
+ SBVTestSuite/TestSuite/Puzzles/MagicSquare.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Puzzles.MagicSquare+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Puzzles.MagicSquare+-----------------------------------------------------------------------------++module TestSuite.Puzzles.MagicSquare(tests) where++import Data.SBV.Examples.Puzzles.MagicSquare++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "Puzzles.MagicSquare"+    [ testCase "magic 2" (assertIsntSat (mkMagic 2))+    , testCase "magic 3" (assertIsSat (mkMagic 3))+    ]+++mkMagic :: Int -> Symbolic SBool+mkMagic n = (isMagic . chunk n) `fmap` mkExistVars (n*n)
+ SBVTestSuite/TestSuite/Puzzles/NQueens.hs view
@@ -0,0 +1,33 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Puzzles.NQueens+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Puzzles.NQueens+-----------------------------------------------------------------------------++module TestSuite.Puzzles.NQueens(tests) where++import Data.SBV.Examples.Puzzles.NQueens++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "Puzzles.NQueens"+    -- number of *distinct* solutions is given in http://en.wikipedia.org/wiki/Eight_queens_puzzle+   [ testCase "nQueens 1" (assert $ (==  1) `fmap` numberOfModels (mkQueens 1))+   , testCase "nQueens 2" (assert $ (==  0) `fmap` numberOfModels (mkQueens 2))+   , testCase "nQueens 3" (assert $ (==  0) `fmap` numberOfModels (mkQueens 3))+   , testCase "nQueens 4" (assert $ (==  2) `fmap` numberOfModels (mkQueens 4))+   , testCase "nQueens 5" (assert $ (== 10) `fmap` numberOfModels (mkQueens 5))+   , testCase "nQueens 6" (assert $ (==  4) `fmap` numberOfModels (mkQueens 6))+   , testCase "nQueens 7" (assert $ (== 40) `fmap` numberOfModels (mkQueens 7))+   , testCase "nQueens 8" (assert $ (== 92) `fmap` numberOfModels (mkQueens 8))+   ]++mkQueens :: Int -> Symbolic SBool+mkQueens n = isValid n `fmap` mkExistVars n
+ SBVTestSuite/TestSuite/Puzzles/PowerSet.hs view
@@ -0,0 +1,25 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Puzzles.PowerSet+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.Puzzles.PowerSet+-----------------------------------------------------------------------------++module TestSuite.Puzzles.PowerSet(tests) where++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "Puzzles.PowerSet"+    [ testCase ("powerSet " ++ show i) (assert (pSet i)) | i <- [0 .. 7] ]++pSet :: Int -> IO Bool+pSet n = do cnt <- numberOfModels $ do _ <- mapM (\i -> sBool ("e" ++ show i)) [1..n]+                                       -- Look ma! No constraints!+                                       return (true :: SBool)+            return (cnt == 2^n)
+ SBVTestSuite/TestSuite/Puzzles/Sudoku.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Puzzles.Sudoku+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Puzzles.Sudoku+-----------------------------------------------------------------------------++module TestSuite.Puzzles.Sudoku(tests) where++import Data.SBV.Examples.Puzzles.Sudoku++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "Puzzles.Sudoku"+    [ testCase ("sudoku " ++ show n) (assert (checkPuzzle s))+       | (n, s) <-+           zip+             [(0::Int)..]+             [puzzle0, puzzle1, puzzle2, puzzle3, puzzle4, puzzle5, puzzle6] ]++checkPuzzle :: Puzzle -> IO Bool+checkPuzzle (i, f) = isSatisfiable $ (valid . f) `fmap` mkExistVars i
+ SBVTestSuite/TestSuite/Puzzles/Temperature.hs view
@@ -0,0 +1,35 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Puzzles.Temperature+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.Puzzles.Temperature+-----------------------------------------------------------------------------++module TestSuite.Puzzles.Temperature(tests) where++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Puzzles.Temperature"+    [ goldenVsStringShow "temperature" (allSat (revOf `fmap` exists_))+    ]++type Temp = SInteger++-- convert celcius to fahrenheit, rounding up/down properly+-- we have to be careful here to make sure rounding is done properly..+d2f :: Temp -> Temp+d2f d = 32 + ite (fr .>= 5) (1+fi) fi+  where (fi, fr) = (18 * d) `sQuotRem` 10++-- puzzle: What 2 digit fahrenheit/celcius values are reverses of each other?+revOf :: Temp -> SBool+revOf c = swap (digits c) .== digits (d2f c)+  where digits x = x `sQuotRem` 10+        swap (a, b) = (b, a)
+ SBVTestSuite/TestSuite/Puzzles/U2Bridge.hs view
@@ -0,0 +1,31 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Puzzles.U2Bridge+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Puzzles.U2Bridge+-----------------------------------------------------------------------------++module TestSuite.Puzzles.U2Bridge(tests) where++import Data.SBV.Examples.Puzzles.U2Bridge++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Puzzles.U2Bridge"+    [ testCase "U2Bridge_cnt1" (assert $ (0 ==) `fmap` count 1)+    , testCase "U2Bridge_cnt2" (assert $ (0 ==) `fmap` count 2)+    , testCase "U2Bridge_cnt3" (assert $ (0 ==) `fmap` count 3)+    , testCase "U2Bridge_cnt4" (assert $ (0 ==) `fmap` count 4)+    , testCase "U2Bridge_cnt6" (assert $ (0 ==) `fmap` count 6)+    , goldenVsStringShow "U2Bridge" (slv 5)+    ]+ where act     = do b <- exists_; p1 <- exists_; p2 <- exists_; return (b, p1, p2)+       count n = numberOfModels $ isValid `fmap` mapM (const act) [1..(n::Int)]+       slv n   = sat $ isValid `fmap` mapM (const act) [1..(n::Int)]
+ SBVTestSuite/TestSuite/Queries/BasicQuery.hs view
@@ -0,0 +1,131 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Queries.BasicQuery+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- A hodgepodge of query commands+-----------------------------------------------------------------------------++{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.Queries.BasicQuery (tests)  where++import Data.SBV.Control++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.Query"+    [ goldenCapturedIO "noTravis_query1" testQuery+    ]++testQuery :: FilePath -> IO ()+testQuery rf = do r <- runSMTWith defaultSMTCfg{verbose=True, redirectVerbose=Just rf} query1+                  appendFile rf ("\n FINAL:" ++ show (SatResult r) ++ "\nDONE!\n")++query1 :: Symbolic SMTResult+query1 = do+       a <- sInteger "a"+       b <- sInteger "b"++       c <- sFloat "c"+       d <- sBool "d"++       e <- sReal "e"++       (f :: SWord8) <- free_++       namedConstraint "a > 0" $ a .> 0+       constrain $ b .> 0++       setOption $ ProduceUnsatCores True+       setOption $ ProduceUnsatAssumptions True+       setOption $ ProduceProofs True+       setOption $ RandomSeed 123+       setOption $ ProduceAssertions True+       setOption $ OptionKeyword ":smt.mbqi" ["true"]+       setOption $ ProduceAssignments True++       setInfo ":status" ["sat"]+       setInfo ":bad" ["what"]++       query $ do constrain $ a+2 .>= 5+                  namedConstraint "a+b_<_12" $ a+b .< 12++                  _ <- getOption DiagnosticOutputChannel+                  _ <- getOption ProduceAssertions+                  _ <- getOption ProduceAssignments+                  _ <- getOption ProduceProofs+                  _ <- getOption ProduceUnsatAssumptions+                  _ <- getOption ProduceUnsatCores+                  _ <- getOption RandomSeed+                  _ <- getOption ReproducibleResourceLimit+                  _ <- getOption SMTVerbosity+                  _ <- getOption (OptionKeyword ":smt.mbqi")+                  _ <- getOption (OptionKeyword ":smt.mbqi")++                  _ <- getInfo ReasonUnknown+                  _ <- getInfo (InfoKeyword ":version")+                  _ <- getInfo (InfoKeyword ":status")++                  namedConstraint "later, a > 4" $ a .> 4++                  cs <- checkSat++                  case cs of+                    Sat -> return ()+                    Unk -> getInfo ReasonUnknown >>= error . show+                    r   -> error $ "Something went bad, why not-sat/unk?: " ++ show r++                  setInfo ":status" ["unknown"]++                  _ <- checkSatAssumingWithUnsatisfiableSet [a .> 2]+                  _ <- checkSatAssuming [a .> 2]+                  _ <- getAssignment++                  -- ends up printing different numbers on different machines..+                  -- _ <- getInfo AllStatistics++                  _ <- getInfo AssertionStackLevels+                  _ <- getInfo Authors+                  _ <- getInfo ErrorBehavior+                  _ <- getInfo Name+                  _ <- getInfo ReasonUnknown+                  _ <- getInfo Version+                  _ <- getInfo (InfoKeyword ":memory")+                  _ <- getInfo (InfoKeyword ":time")++                  -- Query a/b+                  av <- getValue a+                  bv <- getValue b++                  _ <- checkSatAssumingWithUnsatisfiableSet [a .> 100,  a .> 9]++                  push 5+                  pop 3+                  _ <- getAssertionStackDepth++                  -- Now assert so that we get even a bigger value..+                  namedConstraint "bey" $ a .> literal (av + bv)+                  namedConstraint "hey" $ a .< literal (av + bv)+                  _ <- checkSat+                  _ <- timeout 4000 getUnsatCore++                  _ <- getProof+                  _ <- timeout 6000 getAssertions++                  echo "there we go"++                  -- fake it!+                  mkSMTResult [ a |-> 332+                              , b |-> 3+                              , c |-> 2.3+                              , d |-> True+                              , e |-> 3.12+                              , f |-> (-12)+                              ]
+ SBVTestSuite/TestSuite/Queries/Enums.hs view
@@ -0,0 +1,49 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Queries.Enums+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Uninterpreted.AUF+-----------------------------------------------------------------------------++{-# LANGUAGE TemplateHaskell     #-}+{-# LANGUAGE StandaloneDeriving  #-}+{-# LANGUAGE DeriveDataTypeable  #-}+{-# LANGUAGE DeriveAnyClass      #-}+{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.Queries.Enums where++import Data.SBV.Control++import Utils.SBVTestFramework++data BinOp  = Plus | Minus | Times+mkSymbolicEnumeration ''BinOp++-- Test suite+tests :: TestTree+tests =+  testGroup "Queries.Enums"+    [ goldenCapturedIO "qEnum1" $ \rf -> runSMTWith defaultSMTCfg{verbose=True, redirectVerbose=Just rf} test+    ]++type SBinOp = SBV BinOp++test :: Symbolic ()+test = do p :: SBinOp <- free "p"+          m :: SBinOp <- free "m"+          t :: SBinOp <- free "t"++          constrain $ p .<= m+          constrain $ m .<= t+          constrain $ distinct [p, m, t]++          query $ do _ <- checkSat+                     _ <- getValue p+                     _ <- getValue m+                     _ <- getValue t+                     return ()
+ SBVTestSuite/TestSuite/Queries/FreshVars.hs view
@@ -0,0 +1,108 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Queries.FreshVars+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Testing fresh-vars in query mode+-----------------------------------------------------------------------------++{-# LANGUAGE TemplateHaskell     #-}+{-# LANGUAGE StandaloneDeriving  #-}+{-# LANGUAGE DeriveDataTypeable  #-}+{-# LANGUAGE DeriveAnyClass      #-}+{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.Queries.FreshVars (tests)  where++import Data.SBV.Control++import Utils.SBVTestFramework++data BinOp  = Plus | Minus | Times+mkSymbolicEnumeration ''BinOp++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.Query"+    [ goldenCapturedIO "freshVars" testQuery+    ]++testQuery :: FilePath -> IO ()+testQuery rf = do r <- runSMTWith defaultSMTCfg{verbose=True, redirectVerbose=Just rf} fv+                  appendFile rf ("\n FINAL:" ++ show (SatResult r) ++ "\nDONE!\n")++type SBinOp = SBV BinOp++fv :: Symbolic SMTResult+fv = do a <- sInteger "a"++        constrain $ a .== 0++        query $ do vBool    :: SBool    <- freshVar  "vBool"+                   vWord8   :: SWord8   <- freshVar  "vWord8"+                   vWord16  :: SWord16  <- freshVar_+                   vWord32  :: SWord32  <- freshVar_+                   vWord64  :: SWord64  <- freshVar  "vWord64"+                   vInt8    :: SInt8    <- freshVar  "vInt8"+                   vInt16   :: SInt16   <- freshVar_+                   vInt32   :: SInt32   <- freshVar_+                   vInt64   :: SInt64   <- freshVar  "vInt64"+                   vFloat   :: SFloat   <- freshVar  "vFloat"+                   vDouble  :: SDouble  <- freshVar_+                   vReal    :: SReal    <- freshVar_+                   vInteger :: SInteger <- freshVar  "vInteger"+                   vBinOp   :: SBinOp   <- freshVar  "vBinOp"+                   constrain   vBool+                   constrain $ vWord8   .== 1+                   constrain $ vWord16  .== 2+                   constrain $ vWord32  .== 3+                   constrain $ vWord64  .== 4+                   constrain $ vInt8    .== 5+                   constrain $ vInt16   .== 6+                   constrain $ vInt32   .== 7+                   constrain $ vInt64   .== 8+                   constrain $ vFloat   .== 9+                   constrain $ vDouble  .== 10+                   constrain $ vReal    .== 11+                   constrain $ vInteger .== 12+                   constrain $ vBinOp   .== literal Plus++                   cs <- checkSat+                   case cs of+                     Sat -> do aVal        <- getValue a+                               vBoolVal    <- getValue vBool+                               vWord8Val   <- getValue vWord8+                               vWord16Val  <- getValue vWord16+                               vWord32Val  <- getValue vWord32+                               vWord64Val  <- getValue vWord64+                               vInt8Val    <- getValue vInt8+                               vInt16Val   <- getValue vInt16+                               vInt32Val   <- getValue vInt32+                               vInt64Val   <- getValue vInt64+                               vFloatVal   <- getValue vFloat+                               vDoubleVal  <- getValue vDouble+                               vRealVal    <- getValue vReal+                               vIntegerVal <- getValue vInteger+                               vBinOpVal   <- getValue vBinOp++                               mkSMTResult [ a        |-> aVal+                                           , vBool    |-> vBoolVal+                                           , vWord8   |-> vWord8Val+                                           , vWord16  |-> vWord16Val+                                           , vWord32  |-> vWord32Val+                                           , vWord64  |-> vWord64Val+                                           , vInt8    |-> vInt8Val+                                           , vInt16   |-> vInt16Val+                                           , vInt32   |-> vInt32Val+                                           , vInt64   |-> vInt64Val+                                           , vFloat   |-> vFloatVal+                                           , vDouble  |-> vDoubleVal+                                           , vReal    |-> vRealVal+                                           , vInteger |-> vIntegerVal+                                           , vBinOp   |-> vBinOpVal+                                           ]+                     _   -> error "didn't expect non-Sat here!"
+ SBVTestSuite/TestSuite/Queries/Int_ABC.hs view
@@ -0,0 +1,49 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Queries.Int_ABC+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Testing ABC specific interactive features.+-----------------------------------------------------------------------------+{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.Queries.Int_ABC (tests)  where++import Data.SBV.Control++import Control.Monad (unless)++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.QueryIndividual"+    [ goldenCapturedIO "noTravis_query_abc" $ \rf -> runSMTWith abc{verbose=True, redirectVerbose=Just rf} q+    ]++q :: Symbolic ()+q = do a <- sInt32 "a"+       b <- sInt32 "b"++       constrain $ a .> 0+       constrain $ b .> 0++       -- this is severely limited since ABC doesn't like multi check-sat calls, oh well.+       query $ do constrain $ a+2 .<= 15+                  constrain $ a   .<  2+                  constrain $ b   .<  2+                  constrain $ a+b .< 12++                  constrain $ a .< 2+                  cs <- checkSat++                  case cs of+                    Unk   -> getInfo ReasonUnknown >>= error . show+                    Unsat -> error "Got UNSAT!"+                    Sat   -> do -- Query a/b+                                res <- (,) <$> getValue a <*> getValue b+                                unless (res == (1, 1)) $ error $ "Didn't get (1,1): " ++ show res
+ SBVTestSuite/TestSuite/Queries/Int_Boolector.hs view
@@ -0,0 +1,53 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Queries.Int_Boolector+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Testing Boolector specific interactive features.+-----------------------------------------------------------------------------+{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.Queries.Int_Boolector (tests)  where++import Data.SBV.Control++import Control.Monad (unless)++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.QueryIndividual"+    [ goldenCapturedIO "noTravis_query_boolector" $ \rf -> runSMTWith boolector{verbose=True, redirectVerbose=Just rf} q+    ]++q :: Symbolic ()+q = do a <- sInt32 "a"+       b <- sInt32 "b"++       constrain $ a .> 0+       constrain $ b .> 0++       query $ do constrain $ a+2 .<= 15+                  constrain $ a   .<  3+                  constrain $ b   .<  2+                  constrain $ a+b .< 12++                  constrain $ a .< 2+                  cs <- checkSat++                  case cs of+                    Sat -> return ()+                    Unk -> getInfo ReasonUnknown >>= error . show+                    r   -> error $ "Something went bad, why not-sat/unk?: " ++ show r++                  -- Now assert so that we get even a bigger value..+                  constrain $ a .>= 1+                  _ <- checkSat++                  res <- (,) <$> getValue a <*> getValue b+                  unless (res == (1, 1)) $ error $ "Didn't get (1,1): " ++ show res
+ SBVTestSuite/TestSuite/Queries/Int_CVC4.hs view
@@ -0,0 +1,58 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Queries.Int_CVC4+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Testing CVC4 specific interactive features+-----------------------------------------------------------------------------+{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.Queries.Int_CVC4 (tests)  where++import Data.SBV.Control++import Control.Monad (unless)++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.QueryIndividual"+    [ goldenCapturedIO "noTravis_query_cvc4" $ \rf -> runSMTWith cvc4{verbose=True, redirectVerbose=Just rf} q+    ]++q :: Symbolic ()+q = do a <- sInt32 "a"+       b <- sInt32 "b"++       namedConstraint "a > 0" $ a .> 0+       constrain $ b .> 0++       query $ do constrain $ a+2 .<= 15+                  constrain $ a   .<  3+                  constrain $ b   .<  2+                  namedConstraint "a+b_<_12" $ a+b .< 12++                  av <- inNewAssertionStack $ do++                            constrain $ a .< 2+                            cs <- checkSat++                            case cs of+                              Sat -> return ()+                              Unk -> getInfo ReasonUnknown >>= error . show+                              r   -> error $ "Something went bad, why not-sat/unk?: " ++ show r++                            getValue a++                  -- Now assert so that we get even a bigger value..+                  namedConstraint "extra" $ a .> literal av+                  constrain $ b .< 2+                  _ <- checkSat++                  res <- (,) <$> getValue a <*> getValue b+                  unless (res == (2, 1)) $ error $ "Didn't get (2,1): " ++ show res
+ SBVTestSuite/TestSuite/Queries/Int_Mathsat.hs view
@@ -0,0 +1,53 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Queries.Int_Mathsat+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Testing MathSAT specific interactive features.+-----------------------------------------------------------------------------+{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.Queries.Int_Mathsat (tests)  where++import Data.SBV.Control++import Control.Monad (unless)++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.QueryIndividual"+    [ goldenCapturedIO "noTravis_query_mathsat" $ \rf -> runSMTWith mathSAT{verbose=True, redirectVerbose=Just rf} q+    ]++q :: Symbolic ()+q = do a <- sInt32 "a"+       b <- sInt32 "b"++       namedConstraint "a > 0" $ a .> 0+       constrain $ b .> 0++       query $ do constrain $ a+2 .<= 15+                  constrain $ a   .<  3+                  constrain $ b   .<  2+                  namedConstraint "a+b_<_12" $ a+b .< 12++                  constrain $ a .< 2+                  cs <- checkSat++                  case cs of+                    Sat -> return ()+                    Unk -> getInfo ReasonUnknown >>= error . show+                    r   -> error $ "Something went bad, why not-sat/unk?: " ++ show r++                  -- Now assert so that we get even a bigger value..+                  namedConstraint "extra" $ a .>= 1+                  _ <- checkSat++                  res <- (,) <$> getValue a <*> getValue b+                  unless (res == (1, 1)) $ error $ "Didn't get (1,1): " ++ show res
+ SBVTestSuite/TestSuite/Queries/Int_Yices.hs view
@@ -0,0 +1,53 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Queries.Int_Yices+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Testing Yices specific interactive features.+-----------------------------------------------------------------------------+{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.Queries.Int_Yices (tests)  where++import Data.SBV.Control++import Control.Monad (unless)++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.QueryIndividual"+    [ goldenCapturedIO "noTravis_query_yices" $ \rf -> runSMTWith yices{verbose=True, redirectVerbose=Just rf} q+    ]++q :: Symbolic ()+q = do a <- sInt32 "a"+       b <- sInt32 "b"++       namedConstraint "a > 0" $ a .> 0+       constrain $ b .> 0++       query $ do constrain $ a+2 .<= 15+                  constrain $ a   .<  3+                  constrain $ b   .<  2+                  namedConstraint "a+b_<_12" $ a+b .< 12++                  constrain $ a .< 2+                  cs <- checkSat++                  case cs of+                    Sat -> return ()+                    Unk -> getInfo ReasonUnknown >>= error . show+                    r   -> error $ "Something went bad, why not-sat/unk?: " ++ show r++                  -- Now assert so that we get even a bigger value..+                  namedConstraint "extra" $ a .>= 1+                  _ <- checkSat++                  res <- (,) <$> getValue a <*> getValue b+                  unless (res == (1, 1)) $ error $ "Didn't get (1,1): " ++ show res
+ SBVTestSuite/TestSuite/Queries/Int_Z3.hs view
@@ -0,0 +1,60 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Queries.Int_Z3+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Testing Z3 specific interactive features.+-----------------------------------------------------------------------------+{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.Queries.Int_Z3 (tests)  where++import Data.SBV.Control++import Control.Monad (unless)++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Basics.QueryIndividual"+    [ goldenCapturedIO "query_z3" $ \rf -> runSMTWith z3{verbose=True, redirectVerbose=Just rf} q+    ]++q :: Symbolic ()+q = do a <- sInt32 "a"+       b <- sInt32 "b"++       namedConstraint "a > 0" $ a .> 0+       constrain $ b .> 0++       query $ do constrain $ a+2 .<= 15+                  constrain $ a   .<  3+                  constrain $ b   .<  2+                  namedConstraint "a+b_<_12" $ a+b .< 12++                  gv <- inNewAssertionStack $ do++                            constrain $ a .< 2+                            cs <- checkSat++                            case cs of+                              Sat -> return ()+                              Unk -> getInfo ReasonUnknown >>= error . show+                              r   -> error $ "Something went bad, why not-sat/unk?: " ++ show r++                            -- Query a/b+                            getValue a++                  -- Now assert so that we get even a bigger value..+                  namedConstraint "extra" $ a .> literal gv+                  constrain $ b .< 2++                  _ <- checkSat++                  res <- (,) <$> getValue a <*> getValue b+                  unless (res == (2, 1)) $ error $ "Didn't get (2,1): " ++ show res
+ SBVTestSuite/TestSuite/Queries/Uninterpreted.hs view
@@ -0,0 +1,45 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Queries.Uninterpreted+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Testing uninterpreted value extraction+-----------------------------------------------------------------------------++{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE DeriveDataTypeable  #-}++module TestSuite.Queries.Uninterpreted where++import Data.Generics+import Data.SBV.Control++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Queries.Uninterpreted"+    [ goldenCapturedIO "qUninterp1" testQuery+    ]++testQuery :: FilePath -> IO ()+testQuery rf = do r <- runSMTWith defaultSMTCfg{verbose=True, redirectVerbose=Just rf} unint1+                  appendFile rf ("\n FINAL:" ++ r ++ "\nDONE!\n")+++data L = A | B ()+       deriving (Eq, Ord, Show, Read, Data)++instance SymWord L+instance HasKind L+instance SMTValue L++unint1 :: Symbolic String+unint1 = do (x :: SBV L) <- free_++            query $ do _ <- checkSat+                       getUninterpretedValue x
+ SBVTestSuite/TestSuite/Uninterpreted/AUF.hs view
@@ -0,0 +1,29 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Uninterpreted.AUF+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Data.SBV.Examples.Uninterpreted.AUF+-----------------------------------------------------------------------------++module TestSuite.Uninterpreted.AUF where++import Data.SBV.Examples.Uninterpreted.AUF++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Uninterpreted.AUF"+    [ goldenVsStringShow "auf-1" pgm+    , testCase "auf-2" (assertIsThm (free "x" >>= \x -> free "y" >>= \y -> return (thm1 x y (mkSFunArray (const 0)))))+    , testCase "auf-3" (assertIsThm (newArray "b" >>= \b -> free "x" >>= \x -> free "y" >>= \y -> return (thm2 x y b)))+    ]+ where pgm = runSAT $ do+                x <- free "x"+                y <- free "y"+                output $ thm1 x y (mkSFunArray (const 0))
+ SBVTestSuite/TestSuite/Uninterpreted/Axioms.hs view
@@ -0,0 +1,47 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Uninterpreted.Axioms+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for basic axioms and uninterpreted functions+-----------------------------------------------------------------------------++{-# LANGUAGE DeriveAnyClass     #-}+{-# LANGUAGE DeriveDataTypeable #-}++module TestSuite.Uninterpreted.Axioms(tests) where++import Utils.SBVTestFramework+import Data.Generics++tests :: TestTree+tests =+  testGroup "Uninterpreted.Axioms"+    [ testCase "unint-axioms" (assertIsThm p0) ]++-- Example provided by Thomas DuBuisson:+newtype Bitstring = Bitstring () deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind)+type SBitstring = SBV Bitstring++a :: SBitstring -> SBool+a = uninterpret "a"++e :: SBitstring -> SBitstring -> SBitstring+e = uninterpret "e"++axE :: [String]+axE = [ "(assert (forall ((p Bitstring) (k Bitstring))"+      , "         (=> (and (a k) (a p)) (a (e k p)))))"+      ]++p0 :: Symbolic SBool+p0 = do+    p <- free "p" :: Symbolic SBitstring+    k <- free "k" :: Symbolic SBitstring+    addAxiom "axE" axE+    constrain $ a p+    constrain $ a k+    return $ a (e k p)
+ SBVTestSuite/TestSuite/Uninterpreted/Function.hs view
@@ -0,0 +1,22 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Uninterpreted.Function+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Testsuite for Data.SBV.Examples.Uninterpreted.Function+-----------------------------------------------------------------------------++module TestSuite.Uninterpreted.Function(tests) where++import Data.SBV.Examples.Uninterpreted.Function++import Utils.SBVTestFramework++tests :: TestTree+tests =+  testGroup "Uninterpreted.Function"+  [ testCase "aufunc-0" (assertIsThm thmGood)+  ]
+ SBVTestSuite/TestSuite/Uninterpreted/Sort.hs view
@@ -0,0 +1,45 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  TestSuite.Uninterpreted.Sort+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for uninterpreted sorts+-----------------------------------------------------------------------------++{-# LANGUAGE DeriveDataTypeable  #-}+{-# LANGUAGE ScopedTypeVariables #-}++module TestSuite.Uninterpreted.Sort(tests) where++import Utils.SBVTestFramework+import Data.Generics++tests :: TestTree+tests =+  testGroup "Uninterpreted.Sort"+    [ testCase "unint-sort"+        (assert . (==4) . length . (extractModels :: AllSatResult -> [L]) =<< allSat p0)+    ]++data L = Nil | Cons Int L deriving (Eq, Ord, Data, Read, Show)+instance SymWord L+instance HasKind L+instance SatModel L where+  parseCWs = undefined -- make GHC shut up about the missing method, we won't actually call it++type SList = SBV L++len :: SList -> SInteger+len = uninterpret "len"++p0 :: Symbolic SBool+p0 = do+    [l, l0, l1] <- symbolics ["l", "l0", "l1"]+    constrain $ len l0 .== 0+    constrain $ len l1 .== 1+    x :: SInteger <- symbolic "x"+    constrain $ x .== 0 ||| x.== 1+    return $ l .== l0 ||| l .== l1
+ SBVTestSuite/TestSuite/Uninterpreted/Uninterpreted.hs view
@@ -0,0 +1,38 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Examples.TestSuite.Uninterpreted+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Test suite for Examples.Uninterpreted.Uninterpreted+-----------------------------------------------------------------------------++module TestSuite.Uninterpreted.Uninterpreted(tests) where++import Utils.SBVTestFramework++-- Test suite+tests :: TestTree+tests =+  testGroup "Uninterpreted.Uninterpreted"+    [ testCase "uninterpreted-0" (assertIsThm p0)+    , testCase "uninterpreted-1" (assertIsThm p1)+    , testCase "uninterpreted-2" (assertIsntThm p2)+    ]++f :: SInt8 -> SWord32+f = uninterpret "f"++g :: SInt8 -> SWord16 -> SWord32+g = uninterpret "g"++p0 :: SInt8 -> SInt8 -> SBool+p0 x y   = x .== y ==> f x .== f y      -- OK++p1 :: SInt8 -> SWord16 -> SWord16 -> SBool+p1 x y z = y .== z ==> g x y .== g x z  -- OK++p2 :: SInt8 -> SWord16 -> SWord16 -> SBool+p2 x y z = y .== z ==> g x y .== f x    -- Not true
+ SBVTestSuite/Utils/SBVTestFramework.hs view
@@ -0,0 +1,86 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Utils.SBVTestFramework+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+--+-- Various goodies for testing SBV+-----------------------------------------------------------------------------++{-# LANGUAGE RankNTypes          #-}+{-# LANGUAGE ScopedTypeVariables #-}++module Utils.SBVTestFramework (+          showsAs+        , runSAT, numberOfModels+        , assertIsThm, assertIsntThm, assertIsSat, assertIsntSat+        , goldenString+        , goldenVsStringShow+        , goldenCapturedIO+        -- module exports to simplify life+        , module Test.Tasty+        , module Test.Tasty.HUnit+        , module Data.SBV+        ) where++import qualified Control.Exception as C++import qualified Data.ByteString.Lazy.Char8 as LBC++import System.Directory   (removeFile)+import Test.Tasty         (testGroup, TestTree, TestName)+import Test.Tasty.Golden  (goldenVsString, goldenVsFile)+import Test.Tasty.HUnit   (assert, Assertion, testCase)++import Data.SBV++import System.FilePath ((</>), (<.>))++import Data.SBV.Internals (runSymbolic, Symbolic, Result, SBVRunMode(..), IStage(..))++-- | Checks that a particular result shows as @s@+showsAs :: Show a => a -> String -> Assertion+showsAs r s = assert $ show r == s++goldFile :: FilePath -> FilePath+goldFile nm = "SBVTestSuite" </> "GoldFiles" </> nm <.> "gold"++goldenString :: TestName -> IO String -> TestTree+goldenString n res = goldenVsString n (goldFile n) (fmap LBC.pack res)++goldenVsStringShow :: Show a => TestName -> IO a -> TestTree+goldenVsStringShow n res = goldenVsString n (goldFile n) (fmap (LBC.pack . show) res)++goldenCapturedIO :: TestName -> (FilePath -> IO ()) -> TestTree+goldenCapturedIO n res = goldenVsFile n gf gfTmp (rm gfTmp >> res gfTmp)+  where gf    = goldFile n+        gfTmp = gf ++ "_temp"++        rm f = removeFile f `C.catch` (\(_ :: C.SomeException) -> return ())++-- | Count the number of models+numberOfModels :: Provable a => a -> IO Int+numberOfModels p = do AllSatResult (_, _, rs) <- allSat p+                      return $ length rs++-- | Symbolicly run a SAT instance using the default config+runSAT :: Symbolic a -> IO Result+runSAT cmp = snd <$> runSymbolic (SMTMode ISetup True defaultSMTCfg) cmp++-- | Turn provable to an assertion, theorem case+assertIsThm :: Provable a => a -> Assertion+assertIsThm t = assert (isTheorem t)++-- | Turn provable to a negative assertion, theorem case+assertIsntThm :: Provable a => a -> Assertion+assertIsntThm t = assert (fmap not (isTheorem t))++-- | Turn provable to an assertion, satisfiability case+assertIsSat :: Provable a => a -> Assertion+assertIsSat p = assert (isSatisfiable p)++-- | Turn provable to a negative assertion, satisfiability case+assertIsntSat :: Provable a => a -> Assertion+assertIsntSat p = assert (fmap not (isSatisfiable p))
− SBVUnitTest/Examples/Arrays/Memory.hs 
@@ -1,43 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.Arrays.Memory--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Simple memory abstraction and properties--------------------------------------------------------------------------------module Examples.Arrays.Memory where--import Data.SBV--type Address = SWord32-type Value   = SWord64-type Memory  = SArray Word32 Word64---- | read-after-write: If you write a value and read it back, you'll get it-raw :: Address -> Value -> Memory -> SBool-raw a v m = readArray (writeArray m a v) a .== v---- | write-after-write: If you write to the same location twice, then the first one is ignored-waw :: Address -> Value -> Value -> Memory -> SBool-waw a v1 v2 m0 = m2 .== m3-  where m1 = writeArray m0 a v1-        m2 = writeArray m1 a v2-        m3 = writeArray m0 a v2---- | Two writes to different locations commute, i.e., can be done in any order-wcommutesGood :: (Address, Value) -> (Address, Value) -> Memory -> SBool-wcommutesGood (a, x) (b, y) m = a ./= b ==> wcommutesBad (a, x) (b, y) m---- | Two writes do not commute if they can be done to the same location-wcommutesBad :: (Address, Value) -> (Address, Value) -> Memory -> SBool-wcommutesBad (a, x) (b, y) m = writeArray (writeArray m a x) b y .== writeArray (writeArray m b y) a x--tests :: IO ()-tests = do print =<< prove raw-           print =<< prove waw-           print =<< prove wcommutesBad-           print =<< prove wcommutesGood
− SBVUnitTest/Examples/Basics/BasicTests.hs 
@@ -1,51 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.Basics.BasicTests--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Basic tests of the sbv library--------------------------------------------------------------------------------{-# LANGUAGE Rank2Types          #-}-{-# LANGUAGE ScopedTypeVariables #-}--module Examples.Basics.BasicTests where--import Data.SBV-import Data.SBV.Internals-import SBVTest--test0 :: (forall a. Num a => (a -> a -> a)) -> Word8-test0 f = f (3 :: Word8) 2--test1, test2, test3, test4, test5 :: (forall a. Num a => (a -> a -> a)) -> IO Result-test1 f = runSAT $ do let x = literal (3 :: Word8)-                          y = literal (2 :: Word8)-                      output $ f x y-test2 f = runSAT $ do let x = literal (3 :: Word8)-                      y :: SWord8 <- forall "y"-                      output $ f x y-test3 f = runSAT $ do x :: SWord8 <- forall "x"-                      y :: SWord8 <- forall "y"-                      output $ f x y-test4 f = runSAT $ do x :: SWord8 <- forall "x"-                      output $ f x x-test5 f = runSAT $ do x :: SWord8 <- forall "x"-                      let r = f x x-                      q :: SWord8 <- forall "q"-                      _ <- output q-                      output r--f1, f2, f3, f4, f5 :: Num a => a -> a -> a-f1 x y = (x+y)*(x-y)-f2 x y = (x*x)-(y*y)-f3 x y = (x+y)*(x+y)-f4 x y = let z = x + y in z * z-f5 x _ = x + 1--{-# ANN f1 "NoHerbie" #-}-{-# ANN f2 "NoHerbie" #-}-{-# ANN f3 "NoHerbie" #-}
− SBVUnitTest/Examples/Basics/Higher.hs 
@@ -1,49 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.Basics.Higher--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Testing function equality--------------------------------------------------------------------------------module Examples.Basics.Higher where--import Data.SBV--type B = SWord8--f11 :: B -> B-f11 x = x--f12 :: B -> (B, B)-f12 x = (x, x)--f21 :: (B, B) -> B-f21 (x, y) = x + y--f22 :: (B, B) -> (B, B)-f22 (x, y) = (x, y)--f31 :: B -> B -> B-f31 x y = x + y--f32 :: B -> B -> (B, B)-f32 x y = (x, y)--f33 :: B -> B -> B -> (B, B, B)-f33 x y z = (x, y, z)---t :: IO [ThmResult]-t = sequence [-       f11 === f11-     , f12 === f12-     , f21 === f21-     , f22 === f22-     , f31 === f31-     , f32 === f32-     , f33 === f33-     ]
− SBVUnitTest/Examples/Basics/Index.hs 
@@ -1,69 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.Basics.Index--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Testing the select function--------------------------------------------------------------------------------module Examples.Basics.Index where--import Data.SBV-import SBVTest---- prove that the "select" primitive is working correctly-test1 :: Int -> IO Bool-test1 n = isThm $ do-            elts <- mkForallVars n-            err  <- forall_-            ind  <- forall_-            ind2 <- forall_-            let r1 = (select :: [SWord8] -> SWord8 -> SInt8 -> SWord8) elts err ind-                r2 = (select :: [SWord8] -> SWord8 -> SWord8 -> SWord8) elts err ind2-                r3 = slowSearch elts err ind-                r4 = slowSearch elts err ind2-            return $ r1 .== r3 &&& r2 .== r4- where slowSearch elts err i = ite (i .< 0) err (go elts i)-         where go []     _      = err-               go (x:xs) curInd = ite (curInd .== 0) x (go xs (curInd - 1))--test2 :: Int -> IO Bool-test2 n = isThm $ do-            elts1 <- mkForallVars n-            elts2 <- mkForallVars n-            let elts = zip elts1 elts2-            err1  <- forall_-            err2  <- forall_-            let err = (err1, err2)-            ind  <- forall_-            ind2 <- forall_-            let r1 = (select :: [(SWord8, SWord8)] -> (SWord8, SWord8) -> SInt8 -> (SWord8, SWord8)) elts err ind-                r2 = (select :: [(SWord8, SWord8)] -> (SWord8, SWord8) -> SWord8 -> (SWord8, SWord8)) elts err ind2-                r3 = slowSearch elts err ind-                r4 = slowSearch elts err ind2-            return $ r1 .== r3 &&& r2 .== r4- where slowSearch elts err i = ite (i .< 0) err (go elts i)-         where go []     _      = err-               go (x:xs) curInd = ite (curInd .== 0) x (go xs (curInd - 1))--test3 :: Int -> IO Bool-test3 n = isThm $ do-            eltsI <- mkForallVars n-            let elts = map Left eltsI-            errI  <- forall_-            let err = Left errI-            ind  <- forall_-            let r1 = (select :: [Either SWord8 SWord8] -> Either SWord8 SWord8 -> SInt8 -> Either SWord8 SWord8) elts err ind-                r2 = slowSearch elts err ind-            return $ r1 .== r2- where slowSearch elts err i = ite (i .< 0) err (go elts i)-         where go []     _      = err-               go (x:xs) curInd = ite (curInd .== 0) x (go xs (curInd - 1))--tests :: IO ()-tests = do mapM test1 [0..50] >>= print . and-           mapM test2 [0..50] >>= print . and-           mapM test3 [0..50] >>= print . and
− SBVUnitTest/Examples/Basics/ProofTests.hs 
@@ -1,52 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.Basics.ProofTests--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Basic proofs--------------------------------------------------------------------------------{-# LANGUAGE Rank2Types          #-}-{-# LANGUAGE ScopedTypeVariables #-}--module Examples.Basics.ProofTests where--import Data.SBV--f1, f2, f3, f4 :: Num a => a -> a -> a-f1 x y = (x+y)*(x-y)-f2 x y = (x*x)-(y*y)-f3 x y = (x+y)*(x+y)-f4 x y = x*x + 2*x*y + y*y--f1eqf2 :: Predicate-f1eqf2 = forAll_ $ \x y -> f1 x y .== f2 x (y :: SWord8)--f1eqf3 :: Predicate-f1eqf3 = forAll ["x", "y"] $ \x y -> f1 x y .== f3 x (y :: SWord8)--f3eqf4 :: Predicate-f3eqf4 = forAll_ $ \x y -> f3 x y .== f4 x (y :: SWord8)--f1Single :: Predicate-f1Single = forAll_ $ \x -> f1 x x .== (0 :: SWord16)--queries :: IO ()-queries = do print =<< prove f1eqf2   -- QED-             print =<< prove f1eqf3   -- No-             print =<< prove f3eqf4   -- QED-             print =<< prove f1Single -- QED-             print =<< sat (do x <- exists "x"-                               y <- exists "y"-                               return $ f1 x y .== f2 x (y :: SWord8))  -- yes, any output OK-             print =<< sat (do x <- exists "x"-                               y <- exists "y"-                               return $ f1 x y .== f3 x (y:: SWord8))    -- yes, 0;0--{-# ANN f1 "NoHerbie" #-}-{-# ANN f2 "NoHerbie" #-}-{-# ANN f3 "NoHerbie" #-}-{-# ANN f4 "NoHerbie" #-}
− SBVUnitTest/Examples/Basics/QRem.hs 
@@ -1,30 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.Basics.QRem--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Testing the sQuotRem and sDivMod--------------------------------------------------------------------------------module Examples.Basics.QRem where--import Data.SBV---- check: if (a, b) = x `quotRem` y then x = y*a + b--- same is also true for divMod--- being careful about y = 0. When divisor is 0, then quotient is--- defined to be 0 and the remainder is the numerator-qrem :: (Num a, EqSymbolic a, SDivisible a) => a -> a -> SBool-qrem x y = ite (y .== 0)-               ((0, x) .== (q, r) &&& (0, x) .== (d, m))-               (x .== y * q + r &&& x .== y * d + m)-  where (q, r) = x `sQuotRem` y-        (d, m) = x `sDivMod` y--check :: IO ()-check = do print =<< prove (qrem :: SWord8   -> SWord8   -> SBool)-           print =<< prove (qrem :: SInt8    -> SInt8    -> SBool)-           print =<< prove (qrem :: SInteger -> SInteger -> SBool)
− SBVUnitTest/Examples/CRC/CCITT.hs 
@@ -1,63 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.CRC.CCITT--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ CRC checks, hamming distance, etc.--------------------------------------------------------------------------------module Examples.CRC.CCITT where--import Data.SBV-import Data.SBV.Tools.Polynomial---- We don't have native support for 48 bits in Data.SBV--- So, represent as 32 high-bits and 16 low-type SWord48 = (SWord32, SWord16)--extendData :: SWord48 -> SWord64-extendData (h, l) = h # l # 0--mkFrame :: SWord48 -> SWord64-mkFrame msg@(h, l) = h # l # crc_48_16 msg--crc_48_16 :: SWord48 -> SWord16-crc_48_16 msg = res-  where msg64, divisor :: SWord64-        msg64   = extendData msg-        divisor = polynomial [16, 12, 5, 0]-        crc64 = pMod msg64 divisor-        (_, res) = split (snd (split crc64))--diffCount :: SWord64 -> SWord64 -> SWord8-diffCount x y = count $ zipWith (.==) (blastLE x) (blastLE y)-  where count []     = 0-        count (b:bs) = let r = count bs in ite b r (1+r)---- Claim: If there is an undetected corruption, it must be at least at 4 bits; i.e. HD is 4-crcGood :: SWord48 -> SWord48 -> SBool-crcGood sent received =-     sent ./= received ==> diffCount frameSent frameReceived .> 3-   where frameSent     = mkFrame sent-         frameReceived = mkFrame received---- How come we get way more than 168 (= 2*84) counter-examples for this? -hw4has84Inhabitants :: SWord48 -> SWord48 -> SBool-hw4has84Inhabitants sent received = fourBitError-   where frameSent     = mkFrame sent-         frameReceived = mkFrame received-         fourBitError  = diffCount frameSent frameReceived .== 4--hw4 :: IO ()-hw4 = do res <- allSat hw4has84Inhabitants-         cnt <- displayModels disp res-         putStrLn $ "Found: " ++ show cnt ++ " solution(s)."-   where disp :: Int -> (Bool, (Word32, Word16, Word32, Word16)) -> IO ()-         disp i (_, (sh, sl, rh, rl)) = do putStrLn $ "Solution #" ++ show i ++ ": "-                                           putStrLn $ "  Sent    : " ++ binS (mkFrame (literal sh, literal sl))-                                           putStrLn $ "  Received: " ++ binS (mkFrame (literal rh, literal rl))--{-# ANN crc_48_16 ("HLint: ignore Use camelCase" :: String) #-}
− SBVUnitTest/Examples/CRC/CCITT_Unidir.hs 
@@ -1,61 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.CRC.CCITT_Unidir--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Similar to CCITT. It shows that the CCITT is still HD 3--- even if we consider only uni-directional errors--------------------------------------------------------------------------------module Examples.CRC.CCITT_Unidir where--import Data.SBV-import Data.SBV.Tools.Polynomial---- We don't have native support for 48 bits in Data.SBV--- So, represent as 32 high-bits and 16 low-type SWord48 = (SWord32, SWord16)--extendData :: SWord48 -> SWord64-extendData (h, l) = h # l # 0--mkFrame :: SWord48 -> SWord64-mkFrame msg@(h, l) = h # l # crc_48_16 msg--crc_48_16 :: SWord48 -> SWord16-crc_48_16 msg = res-  where msg64, divisor :: SWord64-        msg64   = extendData msg-        divisor = polynomial [16, 12, 5, 0]-        crc64 = pMod msg64 divisor-        (_, res) = split (snd (split crc64))--diffCount :: [SBool] -> [SBool] -> SWord8-diffCount xs ys = count $ zipWith (.==) xs ys-  where count []     = 0-        count (b:bs) = let r = count bs in ite b r (1+r)---- returns true if there's a 0->1 error (1->0 is ok)-nonUnidir :: [SBool] -> [SBool] -> SBool-nonUnidir []     _      = false-nonUnidir _      []     = false-nonUnidir (a:as) (b:bs) = (bnot a &&& b) ||| nonUnidir as bs--crcUniGood :: SWord8 -> SWord48 -> SWord48 -> SBool-crcUniGood hd sent received =-     sent ./= received ==> nonUnidir frameSent frameReceived ||| diffCount frameSent frameReceived .> hd-   where frameSent     = blastLE $ mkFrame sent-         frameReceived = blastLE $ mkFrame received---- Provable, i.e., HD is 3-ccitHDis3 :: IO ()-ccitHDis3 = print =<< prove (crcUniGood 3)---- False; i.e., HD doesn't go to 4 just because we only look at uni-directional errors-ccitHDis4 :: IO ()-ccitHDis4 = print =<< prove (crcUniGood 4)--{-# ANN crc_48_16 ("HLint: ignore Use camelCase" :: String) #-}
− SBVUnitTest/Examples/CRC/GenPoly.hs 
@@ -1,76 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.CRC.GenPoly--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Finds good polynomials for CRC's--------------------------------------------------------------------------------module Examples.CRC.GenPoly where--import Data.SBV-import Data.SBV.Tools.Polynomial---- We don't have native support for 48 bits in Data.SBV--- So, represent as 32 high-bits and 16 low-type SWord48 = (SWord32, SWord16)--extendData :: SWord48 -> SWord64-extendData (h, l) = h # l # 0--mkFrame :: SWord64 -> SWord48 -> SWord64-mkFrame poly msg@(h, l) = h # l # crc_48_16 msg poly--crc_48_16 :: SWord48 -> SWord64 -> SWord16-crc_48_16 msg poly = res-  where msg64 = extendData msg-        crc64 = pMod msg64 poly-        (_, res) = split (snd (split crc64))--diffCount :: SWord64 -> SWord64 -> SWord8-diffCount x y = count $ zipWith (.==) (blastLE x) (blastLE y)-  where count []     = 0-        count (b:bs) = let r = count bs in ite b r (1+r)--crcGood :: SWord8 -> SWord16 -> SWord48 -> SWord48 -> SBool-crcGood hd divisor sent received =-     sent ./= received ==> diffCount frameSent frameReceived .> hd-   where frameSent     = mkFrame poly sent-         frameReceived = mkFrame poly received-         poly          = mkPoly divisor--mkPoly :: SWord16 -> SWord64-mkPoly d = 0 # 1 # d---- how long do we wait for each poly.. (seconds)-waitFor :: Int-waitFor = 15--genPoly :: SWord8 -> IO ()-genPoly hd = do putStrLn $ "*** Looking for polynomials with HD = " ++ show hd-                (skipped, res) <- go 0 [] []-                putStrLn $ "*** Good polynomials with HD = " ++ show hd-                mapM_ (\(i, s) -> putStrLn (show i ++ ". " ++ showPoly (mkPoly s)))  (zip [(1::Integer)..] res)-                putStrLn $ "*** Skipped the followings, proof exceeded timeout value of " ++ show waitFor-                mapM_ (\(i, s) -> putStrLn (show i ++ ". " ++ showPoly (mkPoly s)))  (zip [(1::Integer)..] skipped)-                putStrLn "*** Done."-  where go :: SWord16 -> [SWord16] -> [SWord16] -> IO ([SWord16], [SWord16])-        go poly skip acc-         | poly == maxBound = return (skip, acc)-         | True             = do putStr $ "Testing " ++ showPoly  (mkPoly poly) ++ "... "-                                 thm <- isTheorem (Just waitFor) $ crcGood hd poly-                                 case thm of-                                   Nothing    -> do putStrLn "Timeout, skipping.."-                                                    go (poly+1) (poly:skip) acc-                                   Just True  -> do putStrLn "Good!"-                                                    go (poly+1) skip (poly:acc)-                                   Just False -> do putStrLn "Bad!"-                                                    go (poly+1) skip acc--findHD3Polynomials :: IO ()-findHD3Polynomials = genPoly 3--{-# ANN crc_48_16 ("HLint: ignore Use camelCase" :: String) #-}
− SBVUnitTest/Examples/CRC/Parity.hs 
@@ -1,35 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.CRC.Parity--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Parity check as CRC's--------------------------------------------------------------------------------module Examples.CRC.Parity where--import Data.SBV--parity :: SWord64 -> SBool-parity x = bnot (isOdd cnt)-  where cnt :: SWord8-        cnt = count (blastLE x)--isOdd :: SWord8 -> SBool-isOdd x = lsb x .== true---- count the true bits-count :: [SBool] -> SWord8-count []     = 0-count (x:xs) = let c' = count xs in ite x (1+c') c'---- Example suggested by Lee Pike--- If x and y differ in odd-number of bits, then their parities are flipped-parityOK :: SWord64 -> SWord64 -> SBool-parityOK x y = isOdd cnt ==> px .== bnot py-  where cnt = count (zipWith (./=) (blastLE x) (blastLE y))-        px  = parity x-        py  = parity y
− SBVUnitTest/Examples/CRC/USB5.hs 
@@ -1,52 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.CRC.USB5--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ The USB5 CRC implementation--------------------------------------------------------------------------------module Examples.CRC.USB5 where--import Data.SBV-import Data.SBV.Tools.Polynomial--newtype SWord11 = S11 SWord16--instance EqSymbolic SWord11 where-  S11 w .== S11 w' = w .== w'--mkSWord11 :: SWord16 -> SWord11-mkSWord11 w = S11 (w .&. 0x07FF)--extendData :: SWord11 -> SWord16-extendData (S11 w) = w `shiftL` 5--mkFrame :: SWord11 -> SWord16-mkFrame w = extendData w .|. crc_11_16 w---- crc returns 16 bits, but the first 11 are always 0-crc_11_16 :: SWord11 -> SWord16-crc_11_16 msg = crc16 .&. 0x1F -- just get the last 5 bits-  where divisor :: SWord16-        divisor = polynomial [5, 2, 0]-        crc16 = pMod (extendData msg) divisor--diffCount :: SWord16 -> SWord16 -> SWord8-diffCount x y = count $ zipWith (.==) (blastLE x) (blastLE y)-  where count []     = 0-        count (b:bs) = let r = count bs in ite b r (1+r)---- Claim: If there is an undetected corruption, it must be at least at 3 bits-usbGood :: SWord16 -> SWord16 -> SBool-usbGood sent16 received16 =-    sent ./= received ==> diffCount frameSent frameReceived .>= 3-   where sent     = mkSWord11 sent16-         received = mkSWord11 received16-         frameSent     = mkFrame sent-         frameReceived = mkFrame received--{-# ANN crc_11_16 ("HLint: ignore Use camelCase" :: String) #-}
− SBVUnitTest/Examples/Puzzles/PowerSet.hs 
@@ -1,34 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.Puzzles.PowerSet--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Computes the powerset of a givenset--------------------------------------------------------------------------------module Examples.Puzzles.PowerSet where--import Data.SBV--genPowerSet :: [SBool] -> SBool--- The following definition reveals an issue in Yices's model generation. The--- seemingly vacuous test of checking true-or-false is necessary--- so that Yices will return a satisfying assignment--- otherwise, it just skips the "unused" inputs..-genPowerSet = bAll isBool-  where isBool x = x .== true ||| x .== false--powerSet :: [Word8] -> IO ()-powerSet xs = do putStrLn $ "Finding all subsets of " ++ show xs-                 res <- allSat $ genPowerSet `fmap` mkExistVars n-                 cnt <- displayModels disp res-                 putStrLn $ "Found: " ++ show cnt ++ " subset(s)."-     where n = length xs-           disp i (_, ss)-            | length ss /= n = error $ "Expected " ++ show n ++ " results; got: " ++ show (length ss)-            | True           = putStrLn $ "Subset #" ++ show i ++ ": " ++ show (concat (zipWith pick ss xs))-           pick True a  = [a]-           pick False _ = []
− SBVUnitTest/Examples/Puzzles/Temperature.hs 
@@ -1,39 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.Puzzles.Temperature--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Puzzle:---   What 2 digit fahrenheit/celcius values are reverses of each other?---   Ignoring the fractions in the conversion--------------------------------------------------------------------------------module Examples.Puzzles.Temperature where--import Data.SBV--type Temp = SInteger---- convert celcius to fahrenheit, rounding up/down properly--- we have to be careful here to make sure rounding is done properly..-d2f :: Temp -> Temp-d2f d = 32 + ite (fr .>= 5) (1+fi) fi-  where (fi, fr) = (18 * d) `sQuotRem` 10---- puzzle: What 2 digit fahrenheit/celcius values are reverses of each other?-revOf :: Temp -> SBool-revOf c = swap (digits c) .== digits (d2f c)-  where digits x = x `sQuotRem` 10-        swap (a, b) = (b, a)--puzzle :: IO ()-puzzle = do res <- allSat $ revOf `fmap` exists_-            cnt <- displayModels disp res-            putStrLn $ "Found " ++ show cnt ++ " solutions."-     where disp :: Int -> (Bool, Integer) -> IO ()-           disp _ (_, x) = putStrLn $ " " ++ show x ++ "C --> " ++ show (round f :: Integer) ++ "F (exact value: " ++ show f ++ "F)"-              where f :: Double-                    f  = 32 + (9 * fromIntegral x) / 5
− SBVUnitTest/Examples/Uninterpreted/Uninterpreted.hs 
@@ -1,29 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.Uninterpreted.Uninterpreted--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Testing uninterpreted functions--------------------------------------------------------------------------------module Examples.Uninterpreted.Uninterpreted where--import Data.SBV--f :: SInt8 -> SWord32-f = uninterpret "f"--g :: SInt8 -> SWord16 -> SWord32-g = uninterpret "g"--p0 :: SInt8 -> SInt8 -> SBool-p0 x y   = x .== y ==> f x .== f y      -- OK--p1 :: SInt8 -> SWord16 -> SWord16 -> SBool-p1 x y z = y .== z ==> g x y .== g x z  -- OK--p2 :: SInt8 -> SWord16 -> SWord16 -> SBool-p2 x y z = y .== z ==> g x y .== f x    -- Not true
− SBVUnitTest/GoldFiles/U2Bridge.gold 
@@ -1,16 +0,0 @@-Satisfiable. Model:-  s0  = False :: Bool-  s1  =  Edge :: U2Member-  s2  =  Bono :: U2Member-  s3  =  True :: Bool-  s4  =  Edge :: U2Member-  s5  =  Bono :: U2Member-  s6  = False :: Bool-  s7  = Larry :: U2Member-  s8  =  Adam :: U2Member-  s9  =  True :: Bool-  s10 =  Bono :: U2Member-  s11 =  Bono :: U2Member-  s12 = False :: Bool-  s13 =  Edge :: U2Member-  s14 =  Bono :: U2Member
− SBVUnitTest/GoldFiles/addSub.gold 
@@ -1,105 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for addSub. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: addSub_driver--addSub.o: addSub.c addSub.h-	${CC} ${CCFLAGS} -c $< -o $@--addSub_driver.o: addSub_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--addSub_driver: addSub.o addSub_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f addSub_driver-== END: "Makefile" ==================-== BEGIN: "addSub.h" ================-/* Header file for addSub. Automatically generated by SBV. Do not edit! */--#ifndef __addSub__HEADER_INCLUDED__-#define __addSub__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-void addSub(const SWord8 x, const SWord8 y, SWord8 *sum,-            SWord8 *dif);--#endif /* __addSub__HEADER_INCLUDED__ */-== END: "addSub.h" ==================-== BEGIN: "addSub_driver.c" ================-/* Example driver program for addSub. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "addSub.h"--int main(void)-{-  SWord8 sum;-  SWord8 dif;--  addSub(76, 92, &sum, &dif);--  printf("addSub(76, 92, &sum, &dif) ->\n");-  printf("  sum = %"PRIu8"\n", sum);-  printf("  dif = %"PRIu8"\n", dif);--  return 0;-}-== END: "addSub_driver.c" ==================-== BEGIN: "addSub.c" ================-/* File: "addSub.c". Automatically generated by SBV. Do not edit! */--#include "addSub.h"--void addSub(const SWord8 x, const SWord8 y, SWord8 *sum,-            SWord8 *dif)-{-  const SWord8 s0 = x;-  const SWord8 s1 = y;-  const SWord8 s2 = s0 + s1;-  const SWord8 s3 = s0 - s1;--  *sum = s2;-  *dif = s3;-}-== END: "addSub.c" ==================
− SBVUnitTest/GoldFiles/aes128Dec.gold 
@@ -1,2609 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for aes128Dec. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: aes128Dec_driver--aes128Dec.o: aes128Dec.c aes128Dec.h-	${CC} ${CCFLAGS} -c $< -o $@--aes128Dec_driver.o: aes128Dec_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--aes128Dec_driver: aes128Dec.o aes128Dec_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f aes128Dec_driver-== END: "Makefile" ==================-== BEGIN: "aes128Dec.h" ================-/* Header file for aes128Dec. Automatically generated by SBV. Do not edit! */--#ifndef __aes128Dec__HEADER_INCLUDED__-#define __aes128Dec__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-void aes128Dec(const SWord32 *pt, const SWord32 *key, SWord32 *ct);--#endif /* __aes128Dec__HEADER_INCLUDED__ */-== END: "aes128Dec.h" ==================-== BEGIN: "aes128Dec_driver.c" ================-/* Example driver program for aes128Dec. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "aes128Dec.h"--int main(void)-{-  const SWord32 pt[4] = {-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL-  };--  printf("Contents of input array pt:\n");-  int pt_ctr;-  for(pt_ctr = 0; pt_ctr < 4 ; ++pt_ctr)-    printf("  pt[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]);--  const SWord32 key[4] = {-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL-  };--  printf("Contents of input array key:\n");-  int key_ctr;-  for(key_ctr = 0; key_ctr < 4 ; ++key_ctr)-    printf("  key[%d] = 0x%08"PRIx32"UL\n", key_ctr ,key[key_ctr]);--  SWord32 ct[4];--  aes128Dec(pt, key, ct);--  printf("aes128Dec(pt, key, ct) ->\n");-  int ct_ctr;-  for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr)-    printf("  ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]);--  return 0;-}-== END: "aes128Dec_driver.c" ==================-== BEGIN: "aes128Dec.c" ================-/* File: "aes128Dec.c". Automatically generated by SBV. Do not edit! */--#include "aes128Dec.h"--void aes128Dec(const SWord32 *pt, const SWord32 *key, SWord32 *ct)-{-  const SWord32 s0 = pt[0];-  const SWord32 s1 = pt[1];-  const SWord32 s2 = pt[2];-  const SWord32 s3 = pt[3];-  const SWord32 s4 = key[0];-  const SWord32 s5 = key[1];-  const SWord32 s6 = key[2];-  const SWord32 s7 = key[3];-  static const SWord8 table0[] = {-       82,   9, 106, 213,  48,  54, 165,  56, 191,  64, 163, 158, 129,-      243, 215, 251, 124, 227,  57, 130, 155,  47, 255, 135,  52, 142,-       67,  68, 196, 222, 233, 203,  84, 123, 148,  50, 166, 194,  35,-       61, 238,  76, 149,  11,  66, 250, 195,  78,   8,  46, 161, 102,-       40, 217,  36, 178, 118,  91, 162,  73, 109, 139, 209,  37, 114,-      248, 246, 100, 134, 104, 152,  22, 212, 164,  92, 204,  93, 101,-      182, 146, 108, 112,  72,  80, 253, 237, 185, 218,  94,  21,  70,-       87, 167, 141, 157, 132, 144, 216, 171,   0, 140, 188, 211,  10,-      247, 228,  88,   5, 184, 179,  69,   6, 208,  44,  30, 143, 202,-       63,  15,   2, 193, 175, 189,   3,   1,  19, 138, 107,  58, 145,-       17,  65,  79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230,-      115, 150, 172, 116,  34, 231, 173,  53, 133, 226, 249,  55, 232,-       28, 117, 223, 110,  71, 241,  26, 113,  29,  41, 197, 137, 111,-      183,  98,  14, 170,  24, 190,  27, 252,  86,  62,  75, 198, 210,-      121,  32, 154, 219, 192, 254, 120, 205,  90, 244,  31, 221, 168,-       51, 136,   7, 199,  49, 177,  18,  16,  89,  39, 128, 236,  95,-       96,  81, 127, 169,  25, 181,  74,  13,  45, 229, 122, 159, 147,-      201, 156, 239, 160, 224,  59,  77, 174,  42, 245, 176, 200, 235,-      187,  60, 131,  83, 153,  97,  23,  43,   4, 126, 186, 119, 214,-       38, 225, 105,  20,  99,  85,  33,  12, 125-  };-  static const SWord32 table1[] = {-      0x51f4a750UL, 0x7e416553UL, 0x1a17a4c3UL, 0x3a275e96UL,-      0x3bab6bcbUL, 0x1f9d45f1UL, 0xacfa58abUL, 0x4be30393UL,-      0x2030fa55UL, 0xad766df6UL, 0x88cc7691UL, 0xf5024c25UL,-      0x4fe5d7fcUL, 0xc52acbd7UL, 0x26354480UL, 0xb562a38fUL,-      0xdeb15a49UL, 0x25ba1b67UL, 0x45ea0e98UL, 0x5dfec0e1UL,-      0xc32f7502UL, 0x814cf012UL, 0x8d4697a3UL, 0x6bd3f9c6UL,-      0x038f5fe7UL, 0x15929c95UL, 0xbf6d7aebUL, 0x955259daUL,-      0xd4be832dUL, 0x587421d3UL, 0x49e06929UL, 0x8ec9c844UL,-      0x75c2896aUL, 0xf48e7978UL, 0x99583e6bUL, 0x27b971ddUL,-      0xbee14fb6UL, 0xf088ad17UL, 0xc920ac66UL, 0x7dce3ab4UL,-      0x63df4a18UL, 0xe51a3182UL, 0x97513360UL, 0x62537f45UL,-      0xb16477e0UL, 0xbb6bae84UL, 0xfe81a01cUL, 0xf9082b94UL,-      0x70486858UL, 0x8f45fd19UL, 0x94de6c87UL, 0x527bf8b7UL,-      0xab73d323UL, 0x724b02e2UL, 0xe31f8f57UL, 0x6655ab2aUL,-      0xb2eb2807UL, 0x2fb5c203UL, 0x86c57b9aUL, 0xd33708a5UL,-      0x302887f2UL, 0x23bfa5b2UL, 0x02036abaUL, 0xed16825cUL,-      0x8acf1c2bUL, 0xa779b492UL, 0xf307f2f0UL, 0x4e69e2a1UL,-      0x65daf4cdUL, 0x0605bed5UL, 0xd134621fUL, 0xc4a6fe8aUL,-      0x342e539dUL, 0xa2f355a0UL, 0x058ae132UL, 0xa4f6eb75UL,-      0x0b83ec39UL, 0x4060efaaUL, 0x5e719f06UL, 0xbd6e1051UL,-      0x3e218af9UL, 0x96dd063dUL, 0xdd3e05aeUL, 0x4de6bd46UL,-      0x91548db5UL, 0x71c45d05UL, 0x0406d46fUL, 0x605015ffUL,-      0x1998fb24UL, 0xd6bde997UL, 0x894043ccUL, 0x67d99e77UL,-      0xb0e842bdUL, 0x07898b88UL, 0xe7195b38UL, 0x79c8eedbUL,-      0xa17c0a47UL, 0x7c420fe9UL, 0xf8841ec9UL, 0x00000000UL,-      0x09808683UL, 0x322bed48UL, 0x1e1170acUL, 0x6c5a724eUL,-      0xfd0efffbUL, 0x0f853856UL, 0x3daed51eUL, 0x362d3927UL,-      0x0a0fd964UL, 0x685ca621UL, 0x9b5b54d1UL, 0x24362e3aUL,-      0x0c0a67b1UL, 0x9357e70fUL, 0xb4ee96d2UL, 0x1b9b919eUL,-      0x80c0c54fUL, 0x61dc20a2UL, 0x5a774b69UL, 0x1c121a16UL,-      0xe293ba0aUL, 0xc0a02ae5UL, 0x3c22e043UL, 0x121b171dUL,-      0x0e090d0bUL, 0xf28bc7adUL, 0x2db6a8b9UL, 0x141ea9c8UL,-      0x57f11985UL, 0xaf75074cUL, 0xee99ddbbUL, 0xa37f60fdUL,-      0xf701269fUL, 0x5c72f5bcUL, 0x44663bc5UL, 0x5bfb7e34UL,-      0x8b432976UL, 0xcb23c6dcUL, 0xb6edfc68UL, 0xb8e4f163UL,-      0xd731dccaUL, 0x42638510UL, 0x13972240UL, 0x84c61120UL,-      0x854a247dUL, 0xd2bb3df8UL, 0xaef93211UL, 0xc729a16dUL,-      0x1d9e2f4bUL, 0xdcb230f3UL, 0x0d8652ecUL, 0x77c1e3d0UL,-      0x2bb3166cUL, 0xa970b999UL, 0x119448faUL, 0x47e96422UL,-      0xa8fc8cc4UL, 0xa0f03f1aUL, 0x567d2cd8UL, 0x223390efUL,-      0x87494ec7UL, 0xd938d1c1UL, 0x8ccaa2feUL, 0x98d40b36UL,-      0xa6f581cfUL, 0xa57ade28UL, 0xdab78e26UL, 0x3fadbfa4UL,-      0x2c3a9de4UL, 0x5078920dUL, 0x6a5fcc9bUL, 0x547e4662UL,-      0xf68d13c2UL, 0x90d8b8e8UL, 0x2e39f75eUL, 0x82c3aff5UL,-      0x9f5d80beUL, 0x69d0937cUL, 0x6fd52da9UL, 0xcf2512b3UL,-      0xc8ac993bUL, 0x10187da7UL, 0xe89c636eUL, 0xdb3bbb7bUL,-      0xcd267809UL, 0x6e5918f4UL, 0xec9ab701UL, 0x834f9aa8UL,-      0xe6956e65UL, 0xaaffe67eUL, 0x21bccf08UL, 0xef15e8e6UL,-      0xbae79bd9UL, 0x4a6f36ceUL, 0xea9f09d4UL, 0x29b07cd6UL,-      0x31a4b2afUL, 0x2a3f2331UL, 0xc6a59430UL, 0x35a266c0UL,-      0x744ebc37UL, 0xfc82caa6UL, 0xe090d0b0UL, 0x33a7d815UL,-      0xf104984aUL, 0x41ecdaf7UL, 0x7fcd500eUL, 0x1791f62fUL,-      0x764dd68dUL, 0x43efb04dUL, 0xccaa4d54UL, 0xe49604dfUL,-      0x9ed1b5e3UL, 0x4c6a881bUL, 0xc12c1fb8UL, 0x4665517fUL,-      0x9d5eea04UL, 0x018c355dUL, 0xfa877473UL, 0xfb0b412eUL,-      0xb3671d5aUL, 0x92dbd252UL, 0xe9105633UL, 0x6dd64713UL,-      0x9ad7618cUL, 0x37a10c7aUL, 0x59f8148eUL, 0xeb133c89UL,-      0xcea927eeUL, 0xb761c935UL, 0xe11ce5edUL, 0x7a47b13cUL,-      0x9cd2df59UL, 0x55f2733fUL, 0x1814ce79UL, 0x73c737bfUL,-      0x53f7cdeaUL, 0x5ffdaa5bUL, 0xdf3d6f14UL, 0x7844db86UL,-      0xcaaff381UL, 0xb968c43eUL, 0x3824342cUL, 0xc2a3405fUL,-      0x161dc372UL, 0xbce2250cUL, 0x283c498bUL, 0xff0d9541UL,-      0x39a80171UL, 0x080cb3deUL, 0xd8b4e49cUL, 0x6456c190UL,-      0x7bcb8461UL, 0xd532b670UL, 0x486c5c74UL, 0xd0b85742UL-  };-  static const SWord8 table2[] = {-       99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254,-      215, 171, 118, 202, 130, 201, 125, 250,  89,  71, 240, 173, 212,-      162, 175, 156, 164, 114, 192, 183, 253, 147,  38,  54,  63, 247,-      204,  52, 165, 229, 241, 113, 216,  49,  21,   4, 199,  35, 195,-       24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,   9,-      131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,-       47, 132,  83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,-       57,  74,  76,  88, 207, 208, 239, 170, 251,  67,  77,  51, 133,-       69, 249,   2, 127,  80,  60, 159, 168,  81, 163,  64, 143, 146,-      157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210, 205,  12,-       19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25,-      115,  96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20,-      222,  94,  11, 219, 224,  50,  58,  10,  73,   6,  36,  92, 194,-      211, 172,  98, 145, 149, 228, 121, 231, 200,  55, 109, 141, 213,-       78, 169, 108,  86, 244, 234, 101, 122, 174,   8, 186, 120,  37,-       46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,-      112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134,-      193,  29, 158, 225, 248, 152,  17, 105, 217, 142, 148, 155,  30,-      135, 233, 206,  85,  40, 223, 140, 161, 137,  13, 191, 230,  66,-      104,  65, 153,  45,  15, 176,  84, 187,  22-  };-  static const SWord32 table3[] = {-      0x5051f4a7UL, 0x537e4165UL, 0xc31a17a4UL, 0x963a275eUL,-      0xcb3bab6bUL, 0xf11f9d45UL, 0xabacfa58UL, 0x934be303UL,-      0x552030faUL, 0xf6ad766dUL, 0x9188cc76UL, 0x25f5024cUL,-      0xfc4fe5d7UL, 0xd7c52acbUL, 0x80263544UL, 0x8fb562a3UL,-      0x49deb15aUL, 0x6725ba1bUL, 0x9845ea0eUL, 0xe15dfec0UL,-      0x02c32f75UL, 0x12814cf0UL, 0xa38d4697UL, 0xc66bd3f9UL,-      0xe7038f5fUL, 0x9515929cUL, 0xebbf6d7aUL, 0xda955259UL,-      0x2dd4be83UL, 0xd3587421UL, 0x2949e069UL, 0x448ec9c8UL,-      0x6a75c289UL, 0x78f48e79UL, 0x6b99583eUL, 0xdd27b971UL,-      0xb6bee14fUL, 0x17f088adUL, 0x66c920acUL, 0xb47dce3aUL,-      0x1863df4aUL, 0x82e51a31UL, 0x60975133UL, 0x4562537fUL,-      0xe0b16477UL, 0x84bb6baeUL, 0x1cfe81a0UL, 0x94f9082bUL,-      0x58704868UL, 0x198f45fdUL, 0x8794de6cUL, 0xb7527bf8UL,-      0x23ab73d3UL, 0xe2724b02UL, 0x57e31f8fUL, 0x2a6655abUL,-      0x07b2eb28UL, 0x032fb5c2UL, 0x9a86c57bUL, 0xa5d33708UL,-      0xf2302887UL, 0xb223bfa5UL, 0xba02036aUL, 0x5ced1682UL,-      0x2b8acf1cUL, 0x92a779b4UL, 0xf0f307f2UL, 0xa14e69e2UL,-      0xcd65daf4UL, 0xd50605beUL, 0x1fd13462UL, 0x8ac4a6feUL,-      0x9d342e53UL, 0xa0a2f355UL, 0x32058ae1UL, 0x75a4f6ebUL,-      0x390b83ecUL, 0xaa4060efUL, 0x065e719fUL, 0x51bd6e10UL,-      0xf93e218aUL, 0x3d96dd06UL, 0xaedd3e05UL, 0x464de6bdUL,-      0xb591548dUL, 0x0571c45dUL, 0x6f0406d4UL, 0xff605015UL,-      0x241998fbUL, 0x97d6bde9UL, 0xcc894043UL, 0x7767d99eUL,-      0xbdb0e842UL, 0x8807898bUL, 0x38e7195bUL, 0xdb79c8eeUL,-      0x47a17c0aUL, 0xe97c420fUL, 0xc9f8841eUL, 0x00000000UL,-      0x83098086UL, 0x48322bedUL, 0xac1e1170UL, 0x4e6c5a72UL,-      0xfbfd0effUL, 0x560f8538UL, 0x1e3daed5UL, 0x27362d39UL,-      0x640a0fd9UL, 0x21685ca6UL, 0xd19b5b54UL, 0x3a24362eUL,-      0xb10c0a67UL, 0x0f9357e7UL, 0xd2b4ee96UL, 0x9e1b9b91UL,-      0x4f80c0c5UL, 0xa261dc20UL, 0x695a774bUL, 0x161c121aUL,-      0x0ae293baUL, 0xe5c0a02aUL, 0x433c22e0UL, 0x1d121b17UL,-      0x0b0e090dUL, 0xadf28bc7UL, 0xb92db6a8UL, 0xc8141ea9UL,-      0x8557f119UL, 0x4caf7507UL, 0xbbee99ddUL, 0xfda37f60UL,-      0x9ff70126UL, 0xbc5c72f5UL, 0xc544663bUL, 0x345bfb7eUL,-      0x768b4329UL, 0xdccb23c6UL, 0x68b6edfcUL, 0x63b8e4f1UL,-      0xcad731dcUL, 0x10426385UL, 0x40139722UL, 0x2084c611UL,-      0x7d854a24UL, 0xf8d2bb3dUL, 0x11aef932UL, 0x6dc729a1UL,-      0x4b1d9e2fUL, 0xf3dcb230UL, 0xec0d8652UL, 0xd077c1e3UL,-      0x6c2bb316UL, 0x99a970b9UL, 0xfa119448UL, 0x2247e964UL,-      0xc4a8fc8cUL, 0x1aa0f03fUL, 0xd8567d2cUL, 0xef223390UL,-      0xc787494eUL, 0xc1d938d1UL, 0xfe8ccaa2UL, 0x3698d40bUL,-      0xcfa6f581UL, 0x28a57adeUL, 0x26dab78eUL, 0xa43fadbfUL,-      0xe42c3a9dUL, 0x0d507892UL, 0x9b6a5fccUL, 0x62547e46UL,-      0xc2f68d13UL, 0xe890d8b8UL, 0x5e2e39f7UL, 0xf582c3afUL,-      0xbe9f5d80UL, 0x7c69d093UL, 0xa96fd52dUL, 0xb3cf2512UL,-      0x3bc8ac99UL, 0xa710187dUL, 0x6ee89c63UL, 0x7bdb3bbbUL,-      0x09cd2678UL, 0xf46e5918UL, 0x01ec9ab7UL, 0xa8834f9aUL,-      0x65e6956eUL, 0x7eaaffe6UL, 0x0821bccfUL, 0xe6ef15e8UL,-      0xd9bae79bUL, 0xce4a6f36UL, 0xd4ea9f09UL, 0xd629b07cUL,-      0xaf31a4b2UL, 0x312a3f23UL, 0x30c6a594UL, 0xc035a266UL,-      0x37744ebcUL, 0xa6fc82caUL, 0xb0e090d0UL, 0x1533a7d8UL,-      0x4af10498UL, 0xf741ecdaUL, 0x0e7fcd50UL, 0x2f1791f6UL,-      0x8d764dd6UL, 0x4d43efb0UL, 0x54ccaa4dUL, 0xdfe49604UL,-      0xe39ed1b5UL, 0x1b4c6a88UL, 0xb8c12c1fUL, 0x7f466551UL,-      0x049d5eeaUL, 0x5d018c35UL, 0x73fa8774UL, 0x2efb0b41UL,-      0x5ab3671dUL, 0x5292dbd2UL, 0x33e91056UL, 0x136dd647UL,-      0x8c9ad761UL, 0x7a37a10cUL, 0x8e59f814UL, 0x89eb133cUL,-      0xeecea927UL, 0x35b761c9UL, 0xede11ce5UL, 0x3c7a47b1UL,-      0x599cd2dfUL, 0x3f55f273UL, 0x791814ceUL, 0xbf73c737UL,-      0xea53f7cdUL, 0x5b5ffdaaUL, 0x14df3d6fUL, 0x867844dbUL,-      0x81caaff3UL, 0x3eb968c4UL, 0x2c382434UL, 0x5fc2a340UL,-      0x72161dc3UL, 0x0cbce225UL, 0x8b283c49UL, 0x41ff0d95UL,-      0x7139a801UL, 0xde080cb3UL, 0x9cd8b4e4UL, 0x906456c1UL,-      0x617bcb84UL, 0x70d532b6UL, 0x74486c5cUL, 0x42d0b857UL-  };-  static const SWord32 table4[] = {-      0xa75051f4UL, 0x65537e41UL, 0xa4c31a17UL, 0x5e963a27UL,-      0x6bcb3babUL, 0x45f11f9dUL, 0x58abacfaUL, 0x03934be3UL,-      0xfa552030UL, 0x6df6ad76UL, 0x769188ccUL, 0x4c25f502UL,-      0xd7fc4fe5UL, 0xcbd7c52aUL, 0x44802635UL, 0xa38fb562UL,-      0x5a49deb1UL, 0x1b6725baUL, 0x0e9845eaUL, 0xc0e15dfeUL,-      0x7502c32fUL, 0xf012814cUL, 0x97a38d46UL, 0xf9c66bd3UL,-      0x5fe7038fUL, 0x9c951592UL, 0x7aebbf6dUL, 0x59da9552UL,-      0x832dd4beUL, 0x21d35874UL, 0x692949e0UL, 0xc8448ec9UL,-      0x896a75c2UL, 0x7978f48eUL, 0x3e6b9958UL, 0x71dd27b9UL,-      0x4fb6bee1UL, 0xad17f088UL, 0xac66c920UL, 0x3ab47dceUL,-      0x4a1863dfUL, 0x3182e51aUL, 0x33609751UL, 0x7f456253UL,-      0x77e0b164UL, 0xae84bb6bUL, 0xa01cfe81UL, 0x2b94f908UL,-      0x68587048UL, 0xfd198f45UL, 0x6c8794deUL, 0xf8b7527bUL,-      0xd323ab73UL, 0x02e2724bUL, 0x8f57e31fUL, 0xab2a6655UL,-      0x2807b2ebUL, 0xc2032fb5UL, 0x7b9a86c5UL, 0x08a5d337UL,-      0x87f23028UL, 0xa5b223bfUL, 0x6aba0203UL, 0x825ced16UL,-      0x1c2b8acfUL, 0xb492a779UL, 0xf2f0f307UL, 0xe2a14e69UL,-      0xf4cd65daUL, 0xbed50605UL, 0x621fd134UL, 0xfe8ac4a6UL,-      0x539d342eUL, 0x55a0a2f3UL, 0xe132058aUL, 0xeb75a4f6UL,-      0xec390b83UL, 0xefaa4060UL, 0x9f065e71UL, 0x1051bd6eUL,-      0x8af93e21UL, 0x063d96ddUL, 0x05aedd3eUL, 0xbd464de6UL,-      0x8db59154UL, 0x5d0571c4UL, 0xd46f0406UL, 0x15ff6050UL,-      0xfb241998UL, 0xe997d6bdUL, 0x43cc8940UL, 0x9e7767d9UL,-      0x42bdb0e8UL, 0x8b880789UL, 0x5b38e719UL, 0xeedb79c8UL,-      0x0a47a17cUL, 0x0fe97c42UL, 0x1ec9f884UL, 0x00000000UL,-      0x86830980UL, 0xed48322bUL, 0x70ac1e11UL, 0x724e6c5aUL,-      0xfffbfd0eUL, 0x38560f85UL, 0xd51e3daeUL, 0x3927362dUL,-      0xd9640a0fUL, 0xa621685cUL, 0x54d19b5bUL, 0x2e3a2436UL,-      0x67b10c0aUL, 0xe70f9357UL, 0x96d2b4eeUL, 0x919e1b9bUL,-      0xc54f80c0UL, 0x20a261dcUL, 0x4b695a77UL, 0x1a161c12UL,-      0xba0ae293UL, 0x2ae5c0a0UL, 0xe0433c22UL, 0x171d121bUL,-      0x0d0b0e09UL, 0xc7adf28bUL, 0xa8b92db6UL, 0xa9c8141eUL,-      0x198557f1UL, 0x074caf75UL, 0xddbbee99UL, 0x60fda37fUL,-      0x269ff701UL, 0xf5bc5c72UL, 0x3bc54466UL, 0x7e345bfbUL,-      0x29768b43UL, 0xc6dccb23UL, 0xfc68b6edUL, 0xf163b8e4UL,-      0xdccad731UL, 0x85104263UL, 0x22401397UL, 0x112084c6UL,-      0x247d854aUL, 0x3df8d2bbUL, 0x3211aef9UL, 0xa16dc729UL,-      0x2f4b1d9eUL, 0x30f3dcb2UL, 0x52ec0d86UL, 0xe3d077c1UL,-      0x166c2bb3UL, 0xb999a970UL, 0x48fa1194UL, 0x642247e9UL,-      0x8cc4a8fcUL, 0x3f1aa0f0UL, 0x2cd8567dUL, 0x90ef2233UL,-      0x4ec78749UL, 0xd1c1d938UL, 0xa2fe8ccaUL, 0x0b3698d4UL,-      0x81cfa6f5UL, 0xde28a57aUL, 0x8e26dab7UL, 0xbfa43fadUL,-      0x9de42c3aUL, 0x920d5078UL, 0xcc9b6a5fUL, 0x4662547eUL,-      0x13c2f68dUL, 0xb8e890d8UL, 0xf75e2e39UL, 0xaff582c3UL,-      0x80be9f5dUL, 0x937c69d0UL, 0x2da96fd5UL, 0x12b3cf25UL,-      0x993bc8acUL, 0x7da71018UL, 0x636ee89cUL, 0xbb7bdb3bUL,-      0x7809cd26UL, 0x18f46e59UL, 0xb701ec9aUL, 0x9aa8834fUL,-      0x6e65e695UL, 0xe67eaaffUL, 0xcf0821bcUL, 0xe8e6ef15UL,-      0x9bd9bae7UL, 0x36ce4a6fUL, 0x09d4ea9fUL, 0x7cd629b0UL,-      0xb2af31a4UL, 0x23312a3fUL, 0x9430c6a5UL, 0x66c035a2UL,-      0xbc37744eUL, 0xcaa6fc82UL, 0xd0b0e090UL, 0xd81533a7UL,-      0x984af104UL, 0xdaf741ecUL, 0x500e7fcdUL, 0xf62f1791UL,-      0xd68d764dUL, 0xb04d43efUL, 0x4d54ccaaUL, 0x04dfe496UL,-      0xb5e39ed1UL, 0x881b4c6aUL, 0x1fb8c12cUL, 0x517f4665UL,-      0xea049d5eUL, 0x355d018cUL, 0x7473fa87UL, 0x412efb0bUL,-      0x1d5ab367UL, 0xd25292dbUL, 0x5633e910UL, 0x47136dd6UL,-      0x618c9ad7UL, 0x0c7a37a1UL, 0x148e59f8UL, 0x3c89eb13UL,-      0x27eecea9UL, 0xc935b761UL, 0xe5ede11cUL, 0xb13c7a47UL,-      0xdf599cd2UL, 0x733f55f2UL, 0xce791814UL, 0x37bf73c7UL,-      0xcdea53f7UL, 0xaa5b5ffdUL, 0x6f14df3dUL, 0xdb867844UL,-      0xf381caafUL, 0xc43eb968UL, 0x342c3824UL, 0x405fc2a3UL,-      0xc372161dUL, 0x250cbce2UL, 0x498b283cUL, 0x9541ff0dUL,-      0x017139a8UL, 0xb3de080cUL, 0xe49cd8b4UL, 0xc1906456UL,-      0x84617bcbUL, 0xb670d532UL, 0x5c74486cUL, 0x5742d0b8UL-  };-  static const SWord32 table5[] = {-      0xf4a75051UL, 0x4165537eUL, 0x17a4c31aUL, 0x275e963aUL,-      0xab6bcb3bUL, 0x9d45f11fUL, 0xfa58abacUL, 0xe303934bUL,-      0x30fa5520UL, 0x766df6adUL, 0xcc769188UL, 0x024c25f5UL,-      0xe5d7fc4fUL, 0x2acbd7c5UL, 0x35448026UL, 0x62a38fb5UL,-      0xb15a49deUL, 0xba1b6725UL, 0xea0e9845UL, 0xfec0e15dUL,-      0x2f7502c3UL, 0x4cf01281UL, 0x4697a38dUL, 0xd3f9c66bUL,-      0x8f5fe703UL, 0x929c9515UL, 0x6d7aebbfUL, 0x5259da95UL,-      0xbe832dd4UL, 0x7421d358UL, 0xe0692949UL, 0xc9c8448eUL,-      0xc2896a75UL, 0x8e7978f4UL, 0x583e6b99UL, 0xb971dd27UL,-      0xe14fb6beUL, 0x88ad17f0UL, 0x20ac66c9UL, 0xce3ab47dUL,-      0xdf4a1863UL, 0x1a3182e5UL, 0x51336097UL, 0x537f4562UL,-      0x6477e0b1UL, 0x6bae84bbUL, 0x81a01cfeUL, 0x082b94f9UL,-      0x48685870UL, 0x45fd198fUL, 0xde6c8794UL, 0x7bf8b752UL,-      0x73d323abUL, 0x4b02e272UL, 0x1f8f57e3UL, 0x55ab2a66UL,-      0xeb2807b2UL, 0xb5c2032fUL, 0xc57b9a86UL, 0x3708a5d3UL,-      0x2887f230UL, 0xbfa5b223UL, 0x036aba02UL, 0x16825cedUL,-      0xcf1c2b8aUL, 0x79b492a7UL, 0x07f2f0f3UL, 0x69e2a14eUL,-      0xdaf4cd65UL, 0x05bed506UL, 0x34621fd1UL, 0xa6fe8ac4UL,-      0x2e539d34UL, 0xf355a0a2UL, 0x8ae13205UL, 0xf6eb75a4UL,-      0x83ec390bUL, 0x60efaa40UL, 0x719f065eUL, 0x6e1051bdUL,-      0x218af93eUL, 0xdd063d96UL, 0x3e05aeddUL, 0xe6bd464dUL,-      0x548db591UL, 0xc45d0571UL, 0x06d46f04UL, 0x5015ff60UL,-      0x98fb2419UL, 0xbde997d6UL, 0x4043cc89UL, 0xd99e7767UL,-      0xe842bdb0UL, 0x898b8807UL, 0x195b38e7UL, 0xc8eedb79UL,-      0x7c0a47a1UL, 0x420fe97cUL, 0x841ec9f8UL, 0x00000000UL,-      0x80868309UL, 0x2bed4832UL, 0x1170ac1eUL, 0x5a724e6cUL,-      0x0efffbfdUL, 0x8538560fUL, 0xaed51e3dUL, 0x2d392736UL,-      0x0fd9640aUL, 0x5ca62168UL, 0x5b54d19bUL, 0x362e3a24UL,-      0x0a67b10cUL, 0x57e70f93UL, 0xee96d2b4UL, 0x9b919e1bUL,-      0xc0c54f80UL, 0xdc20a261UL, 0x774b695aUL, 0x121a161cUL,-      0x93ba0ae2UL, 0xa02ae5c0UL, 0x22e0433cUL, 0x1b171d12UL,-      0x090d0b0eUL, 0x8bc7adf2UL, 0xb6a8b92dUL, 0x1ea9c814UL,-      0xf1198557UL, 0x75074cafUL, 0x99ddbbeeUL, 0x7f60fda3UL,-      0x01269ff7UL, 0x72f5bc5cUL, 0x663bc544UL, 0xfb7e345bUL,-      0x4329768bUL, 0x23c6dccbUL, 0xedfc68b6UL, 0xe4f163b8UL,-      0x31dccad7UL, 0x63851042UL, 0x97224013UL, 0xc6112084UL,-      0x4a247d85UL, 0xbb3df8d2UL, 0xf93211aeUL, 0x29a16dc7UL,-      0x9e2f4b1dUL, 0xb230f3dcUL, 0x8652ec0dUL, 0xc1e3d077UL,-      0xb3166c2bUL, 0x70b999a9UL, 0x9448fa11UL, 0xe9642247UL,-      0xfc8cc4a8UL, 0xf03f1aa0UL, 0x7d2cd856UL, 0x3390ef22UL,-      0x494ec787UL, 0x38d1c1d9UL, 0xcaa2fe8cUL, 0xd40b3698UL,-      0xf581cfa6UL, 0x7ade28a5UL, 0xb78e26daUL, 0xadbfa43fUL,-      0x3a9de42cUL, 0x78920d50UL, 0x5fcc9b6aUL, 0x7e466254UL,-      0x8d13c2f6UL, 0xd8b8e890UL, 0x39f75e2eUL, 0xc3aff582UL,-      0x5d80be9fUL, 0xd0937c69UL, 0xd52da96fUL, 0x2512b3cfUL,-      0xac993bc8UL, 0x187da710UL, 0x9c636ee8UL, 0x3bbb7bdbUL,-      0x267809cdUL, 0x5918f46eUL, 0x9ab701ecUL, 0x4f9aa883UL,-      0x956e65e6UL, 0xffe67eaaUL, 0xbccf0821UL, 0x15e8e6efUL,-      0xe79bd9baUL, 0x6f36ce4aUL, 0x9f09d4eaUL, 0xb07cd629UL,-      0xa4b2af31UL, 0x3f23312aUL, 0xa59430c6UL, 0xa266c035UL,-      0x4ebc3774UL, 0x82caa6fcUL, 0x90d0b0e0UL, 0xa7d81533UL,-      0x04984af1UL, 0xecdaf741UL, 0xcd500e7fUL, 0x91f62f17UL,-      0x4dd68d76UL, 0xefb04d43UL, 0xaa4d54ccUL, 0x9604dfe4UL,-      0xd1b5e39eUL, 0x6a881b4cUL, 0x2c1fb8c1UL, 0x65517f46UL,-      0x5eea049dUL, 0x8c355d01UL, 0x877473faUL, 0x0b412efbUL,-      0x671d5ab3UL, 0xdbd25292UL, 0x105633e9UL, 0xd647136dUL,-      0xd7618c9aUL, 0xa10c7a37UL, 0xf8148e59UL, 0x133c89ebUL,-      0xa927eeceUL, 0x61c935b7UL, 0x1ce5ede1UL, 0x47b13c7aUL,-      0xd2df599cUL, 0xf2733f55UL, 0x14ce7918UL, 0xc737bf73UL,-      0xf7cdea53UL, 0xfdaa5b5fUL, 0x3d6f14dfUL, 0x44db8678UL,-      0xaff381caUL, 0x68c43eb9UL, 0x24342c38UL, 0xa3405fc2UL,-      0x1dc37216UL, 0xe2250cbcUL, 0x3c498b28UL, 0x0d9541ffUL,-      0xa8017139UL, 0x0cb3de08UL, 0xb4e49cd8UL, 0x56c19064UL,-      0xcb84617bUL, 0x32b670d5UL, 0x6c5c7448UL, 0xb85742d0UL-  };-  static const SWord8 table6[] = {-        0,  14,  28,  18,  56,  54,  36,  42, 112, 126, 108,  98,  72,-       70,  84,  90, 224, 238, 252, 242, 216, 214, 196, 202, 144, 158,-      140, 130, 168, 166, 180, 186, 219, 213, 199, 201, 227, 237, 255,-      241, 171, 165, 183, 185, 147, 157, 143, 129,  59,  53,  39,  41,-        3,  13,  31,  17,  75,  69,  87,  89, 115, 125, 111,  97, 173,-      163, 177, 191, 149, 155, 137, 135, 221, 211, 193, 207, 229, 235,-      249, 247,  77,  67,  81,  95, 117, 123, 105, 103,  61,  51,  33,-       47,   5,  11,  25,  23, 118, 120, 106, 100,  78,  64,  82,  92,-        6,   8,  26,  20,  62,  48,  34,  44, 150, 152, 138, 132, 174,-      160, 178, 188, 230, 232, 250, 244, 222, 208, 194, 204,  65,  79,-       93,  83, 121, 119, 101, 107,  49,  63,  45,  35,   9,   7,  21,-       27, 161, 175, 189, 179, 153, 151, 133, 139, 209, 223, 205, 195,-      233, 231, 245, 251, 154, 148, 134, 136, 162, 172, 190, 176, 234,-      228, 246, 248, 210, 220, 206, 192, 122, 116, 102, 104,  66,  76,-       94,  80,  10,   4,  22,  24,  50,  60,  46,  32, 236, 226, 240,-      254, 212, 218, 200, 198, 156, 146, 128, 142, 164, 170, 184, 182,-       12,   2,  16,  30,  52,  58,  40,  38, 124, 114,  96, 110,  68,-       74,  88,  86,  55,  57,  43,  37,  15,   1,  19,  29,  71,  73,-       91,  85, 127, 113,  99, 109, 215, 217, 203, 197, 239, 225, 243,-      253, 167, 169, 187, 181, 159, 145, 131, 141-  };-  static const SWord8 table7[] = {-        0,  11,  22,  29,  44,  39,  58,  49,  88,  83,  78,  69, 116,-      127,  98, 105, 176, 187, 166, 173, 156, 151, 138, 129, 232, 227,-      254, 245, 196, 207, 210, 217, 123, 112, 109, 102,  87,  92,  65,-       74,  35,  40,  53,  62,  15,   4,  25,  18, 203, 192, 221, 214,-      231, 236, 241, 250, 147, 152, 133, 142, 191, 180, 169, 162, 246,-      253, 224, 235, 218, 209, 204, 199, 174, 165, 184, 179, 130, 137,-      148, 159,  70,  77,  80,  91, 106,  97, 124, 119,  30,  21,   8,-        3,  50,  57,  36,  47, 141, 134, 155, 144, 161, 170, 183, 188,-      213, 222, 195, 200, 249, 242, 239, 228,  61,  54,  43,  32,  17,-       26,   7,  12, 101, 110, 115, 120,  73,  66,  95,  84, 247, 252,-      225, 234, 219, 208, 205, 198, 175, 164, 185, 178, 131, 136, 149,-      158,  71,  76,  81,  90, 107,  96, 125, 118,  31,  20,   9,   2,-       51,  56,  37,  46, 140, 135, 154, 145, 160, 171, 182, 189, 212,-      223, 194, 201, 248, 243, 238, 229,  60,  55,  42,  33,  16,  27,-        6,  13, 100, 111, 114, 121,  72,  67,  94,  85,   1,  10,  23,-       28,  45,  38,  59,  48,  89,  82,  79,  68, 117, 126,  99, 104,-      177, 186, 167, 172, 157, 150, 139, 128, 233, 226, 255, 244, 197,-      206, 211, 216, 122, 113, 108, 103,  86,  93,  64,  75,  34,  41,-       52,  63,  14,   5,  24,  19, 202, 193, 220, 215, 230, 237, 240,-      251, 146, 153, 132, 143, 190, 181, 168, 163-  };-  static const SWord8 table8[] = {-        0,  13,  26,  23,  52,  57,  46,  35, 104, 101, 114, 127,  92,-       81,  70,  75, 208, 221, 202, 199, 228, 233, 254, 243, 184, 181,-      162, 175, 140, 129, 150, 155, 187, 182, 161, 172, 143, 130, 149,-      152, 211, 222, 201, 196, 231, 234, 253, 240, 107, 102, 113, 124,-       95,  82,  69,  72,   3,  14,  25,  20,  55,  58,  45,  32, 109,-       96, 119, 122,  89,  84,  67,  78,   5,   8,  31,  18,  49,  60,-       43,  38, 189, 176, 167, 170, 137, 132, 147, 158, 213, 216, 207,-      194, 225, 236, 251, 246, 214, 219, 204, 193, 226, 239, 248, 245,-      190, 179, 164, 169, 138, 135, 144, 157,   6,  11,  28,  17,  50,-       63,  40,  37, 110,  99, 116, 121,  90,  87,  64,  77, 218, 215,-      192, 205, 238, 227, 244, 249, 178, 191, 168, 165, 134, 139, 156,-      145,  10,   7,  16,  29,  62,  51,  36,  41,  98, 111, 120, 117,-       86,  91,  76,  65,  97, 108, 123, 118,  85,  88,  79,  66,   9,-        4,  19,  30,  61,  48,  39,  42, 177, 188, 171, 166, 133, 136,-      159, 146, 217, 212, 195, 206, 237, 224, 247, 250, 183, 186, 173,-      160, 131, 142, 153, 148, 223, 210, 197, 200, 235, 230, 241, 252,-      103, 106, 125, 112,  83,  94,  73,  68,  15,   2,  21,  24,  59,-       54,  33,  44,  12,   1,  22,  27,  56,  53,  34,  47, 100, 105,-      126, 115,  80,  93,  74,  71, 220, 209, 198, 203, 232, 229, 242,-      255, 180, 185, 174, 163, 128, 141, 154, 151-  };-  static const SWord8 table9[] = {-        0,   9,  18,  27,  36,  45,  54,  63,  72,  65,  90,  83, 108,-      101, 126, 119, 144, 153, 130, 139, 180, 189, 166, 175, 216, 209,-      202, 195, 252, 245, 238, 231,  59,  50,  41,  32,  31,  22,  13,-        4, 115, 122,  97, 104,  87,  94,  69,  76, 171, 162, 185, 176,-      143, 134, 157, 148, 227, 234, 241, 248, 199, 206, 213, 220, 118,-      127, 100, 109,  82,  91,  64,  73,  62,  55,  44,  37,  26,  19,-        8,   1, 230, 239, 244, 253, 194, 203, 208, 217, 174, 167, 188,-      181, 138, 131, 152, 145,  77,  68,  95,  86, 105,  96, 123, 114,-        5,  12,  23,  30,  33,  40,  51,  58, 221, 212, 207, 198, 249,-      240, 235, 226, 149, 156, 135, 142, 177, 184, 163, 170, 236, 229,-      254, 247, 200, 193, 218, 211, 164, 173, 182, 191, 128, 137, 146,-      155, 124, 117, 110, 103,  88,  81,  74,  67,  52,  61,  38,  47,-       16,  25,   2,  11, 215, 222, 197, 204, 243, 250, 225, 232, 159,-      150, 141, 132, 187, 178, 169, 160,  71,  78,  85,  92,  99, 106,-      113, 120,  15,   6,  29,  20,  43,  34,  57,  48, 154, 147, 136,-      129, 190, 183, 172, 165, 210, 219, 192, 201, 246, 255, 228, 237,-       10,   3,  24,  17,  46,  39,  60,  53,  66,  75,  80,  89, 102,-      111, 116, 125, 161, 168, 179, 186, 133, 140, 151, 158, 233, 224,-      251, 242, 205, 196, 223, 214,  49,  56,  35,  42,  21,  28,   7,-       14, 121, 112, 107,  98,  93,  84,  79,  70-  };-  const SWord32 s520 = (s7 << 8) | (s7 >> 24);-  const SWord16 s521 = (SWord16) (s520 >> 16);-  const SWord8  s522 = (SWord8) (s521 >> 8);-  const SWord8  s523 = table2[s522];-  const SWord8  s524 = 1 ^ s523;-  const SWord8  s525 = (SWord8) s521;-  const SWord8  s526 = table2[s525];-  const SWord16 s527 = (((SWord16) s524) << 8) | ((SWord16) s526);-  const SWord16 s528 = (SWord16) s520;-  const SWord8  s529 = (SWord8) (s528 >> 8);-  const SWord8  s530 = table2[s529];-  const SWord8  s531 = (SWord8) s528;-  const SWord8  s532 = table2[s531];-  const SWord16 s533 = (((SWord16) s530) << 8) | ((SWord16) s532);-  const SWord32 s534 = (((SWord32) s527) << 16) | ((SWord32) s533);-  const SWord32 s535 = s4 ^ s534;-  const SWord32 s536 = s5 ^ s535;-  const SWord32 s537 = s6 ^ s536;-  const SWord32 s538 = s7 ^ s537;-  const SWord32 s539 = (s538 << 8) | (s538 >> 24);-  const SWord16 s540 = (SWord16) (s539 >> 16);-  const SWord8  s541 = (SWord8) (s540 >> 8);-  const SWord8  s542 = table2[s541];-  const SWord8  s543 = 2 ^ s542;-  const SWord8  s544 = (SWord8) s540;-  const SWord8  s545 = table2[s544];-  const SWord16 s546 = (((SWord16) s543) << 8) | ((SWord16) s545);-  const SWord16 s547 = (SWord16) s539;-  const SWord8  s548 = (SWord8) (s547 >> 8);-  const SWord8  s549 = table2[s548];-  const SWord8  s550 = (SWord8) s547;-  const SWord8  s551 = table2[s550];-  const SWord16 s552 = (((SWord16) s549) << 8) | ((SWord16) s551);-  const SWord32 s553 = (((SWord32) s546) << 16) | ((SWord32) s552);-  const SWord32 s554 = s535 ^ s553;-  const SWord32 s555 = s536 ^ s554;-  const SWord32 s556 = s537 ^ s555;-  const SWord32 s557 = s538 ^ s556;-  const SWord32 s558 = (s557 << 8) | (s557 >> 24);-  const SWord16 s559 = (SWord16) (s558 >> 16);-  const SWord8  s560 = (SWord8) (s559 >> 8);-  const SWord8  s561 = table2[s560];-  const SWord8  s562 = 4 ^ s561;-  const SWord8  s563 = (SWord8) s559;-  const SWord8  s564 = table2[s563];-  const SWord16 s565 = (((SWord16) s562) << 8) | ((SWord16) s564);-  const SWord16 s566 = (SWord16) s558;-  const SWord8  s567 = (SWord8) (s566 >> 8);-  const SWord8  s568 = table2[s567];-  const SWord8  s569 = (SWord8) s566;-  const SWord8  s570 = table2[s569];-  const SWord16 s571 = (((SWord16) s568) << 8) | ((SWord16) s570);-  const SWord32 s572 = (((SWord32) s565) << 16) | ((SWord32) s571);-  const SWord32 s573 = s554 ^ s572;-  const SWord32 s574 = s555 ^ s573;-  const SWord32 s575 = s556 ^ s574;-  const SWord32 s576 = s557 ^ s575;-  const SWord32 s577 = (s576 << 8) | (s576 >> 24);-  const SWord16 s578 = (SWord16) (s577 >> 16);-  const SWord8  s579 = (SWord8) (s578 >> 8);-  const SWord8  s580 = table2[s579];-  const SWord8  s581 = 8 ^ s580;-  const SWord8  s582 = (SWord8) s578;-  const SWord8  s583 = table2[s582];-  const SWord16 s584 = (((SWord16) s581) << 8) | ((SWord16) s583);-  const SWord16 s585 = (SWord16) s577;-  const SWord8  s586 = (SWord8) (s585 >> 8);-  const SWord8  s587 = table2[s586];-  const SWord8  s588 = (SWord8) s585;-  const SWord8  s589 = table2[s588];-  const SWord16 s590 = (((SWord16) s587) << 8) | ((SWord16) s589);-  const SWord32 s591 = (((SWord32) s584) << 16) | ((SWord32) s590);-  const SWord32 s592 = s573 ^ s591;-  const SWord32 s593 = s574 ^ s592;-  const SWord32 s594 = s575 ^ s593;-  const SWord32 s595 = s576 ^ s594;-  const SWord32 s596 = (s595 << 8) | (s595 >> 24);-  const SWord16 s597 = (SWord16) (s596 >> 16);-  const SWord8  s598 = (SWord8) (s597 >> 8);-  const SWord8  s599 = table2[s598];-  const SWord8  s600 = 16 ^ s599;-  const SWord8  s601 = (SWord8) s597;-  const SWord8  s602 = table2[s601];-  const SWord16 s603 = (((SWord16) s600) << 8) | ((SWord16) s602);-  const SWord16 s604 = (SWord16) s596;-  const SWord8  s605 = (SWord8) (s604 >> 8);-  const SWord8  s606 = table2[s605];-  const SWord8  s607 = (SWord8) s604;-  const SWord8  s608 = table2[s607];-  const SWord16 s609 = (((SWord16) s606) << 8) | ((SWord16) s608);-  const SWord32 s610 = (((SWord32) s603) << 16) | ((SWord32) s609);-  const SWord32 s611 = s592 ^ s610;-  const SWord32 s612 = s593 ^ s611;-  const SWord32 s613 = s594 ^ s612;-  const SWord32 s614 = s595 ^ s613;-  const SWord32 s615 = (s614 << 8) | (s614 >> 24);-  const SWord16 s616 = (SWord16) (s615 >> 16);-  const SWord8  s617 = (SWord8) (s616 >> 8);-  const SWord8  s618 = table2[s617];-  const SWord8  s619 = 32 ^ s618;-  const SWord8  s620 = (SWord8) s616;-  const SWord8  s621 = table2[s620];-  const SWord16 s622 = (((SWord16) s619) << 8) | ((SWord16) s621);-  const SWord16 s623 = (SWord16) s615;-  const SWord8  s624 = (SWord8) (s623 >> 8);-  const SWord8  s625 = table2[s624];-  const SWord8  s626 = (SWord8) s623;-  const SWord8  s627 = table2[s626];-  const SWord16 s628 = (((SWord16) s625) << 8) | ((SWord16) s627);-  const SWord32 s629 = (((SWord32) s622) << 16) | ((SWord32) s628);-  const SWord32 s630 = s611 ^ s629;-  const SWord32 s631 = s612 ^ s630;-  const SWord32 s632 = s613 ^ s631;-  const SWord32 s633 = s614 ^ s632;-  const SWord32 s634 = (s633 << 8) | (s633 >> 24);-  const SWord16 s635 = (SWord16) (s634 >> 16);-  const SWord8  s636 = (SWord8) (s635 >> 8);-  const SWord8  s637 = table2[s636];-  const SWord8  s638 = 64 ^ s637;-  const SWord8  s639 = (SWord8) s635;-  const SWord8  s640 = table2[s639];-  const SWord16 s641 = (((SWord16) s638) << 8) | ((SWord16) s640);-  const SWord16 s642 = (SWord16) s634;-  const SWord8  s643 = (SWord8) (s642 >> 8);-  const SWord8  s644 = table2[s643];-  const SWord8  s645 = (SWord8) s642;-  const SWord8  s646 = table2[s645];-  const SWord16 s647 = (((SWord16) s644) << 8) | ((SWord16) s646);-  const SWord32 s648 = (((SWord32) s641) << 16) | ((SWord32) s647);-  const SWord32 s649 = s630 ^ s648;-  const SWord32 s650 = s631 ^ s649;-  const SWord32 s651 = s632 ^ s650;-  const SWord32 s652 = s633 ^ s651;-  const SWord32 s653 = (s652 << 8) | (s652 >> 24);-  const SWord16 s654 = (SWord16) (s653 >> 16);-  const SWord8  s655 = (SWord8) (s654 >> 8);-  const SWord8  s656 = table2[s655];-  const SWord8  s657 = 128 ^ s656;-  const SWord8  s658 = (SWord8) s654;-  const SWord8  s659 = table2[s658];-  const SWord16 s660 = (((SWord16) s657) << 8) | ((SWord16) s659);-  const SWord16 s661 = (SWord16) s653;-  const SWord8  s662 = (SWord8) (s661 >> 8);-  const SWord8  s663 = table2[s662];-  const SWord8  s664 = (SWord8) s661;-  const SWord8  s665 = table2[s664];-  const SWord16 s666 = (((SWord16) s663) << 8) | ((SWord16) s665);-  const SWord32 s667 = (((SWord32) s660) << 16) | ((SWord32) s666);-  const SWord32 s668 = s649 ^ s667;-  const SWord32 s669 = s650 ^ s668;-  const SWord32 s670 = s651 ^ s669;-  const SWord32 s671 = s652 ^ s670;-  const SWord32 s672 = (s671 << 8) | (s671 >> 24);-  const SWord16 s673 = (SWord16) (s672 >> 16);-  const SWord8  s674 = (SWord8) (s673 >> 8);-  const SWord8  s675 = table2[s674];-  const SWord8  s676 = 27 ^ s675;-  const SWord8  s677 = (SWord8) s673;-  const SWord8  s678 = table2[s677];-  const SWord16 s679 = (((SWord16) s676) << 8) | ((SWord16) s678);-  const SWord16 s680 = (SWord16) s672;-  const SWord8  s681 = (SWord8) (s680 >> 8);-  const SWord8  s682 = table2[s681];-  const SWord8  s683 = (SWord8) s680;-  const SWord8  s684 = table2[s683];-  const SWord16 s685 = (((SWord16) s682) << 8) | ((SWord16) s684);-  const SWord32 s686 = (((SWord32) s679) << 16) | ((SWord32) s685);-  const SWord32 s687 = s668 ^ s686;-  const SWord32 s688 = s669 ^ s687;-  const SWord32 s689 = s670 ^ s688;-  const SWord32 s690 = s671 ^ s689;-  const SWord32 s691 = (s690 << 8) | (s690 >> 24);-  const SWord16 s692 = (SWord16) (s691 >> 16);-  const SWord8  s693 = (SWord8) (s692 >> 8);-  const SWord8  s694 = table2[s693];-  const SWord8  s695 = 54 ^ s694;-  const SWord8  s696 = (SWord8) s692;-  const SWord8  s697 = table2[s696];-  const SWord16 s698 = (((SWord16) s695) << 8) | ((SWord16) s697);-  const SWord16 s699 = (SWord16) s691;-  const SWord8  s700 = (SWord8) (s699 >> 8);-  const SWord8  s701 = table2[s700];-  const SWord8  s702 = (SWord8) s699;-  const SWord8  s703 = table2[s702];-  const SWord16 s704 = (((SWord16) s701) << 8) | ((SWord16) s703);-  const SWord32 s705 = (((SWord32) s698) << 16) | ((SWord32) s704);-  const SWord32 s706 = s687 ^ s705;-  const SWord32 s707 = s0 ^ s706;-  const SWord16 s708 = (SWord16) (s707 >> 16);-  const SWord8  s709 = (SWord8) (s708 >> 8);-  const SWord32 s710 = table1[s709];-  const SWord32 s966 = s688 ^ s706;-  const SWord32 s967 = s689 ^ s966;-  const SWord32 s968 = s690 ^ s967;-  const SWord32 s969 = s3 ^ s968;-  const SWord16 s970 = (SWord16) (s969 >> 16);-  const SWord8  s971 = (SWord8) s970;-  const SWord32 s972 = table3[s971];-  const SWord32 s973 = s710 ^ s972;-  const SWord32 s1229 = s2 ^ s967;-  const SWord16 s1230 = (SWord16) s1229;-  const SWord8  s1231 = (SWord8) (s1230 >> 8);-  const SWord32 s1232 = table4[s1231];-  const SWord32 s1233 = s973 ^ s1232;-  const SWord32 s1489 = s1 ^ s966;-  const SWord16 s1490 = (SWord16) s1489;-  const SWord8  s1491 = (SWord8) s1490;-  const SWord32 s1492 = table5[s1491];-  const SWord32 s1493 = s1233 ^ s1492;-  const SWord16 s1494 = (SWord16) (s687 >> 16);-  const SWord8  s1495 = (SWord8) (s1494 >> 8);-  const SWord8  s1496 = table6[s1495];-  const SWord8  s1497 = (SWord8) s1494;-  const SWord8  s1498 = table7[s1497];-  const SWord16 s1499 = (SWord16) s687;-  const SWord8  s1500 = (SWord8) (s1499 >> 8);-  const SWord8  s1501 = table8[s1500];-  const SWord8  s1502 = (SWord8) s1499;-  const SWord8  s1503 = table9[s1502];-  const SWord8  s1504 = s1501 ^ s1503;-  const SWord8  s1505 = s1498 ^ s1504;-  const SWord8  s1506 = s1496 ^ s1505;-  const SWord8  s1507 = table9[s1495];-  const SWord8  s1508 = table6[s1497];-  const SWord8  s1509 = table7[s1500];-  const SWord8  s1510 = table8[s1502];-  const SWord8  s1511 = s1509 ^ s1510;-  const SWord8  s1512 = s1508 ^ s1511;-  const SWord8  s1513 = s1507 ^ s1512;-  const SWord16 s1514 = (((SWord16) s1506) << 8) | ((SWord16) s1513);-  const SWord8  s1515 = table8[s1495];-  const SWord8  s1516 = table9[s1497];-  const SWord8  s1517 = table6[s1500];-  const SWord8  s1518 = table7[s1502];-  const SWord8  s1519 = s1517 ^ s1518;-  const SWord8  s1520 = s1516 ^ s1519;-  const SWord8  s1521 = s1515 ^ s1520;-  const SWord8  s1522 = table7[s1495];-  const SWord8  s1523 = table8[s1497];-  const SWord8  s1524 = table9[s1500];-  const SWord8  s1525 = table6[s1502];-  const SWord8  s1526 = s1524 ^ s1525;-  const SWord8  s1527 = s1523 ^ s1526;-  const SWord8  s1528 = s1522 ^ s1527;-  const SWord16 s1529 = (((SWord16) s1521) << 8) | ((SWord16) s1528);-  const SWord32 s1530 = (((SWord32) s1514) << 16) | ((SWord32) s1529);-  const SWord32 s1531 = s1493 ^ s1530;-  const SWord16 s1532 = (SWord16) (s1531 >> 16);-  const SWord8  s1533 = (SWord8) (s1532 >> 8);-  const SWord32 s1534 = table1[s1533];-  const SWord8  s1535 = (SWord8) (s970 >> 8);-  const SWord32 s1536 = table1[s1535];-  const SWord16 s1537 = (SWord16) (s1229 >> 16);-  const SWord8  s1538 = (SWord8) s1537;-  const SWord32 s1539 = table3[s1538];-  const SWord32 s1540 = s1536 ^ s1539;-  const SWord8  s1541 = (SWord8) (s1490 >> 8);-  const SWord32 s1542 = table4[s1541];-  const SWord32 s1543 = s1540 ^ s1542;-  const SWord16 s1544 = (SWord16) s707;-  const SWord8  s1545 = (SWord8) s1544;-  const SWord32 s1546 = table5[s1545];-  const SWord32 s1547 = s1543 ^ s1546;-  const SWord16 s1548 = (SWord16) (s690 >> 16);-  const SWord8  s1549 = (SWord8) (s1548 >> 8);-  const SWord8  s1550 = table6[s1549];-  const SWord8  s1551 = (SWord8) s1548;-  const SWord8  s1552 = table7[s1551];-  const SWord16 s1553 = (SWord16) s690;-  const SWord8  s1554 = (SWord8) (s1553 >> 8);-  const SWord8  s1555 = table8[s1554];-  const SWord8  s1556 = (SWord8) s1553;-  const SWord8  s1557 = table9[s1556];-  const SWord8  s1558 = s1555 ^ s1557;-  const SWord8  s1559 = s1552 ^ s1558;-  const SWord8  s1560 = s1550 ^ s1559;-  const SWord8  s1561 = table9[s1549];-  const SWord8  s1562 = table6[s1551];-  const SWord8  s1563 = table7[s1554];-  const SWord8  s1564 = table8[s1556];-  const SWord8  s1565 = s1563 ^ s1564;-  const SWord8  s1566 = s1562 ^ s1565;-  const SWord8  s1567 = s1561 ^ s1566;-  const SWord16 s1568 = (((SWord16) s1560) << 8) | ((SWord16) s1567);-  const SWord8  s1569 = table8[s1549];-  const SWord8  s1570 = table9[s1551];-  const SWord8  s1571 = table6[s1554];-  const SWord8  s1572 = table7[s1556];-  const SWord8  s1573 = s1571 ^ s1572;-  const SWord8  s1574 = s1570 ^ s1573;-  const SWord8  s1575 = s1569 ^ s1574;-  const SWord8  s1576 = table7[s1549];-  const SWord8  s1577 = table8[s1551];-  const SWord8  s1578 = table9[s1554];-  const SWord8  s1579 = table6[s1556];-  const SWord8  s1580 = s1578 ^ s1579;-  const SWord8  s1581 = s1577 ^ s1580;-  const SWord8  s1582 = s1576 ^ s1581;-  const SWord16 s1583 = (((SWord16) s1575) << 8) | ((SWord16) s1582);-  const SWord32 s1584 = (((SWord32) s1568) << 16) | ((SWord32) s1583);-  const SWord32 s1585 = s1547 ^ s1584;-  const SWord16 s1586 = (SWord16) (s1585 >> 16);-  const SWord8  s1587 = (SWord8) s1586;-  const SWord32 s1588 = table3[s1587];-  const SWord32 s1589 = s1534 ^ s1588;-  const SWord8  s1590 = (SWord8) (s1537 >> 8);-  const SWord32 s1591 = table1[s1590];-  const SWord16 s1592 = (SWord16) (s1489 >> 16);-  const SWord8  s1593 = (SWord8) s1592;-  const SWord32 s1594 = table3[s1593];-  const SWord32 s1595 = s1591 ^ s1594;-  const SWord8  s1596 = (SWord8) (s1544 >> 8);-  const SWord32 s1597 = table4[s1596];-  const SWord32 s1598 = s1595 ^ s1597;-  const SWord16 s1599 = (SWord16) s969;-  const SWord8  s1600 = (SWord8) s1599;-  const SWord32 s1601 = table5[s1600];-  const SWord32 s1602 = s1598 ^ s1601;-  const SWord16 s1603 = (SWord16) (s689 >> 16);-  const SWord8  s1604 = (SWord8) (s1603 >> 8);-  const SWord8  s1605 = table6[s1604];-  const SWord8  s1606 = (SWord8) s1603;-  const SWord8  s1607 = table7[s1606];-  const SWord16 s1608 = (SWord16) s689;-  const SWord8  s1609 = (SWord8) (s1608 >> 8);-  const SWord8  s1610 = table8[s1609];-  const SWord8  s1611 = (SWord8) s1608;-  const SWord8  s1612 = table9[s1611];-  const SWord8  s1613 = s1610 ^ s1612;-  const SWord8  s1614 = s1607 ^ s1613;-  const SWord8  s1615 = s1605 ^ s1614;-  const SWord8  s1616 = table9[s1604];-  const SWord8  s1617 = table6[s1606];-  const SWord8  s1618 = table7[s1609];-  const SWord8  s1619 = table8[s1611];-  const SWord8  s1620 = s1618 ^ s1619;-  const SWord8  s1621 = s1617 ^ s1620;-  const SWord8  s1622 = s1616 ^ s1621;-  const SWord16 s1623 = (((SWord16) s1615) << 8) | ((SWord16) s1622);-  const SWord8  s1624 = table8[s1604];-  const SWord8  s1625 = table9[s1606];-  const SWord8  s1626 = table6[s1609];-  const SWord8  s1627 = table7[s1611];-  const SWord8  s1628 = s1626 ^ s1627;-  const SWord8  s1629 = s1625 ^ s1628;-  const SWord8  s1630 = s1624 ^ s1629;-  const SWord8  s1631 = table7[s1604];-  const SWord8  s1632 = table8[s1606];-  const SWord8  s1633 = table9[s1609];-  const SWord8  s1634 = table6[s1611];-  const SWord8  s1635 = s1633 ^ s1634;-  const SWord8  s1636 = s1632 ^ s1635;-  const SWord8  s1637 = s1631 ^ s1636;-  const SWord16 s1638 = (((SWord16) s1630) << 8) | ((SWord16) s1637);-  const SWord32 s1639 = (((SWord32) s1623) << 16) | ((SWord32) s1638);-  const SWord32 s1640 = s1602 ^ s1639;-  const SWord16 s1641 = (SWord16) s1640;-  const SWord8  s1642 = (SWord8) (s1641 >> 8);-  const SWord32 s1643 = table4[s1642];-  const SWord32 s1644 = s1589 ^ s1643;-  const SWord8  s1645 = (SWord8) (s1592 >> 8);-  const SWord32 s1646 = table1[s1645];-  const SWord8  s1647 = (SWord8) s708;-  const SWord32 s1648 = table3[s1647];-  const SWord32 s1649 = s1646 ^ s1648;-  const SWord8  s1650 = (SWord8) (s1599 >> 8);-  const SWord32 s1651 = table4[s1650];-  const SWord32 s1652 = s1649 ^ s1651;-  const SWord8  s1653 = (SWord8) s1230;-  const SWord32 s1654 = table5[s1653];-  const SWord32 s1655 = s1652 ^ s1654;-  const SWord16 s1656 = (SWord16) (s688 >> 16);-  const SWord8  s1657 = (SWord8) (s1656 >> 8);-  const SWord8  s1658 = table6[s1657];-  const SWord8  s1659 = (SWord8) s1656;-  const SWord8  s1660 = table7[s1659];-  const SWord16 s1661 = (SWord16) s688;-  const SWord8  s1662 = (SWord8) (s1661 >> 8);-  const SWord8  s1663 = table8[s1662];-  const SWord8  s1664 = (SWord8) s1661;-  const SWord8  s1665 = table9[s1664];-  const SWord8  s1666 = s1663 ^ s1665;-  const SWord8  s1667 = s1660 ^ s1666;-  const SWord8  s1668 = s1658 ^ s1667;-  const SWord8  s1669 = table9[s1657];-  const SWord8  s1670 = table6[s1659];-  const SWord8  s1671 = table7[s1662];-  const SWord8  s1672 = table8[s1664];-  const SWord8  s1673 = s1671 ^ s1672;-  const SWord8  s1674 = s1670 ^ s1673;-  const SWord8  s1675 = s1669 ^ s1674;-  const SWord16 s1676 = (((SWord16) s1668) << 8) | ((SWord16) s1675);-  const SWord8  s1677 = table8[s1657];-  const SWord8  s1678 = table9[s1659];-  const SWord8  s1679 = table6[s1662];-  const SWord8  s1680 = table7[s1664];-  const SWord8  s1681 = s1679 ^ s1680;-  const SWord8  s1682 = s1678 ^ s1681;-  const SWord8  s1683 = s1677 ^ s1682;-  const SWord8  s1684 = table7[s1657];-  const SWord8  s1685 = table8[s1659];-  const SWord8  s1686 = table9[s1662];-  const SWord8  s1687 = table6[s1664];-  const SWord8  s1688 = s1686 ^ s1687;-  const SWord8  s1689 = s1685 ^ s1688;-  const SWord8  s1690 = s1684 ^ s1689;-  const SWord16 s1691 = (((SWord16) s1683) << 8) | ((SWord16) s1690);-  const SWord32 s1692 = (((SWord32) s1676) << 16) | ((SWord32) s1691);-  const SWord32 s1693 = s1655 ^ s1692;-  const SWord16 s1694 = (SWord16) s1693;-  const SWord8  s1695 = (SWord8) s1694;-  const SWord32 s1696 = table5[s1695];-  const SWord32 s1697 = s1644 ^ s1696;-  const SWord16 s1698 = (SWord16) (s668 >> 16);-  const SWord8  s1699 = (SWord8) (s1698 >> 8);-  const SWord8  s1700 = table6[s1699];-  const SWord8  s1701 = (SWord8) s1698;-  const SWord8  s1702 = table7[s1701];-  const SWord16 s1703 = (SWord16) s668;-  const SWord8  s1704 = (SWord8) (s1703 >> 8);-  const SWord8  s1705 = table8[s1704];-  const SWord8  s1706 = (SWord8) s1703;-  const SWord8  s1707 = table9[s1706];-  const SWord8  s1708 = s1705 ^ s1707;-  const SWord8  s1709 = s1702 ^ s1708;-  const SWord8  s1710 = s1700 ^ s1709;-  const SWord8  s1711 = table9[s1699];-  const SWord8  s1712 = table6[s1701];-  const SWord8  s1713 = table7[s1704];-  const SWord8  s1714 = table8[s1706];-  const SWord8  s1715 = s1713 ^ s1714;-  const SWord8  s1716 = s1712 ^ s1715;-  const SWord8  s1717 = s1711 ^ s1716;-  const SWord16 s1718 = (((SWord16) s1710) << 8) | ((SWord16) s1717);-  const SWord8  s1719 = table8[s1699];-  const SWord8  s1720 = table9[s1701];-  const SWord8  s1721 = table6[s1704];-  const SWord8  s1722 = table7[s1706];-  const SWord8  s1723 = s1721 ^ s1722;-  const SWord8  s1724 = s1720 ^ s1723;-  const SWord8  s1725 = s1719 ^ s1724;-  const SWord8  s1726 = table7[s1699];-  const SWord8  s1727 = table8[s1701];-  const SWord8  s1728 = table9[s1704];-  const SWord8  s1729 = table6[s1706];-  const SWord8  s1730 = s1728 ^ s1729;-  const SWord8  s1731 = s1727 ^ s1730;-  const SWord8  s1732 = s1726 ^ s1731;-  const SWord16 s1733 = (((SWord16) s1725) << 8) | ((SWord16) s1732);-  const SWord32 s1734 = (((SWord32) s1718) << 16) | ((SWord32) s1733);-  const SWord32 s1735 = s1697 ^ s1734;-  const SWord16 s1736 = (SWord16) (s1735 >> 16);-  const SWord8  s1737 = (SWord8) (s1736 >> 8);-  const SWord32 s1738 = table1[s1737];-  const SWord8  s1739 = (SWord8) (s1586 >> 8);-  const SWord32 s1740 = table1[s1739];-  const SWord16 s1741 = (SWord16) (s1640 >> 16);-  const SWord8  s1742 = (SWord8) s1741;-  const SWord32 s1743 = table3[s1742];-  const SWord32 s1744 = s1740 ^ s1743;-  const SWord8  s1745 = (SWord8) (s1694 >> 8);-  const SWord32 s1746 = table4[s1745];-  const SWord32 s1747 = s1744 ^ s1746;-  const SWord16 s1748 = (SWord16) s1531;-  const SWord8  s1749 = (SWord8) s1748;-  const SWord32 s1750 = table5[s1749];-  const SWord32 s1751 = s1747 ^ s1750;-  const SWord16 s1752 = (SWord16) (s671 >> 16);-  const SWord8  s1753 = (SWord8) (s1752 >> 8);-  const SWord8  s1754 = table6[s1753];-  const SWord8  s1755 = (SWord8) s1752;-  const SWord8  s1756 = table7[s1755];-  const SWord16 s1757 = (SWord16) s671;-  const SWord8  s1758 = (SWord8) (s1757 >> 8);-  const SWord8  s1759 = table8[s1758];-  const SWord8  s1760 = (SWord8) s1757;-  const SWord8  s1761 = table9[s1760];-  const SWord8  s1762 = s1759 ^ s1761;-  const SWord8  s1763 = s1756 ^ s1762;-  const SWord8  s1764 = s1754 ^ s1763;-  const SWord8  s1765 = table9[s1753];-  const SWord8  s1766 = table6[s1755];-  const SWord8  s1767 = table7[s1758];-  const SWord8  s1768 = table8[s1760];-  const SWord8  s1769 = s1767 ^ s1768;-  const SWord8  s1770 = s1766 ^ s1769;-  const SWord8  s1771 = s1765 ^ s1770;-  const SWord16 s1772 = (((SWord16) s1764) << 8) | ((SWord16) s1771);-  const SWord8  s1773 = table8[s1753];-  const SWord8  s1774 = table9[s1755];-  const SWord8  s1775 = table6[s1758];-  const SWord8  s1776 = table7[s1760];-  const SWord8  s1777 = s1775 ^ s1776;-  const SWord8  s1778 = s1774 ^ s1777;-  const SWord8  s1779 = s1773 ^ s1778;-  const SWord8  s1780 = table7[s1753];-  const SWord8  s1781 = table8[s1755];-  const SWord8  s1782 = table9[s1758];-  const SWord8  s1783 = table6[s1760];-  const SWord8  s1784 = s1782 ^ s1783;-  const SWord8  s1785 = s1781 ^ s1784;-  const SWord8  s1786 = s1780 ^ s1785;-  const SWord16 s1787 = (((SWord16) s1779) << 8) | ((SWord16) s1786);-  const SWord32 s1788 = (((SWord32) s1772) << 16) | ((SWord32) s1787);-  const SWord32 s1789 = s1751 ^ s1788;-  const SWord16 s1790 = (SWord16) (s1789 >> 16);-  const SWord8  s1791 = (SWord8) s1790;-  const SWord32 s1792 = table3[s1791];-  const SWord32 s1793 = s1738 ^ s1792;-  const SWord8  s1794 = (SWord8) (s1741 >> 8);-  const SWord32 s1795 = table1[s1794];-  const SWord16 s1796 = (SWord16) (s1693 >> 16);-  const SWord8  s1797 = (SWord8) s1796;-  const SWord32 s1798 = table3[s1797];-  const SWord32 s1799 = s1795 ^ s1798;-  const SWord8  s1800 = (SWord8) (s1748 >> 8);-  const SWord32 s1801 = table4[s1800];-  const SWord32 s1802 = s1799 ^ s1801;-  const SWord16 s1803 = (SWord16) s1585;-  const SWord8  s1804 = (SWord8) s1803;-  const SWord32 s1805 = table5[s1804];-  const SWord32 s1806 = s1802 ^ s1805;-  const SWord16 s1807 = (SWord16) (s670 >> 16);-  const SWord8  s1808 = (SWord8) (s1807 >> 8);-  const SWord8  s1809 = table6[s1808];-  const SWord8  s1810 = (SWord8) s1807;-  const SWord8  s1811 = table7[s1810];-  const SWord16 s1812 = (SWord16) s670;-  const SWord8  s1813 = (SWord8) (s1812 >> 8);-  const SWord8  s1814 = table8[s1813];-  const SWord8  s1815 = (SWord8) s1812;-  const SWord8  s1816 = table9[s1815];-  const SWord8  s1817 = s1814 ^ s1816;-  const SWord8  s1818 = s1811 ^ s1817;-  const SWord8  s1819 = s1809 ^ s1818;-  const SWord8  s1820 = table9[s1808];-  const SWord8  s1821 = table6[s1810];-  const SWord8  s1822 = table7[s1813];-  const SWord8  s1823 = table8[s1815];-  const SWord8  s1824 = s1822 ^ s1823;-  const SWord8  s1825 = s1821 ^ s1824;-  const SWord8  s1826 = s1820 ^ s1825;-  const SWord16 s1827 = (((SWord16) s1819) << 8) | ((SWord16) s1826);-  const SWord8  s1828 = table8[s1808];-  const SWord8  s1829 = table9[s1810];-  const SWord8  s1830 = table6[s1813];-  const SWord8  s1831 = table7[s1815];-  const SWord8  s1832 = s1830 ^ s1831;-  const SWord8  s1833 = s1829 ^ s1832;-  const SWord8  s1834 = s1828 ^ s1833;-  const SWord8  s1835 = table7[s1808];-  const SWord8  s1836 = table8[s1810];-  const SWord8  s1837 = table9[s1813];-  const SWord8  s1838 = table6[s1815];-  const SWord8  s1839 = s1837 ^ s1838;-  const SWord8  s1840 = s1836 ^ s1839;-  const SWord8  s1841 = s1835 ^ s1840;-  const SWord16 s1842 = (((SWord16) s1834) << 8) | ((SWord16) s1841);-  const SWord32 s1843 = (((SWord32) s1827) << 16) | ((SWord32) s1842);-  const SWord32 s1844 = s1806 ^ s1843;-  const SWord16 s1845 = (SWord16) s1844;-  const SWord8  s1846 = (SWord8) (s1845 >> 8);-  const SWord32 s1847 = table4[s1846];-  const SWord32 s1848 = s1793 ^ s1847;-  const SWord8  s1849 = (SWord8) (s1796 >> 8);-  const SWord32 s1850 = table1[s1849];-  const SWord8  s1851 = (SWord8) s1532;-  const SWord32 s1852 = table3[s1851];-  const SWord32 s1853 = s1850 ^ s1852;-  const SWord8  s1854 = (SWord8) (s1803 >> 8);-  const SWord32 s1855 = table4[s1854];-  const SWord32 s1856 = s1853 ^ s1855;-  const SWord8  s1857 = (SWord8) s1641;-  const SWord32 s1858 = table5[s1857];-  const SWord32 s1859 = s1856 ^ s1858;-  const SWord16 s1860 = (SWord16) (s669 >> 16);-  const SWord8  s1861 = (SWord8) (s1860 >> 8);-  const SWord8  s1862 = table6[s1861];-  const SWord8  s1863 = (SWord8) s1860;-  const SWord8  s1864 = table7[s1863];-  const SWord16 s1865 = (SWord16) s669;-  const SWord8  s1866 = (SWord8) (s1865 >> 8);-  const SWord8  s1867 = table8[s1866];-  const SWord8  s1868 = (SWord8) s1865;-  const SWord8  s1869 = table9[s1868];-  const SWord8  s1870 = s1867 ^ s1869;-  const SWord8  s1871 = s1864 ^ s1870;-  const SWord8  s1872 = s1862 ^ s1871;-  const SWord8  s1873 = table9[s1861];-  const SWord8  s1874 = table6[s1863];-  const SWord8  s1875 = table7[s1866];-  const SWord8  s1876 = table8[s1868];-  const SWord8  s1877 = s1875 ^ s1876;-  const SWord8  s1878 = s1874 ^ s1877;-  const SWord8  s1879 = s1873 ^ s1878;-  const SWord16 s1880 = (((SWord16) s1872) << 8) | ((SWord16) s1879);-  const SWord8  s1881 = table8[s1861];-  const SWord8  s1882 = table9[s1863];-  const SWord8  s1883 = table6[s1866];-  const SWord8  s1884 = table7[s1868];-  const SWord8  s1885 = s1883 ^ s1884;-  const SWord8  s1886 = s1882 ^ s1885;-  const SWord8  s1887 = s1881 ^ s1886;-  const SWord8  s1888 = table7[s1861];-  const SWord8  s1889 = table8[s1863];-  const SWord8  s1890 = table9[s1866];-  const SWord8  s1891 = table6[s1868];-  const SWord8  s1892 = s1890 ^ s1891;-  const SWord8  s1893 = s1889 ^ s1892;-  const SWord8  s1894 = s1888 ^ s1893;-  const SWord16 s1895 = (((SWord16) s1887) << 8) | ((SWord16) s1894);-  const SWord32 s1896 = (((SWord32) s1880) << 16) | ((SWord32) s1895);-  const SWord32 s1897 = s1859 ^ s1896;-  const SWord16 s1898 = (SWord16) s1897;-  const SWord8  s1899 = (SWord8) s1898;-  const SWord32 s1900 = table5[s1899];-  const SWord32 s1901 = s1848 ^ s1900;-  const SWord16 s1902 = (SWord16) (s649 >> 16);-  const SWord8  s1903 = (SWord8) (s1902 >> 8);-  const SWord8  s1904 = table6[s1903];-  const SWord8  s1905 = (SWord8) s1902;-  const SWord8  s1906 = table7[s1905];-  const SWord16 s1907 = (SWord16) s649;-  const SWord8  s1908 = (SWord8) (s1907 >> 8);-  const SWord8  s1909 = table8[s1908];-  const SWord8  s1910 = (SWord8) s1907;-  const SWord8  s1911 = table9[s1910];-  const SWord8  s1912 = s1909 ^ s1911;-  const SWord8  s1913 = s1906 ^ s1912;-  const SWord8  s1914 = s1904 ^ s1913;-  const SWord8  s1915 = table9[s1903];-  const SWord8  s1916 = table6[s1905];-  const SWord8  s1917 = table7[s1908];-  const SWord8  s1918 = table8[s1910];-  const SWord8  s1919 = s1917 ^ s1918;-  const SWord8  s1920 = s1916 ^ s1919;-  const SWord8  s1921 = s1915 ^ s1920;-  const SWord16 s1922 = (((SWord16) s1914) << 8) | ((SWord16) s1921);-  const SWord8  s1923 = table8[s1903];-  const SWord8  s1924 = table9[s1905];-  const SWord8  s1925 = table6[s1908];-  const SWord8  s1926 = table7[s1910];-  const SWord8  s1927 = s1925 ^ s1926;-  const SWord8  s1928 = s1924 ^ s1927;-  const SWord8  s1929 = s1923 ^ s1928;-  const SWord8  s1930 = table7[s1903];-  const SWord8  s1931 = table8[s1905];-  const SWord8  s1932 = table9[s1908];-  const SWord8  s1933 = table6[s1910];-  const SWord8  s1934 = s1932 ^ s1933;-  const SWord8  s1935 = s1931 ^ s1934;-  const SWord8  s1936 = s1930 ^ s1935;-  const SWord16 s1937 = (((SWord16) s1929) << 8) | ((SWord16) s1936);-  const SWord32 s1938 = (((SWord32) s1922) << 16) | ((SWord32) s1937);-  const SWord32 s1939 = s1901 ^ s1938;-  const SWord16 s1940 = (SWord16) (s1939 >> 16);-  const SWord8  s1941 = (SWord8) (s1940 >> 8);-  const SWord32 s1942 = table1[s1941];-  const SWord8  s1943 = (SWord8) (s1790 >> 8);-  const SWord32 s1944 = table1[s1943];-  const SWord16 s1945 = (SWord16) (s1844 >> 16);-  const SWord8  s1946 = (SWord8) s1945;-  const SWord32 s1947 = table3[s1946];-  const SWord32 s1948 = s1944 ^ s1947;-  const SWord8  s1949 = (SWord8) (s1898 >> 8);-  const SWord32 s1950 = table4[s1949];-  const SWord32 s1951 = s1948 ^ s1950;-  const SWord16 s1952 = (SWord16) s1735;-  const SWord8  s1953 = (SWord8) s1952;-  const SWord32 s1954 = table5[s1953];-  const SWord32 s1955 = s1951 ^ s1954;-  const SWord16 s1956 = (SWord16) (s652 >> 16);-  const SWord8  s1957 = (SWord8) (s1956 >> 8);-  const SWord8  s1958 = table6[s1957];-  const SWord8  s1959 = (SWord8) s1956;-  const SWord8  s1960 = table7[s1959];-  const SWord16 s1961 = (SWord16) s652;-  const SWord8  s1962 = (SWord8) (s1961 >> 8);-  const SWord8  s1963 = table8[s1962];-  const SWord8  s1964 = (SWord8) s1961;-  const SWord8  s1965 = table9[s1964];-  const SWord8  s1966 = s1963 ^ s1965;-  const SWord8  s1967 = s1960 ^ s1966;-  const SWord8  s1968 = s1958 ^ s1967;-  const SWord8  s1969 = table9[s1957];-  const SWord8  s1970 = table6[s1959];-  const SWord8  s1971 = table7[s1962];-  const SWord8  s1972 = table8[s1964];-  const SWord8  s1973 = s1971 ^ s1972;-  const SWord8  s1974 = s1970 ^ s1973;-  const SWord8  s1975 = s1969 ^ s1974;-  const SWord16 s1976 = (((SWord16) s1968) << 8) | ((SWord16) s1975);-  const SWord8  s1977 = table8[s1957];-  const SWord8  s1978 = table9[s1959];-  const SWord8  s1979 = table6[s1962];-  const SWord8  s1980 = table7[s1964];-  const SWord8  s1981 = s1979 ^ s1980;-  const SWord8  s1982 = s1978 ^ s1981;-  const SWord8  s1983 = s1977 ^ s1982;-  const SWord8  s1984 = table7[s1957];-  const SWord8  s1985 = table8[s1959];-  const SWord8  s1986 = table9[s1962];-  const SWord8  s1987 = table6[s1964];-  const SWord8  s1988 = s1986 ^ s1987;-  const SWord8  s1989 = s1985 ^ s1988;-  const SWord8  s1990 = s1984 ^ s1989;-  const SWord16 s1991 = (((SWord16) s1983) << 8) | ((SWord16) s1990);-  const SWord32 s1992 = (((SWord32) s1976) << 16) | ((SWord32) s1991);-  const SWord32 s1993 = s1955 ^ s1992;-  const SWord16 s1994 = (SWord16) (s1993 >> 16);-  const SWord8  s1995 = (SWord8) s1994;-  const SWord32 s1996 = table3[s1995];-  const SWord32 s1997 = s1942 ^ s1996;-  const SWord8  s1998 = (SWord8) (s1945 >> 8);-  const SWord32 s1999 = table1[s1998];-  const SWord16 s2000 = (SWord16) (s1897 >> 16);-  const SWord8  s2001 = (SWord8) s2000;-  const SWord32 s2002 = table3[s2001];-  const SWord32 s2003 = s1999 ^ s2002;-  const SWord8  s2004 = (SWord8) (s1952 >> 8);-  const SWord32 s2005 = table4[s2004];-  const SWord32 s2006 = s2003 ^ s2005;-  const SWord16 s2007 = (SWord16) s1789;-  const SWord8  s2008 = (SWord8) s2007;-  const SWord32 s2009 = table5[s2008];-  const SWord32 s2010 = s2006 ^ s2009;-  const SWord16 s2011 = (SWord16) (s651 >> 16);-  const SWord8  s2012 = (SWord8) (s2011 >> 8);-  const SWord8  s2013 = table6[s2012];-  const SWord8  s2014 = (SWord8) s2011;-  const SWord8  s2015 = table7[s2014];-  const SWord16 s2016 = (SWord16) s651;-  const SWord8  s2017 = (SWord8) (s2016 >> 8);-  const SWord8  s2018 = table8[s2017];-  const SWord8  s2019 = (SWord8) s2016;-  const SWord8  s2020 = table9[s2019];-  const SWord8  s2021 = s2018 ^ s2020;-  const SWord8  s2022 = s2015 ^ s2021;-  const SWord8  s2023 = s2013 ^ s2022;-  const SWord8  s2024 = table9[s2012];-  const SWord8  s2025 = table6[s2014];-  const SWord8  s2026 = table7[s2017];-  const SWord8  s2027 = table8[s2019];-  const SWord8  s2028 = s2026 ^ s2027;-  const SWord8  s2029 = s2025 ^ s2028;-  const SWord8  s2030 = s2024 ^ s2029;-  const SWord16 s2031 = (((SWord16) s2023) << 8) | ((SWord16) s2030);-  const SWord8  s2032 = table8[s2012];-  const SWord8  s2033 = table9[s2014];-  const SWord8  s2034 = table6[s2017];-  const SWord8  s2035 = table7[s2019];-  const SWord8  s2036 = s2034 ^ s2035;-  const SWord8  s2037 = s2033 ^ s2036;-  const SWord8  s2038 = s2032 ^ s2037;-  const SWord8  s2039 = table7[s2012];-  const SWord8  s2040 = table8[s2014];-  const SWord8  s2041 = table9[s2017];-  const SWord8  s2042 = table6[s2019];-  const SWord8  s2043 = s2041 ^ s2042;-  const SWord8  s2044 = s2040 ^ s2043;-  const SWord8  s2045 = s2039 ^ s2044;-  const SWord16 s2046 = (((SWord16) s2038) << 8) | ((SWord16) s2045);-  const SWord32 s2047 = (((SWord32) s2031) << 16) | ((SWord32) s2046);-  const SWord32 s2048 = s2010 ^ s2047;-  const SWord16 s2049 = (SWord16) s2048;-  const SWord8  s2050 = (SWord8) (s2049 >> 8);-  const SWord32 s2051 = table4[s2050];-  const SWord32 s2052 = s1997 ^ s2051;-  const SWord8  s2053 = (SWord8) (s2000 >> 8);-  const SWord32 s2054 = table1[s2053];-  const SWord8  s2055 = (SWord8) s1736;-  const SWord32 s2056 = table3[s2055];-  const SWord32 s2057 = s2054 ^ s2056;-  const SWord8  s2058 = (SWord8) (s2007 >> 8);-  const SWord32 s2059 = table4[s2058];-  const SWord32 s2060 = s2057 ^ s2059;-  const SWord8  s2061 = (SWord8) s1845;-  const SWord32 s2062 = table5[s2061];-  const SWord32 s2063 = s2060 ^ s2062;-  const SWord16 s2064 = (SWord16) (s650 >> 16);-  const SWord8  s2065 = (SWord8) (s2064 >> 8);-  const SWord8  s2066 = table6[s2065];-  const SWord8  s2067 = (SWord8) s2064;-  const SWord8  s2068 = table7[s2067];-  const SWord16 s2069 = (SWord16) s650;-  const SWord8  s2070 = (SWord8) (s2069 >> 8);-  const SWord8  s2071 = table8[s2070];-  const SWord8  s2072 = (SWord8) s2069;-  const SWord8  s2073 = table9[s2072];-  const SWord8  s2074 = s2071 ^ s2073;-  const SWord8  s2075 = s2068 ^ s2074;-  const SWord8  s2076 = s2066 ^ s2075;-  const SWord8  s2077 = table9[s2065];-  const SWord8  s2078 = table6[s2067];-  const SWord8  s2079 = table7[s2070];-  const SWord8  s2080 = table8[s2072];-  const SWord8  s2081 = s2079 ^ s2080;-  const SWord8  s2082 = s2078 ^ s2081;-  const SWord8  s2083 = s2077 ^ s2082;-  const SWord16 s2084 = (((SWord16) s2076) << 8) | ((SWord16) s2083);-  const SWord8  s2085 = table8[s2065];-  const SWord8  s2086 = table9[s2067];-  const SWord8  s2087 = table6[s2070];-  const SWord8  s2088 = table7[s2072];-  const SWord8  s2089 = s2087 ^ s2088;-  const SWord8  s2090 = s2086 ^ s2089;-  const SWord8  s2091 = s2085 ^ s2090;-  const SWord8  s2092 = table7[s2065];-  const SWord8  s2093 = table8[s2067];-  const SWord8  s2094 = table9[s2070];-  const SWord8  s2095 = table6[s2072];-  const SWord8  s2096 = s2094 ^ s2095;-  const SWord8  s2097 = s2093 ^ s2096;-  const SWord8  s2098 = s2092 ^ s2097;-  const SWord16 s2099 = (((SWord16) s2091) << 8) | ((SWord16) s2098);-  const SWord32 s2100 = (((SWord32) s2084) << 16) | ((SWord32) s2099);-  const SWord32 s2101 = s2063 ^ s2100;-  const SWord16 s2102 = (SWord16) s2101;-  const SWord8  s2103 = (SWord8) s2102;-  const SWord32 s2104 = table5[s2103];-  const SWord32 s2105 = s2052 ^ s2104;-  const SWord16 s2106 = (SWord16) (s630 >> 16);-  const SWord8  s2107 = (SWord8) (s2106 >> 8);-  const SWord8  s2108 = table6[s2107];-  const SWord8  s2109 = (SWord8) s2106;-  const SWord8  s2110 = table7[s2109];-  const SWord16 s2111 = (SWord16) s630;-  const SWord8  s2112 = (SWord8) (s2111 >> 8);-  const SWord8  s2113 = table8[s2112];-  const SWord8  s2114 = (SWord8) s2111;-  const SWord8  s2115 = table9[s2114];-  const SWord8  s2116 = s2113 ^ s2115;-  const SWord8  s2117 = s2110 ^ s2116;-  const SWord8  s2118 = s2108 ^ s2117;-  const SWord8  s2119 = table9[s2107];-  const SWord8  s2120 = table6[s2109];-  const SWord8  s2121 = table7[s2112];-  const SWord8  s2122 = table8[s2114];-  const SWord8  s2123 = s2121 ^ s2122;-  const SWord8  s2124 = s2120 ^ s2123;-  const SWord8  s2125 = s2119 ^ s2124;-  const SWord16 s2126 = (((SWord16) s2118) << 8) | ((SWord16) s2125);-  const SWord8  s2127 = table8[s2107];-  const SWord8  s2128 = table9[s2109];-  const SWord8  s2129 = table6[s2112];-  const SWord8  s2130 = table7[s2114];-  const SWord8  s2131 = s2129 ^ s2130;-  const SWord8  s2132 = s2128 ^ s2131;-  const SWord8  s2133 = s2127 ^ s2132;-  const SWord8  s2134 = table7[s2107];-  const SWord8  s2135 = table8[s2109];-  const SWord8  s2136 = table9[s2112];-  const SWord8  s2137 = table6[s2114];-  const SWord8  s2138 = s2136 ^ s2137;-  const SWord8  s2139 = s2135 ^ s2138;-  const SWord8  s2140 = s2134 ^ s2139;-  const SWord16 s2141 = (((SWord16) s2133) << 8) | ((SWord16) s2140);-  const SWord32 s2142 = (((SWord32) s2126) << 16) | ((SWord32) s2141);-  const SWord32 s2143 = s2105 ^ s2142;-  const SWord16 s2144 = (SWord16) (s2143 >> 16);-  const SWord8  s2145 = (SWord8) (s2144 >> 8);-  const SWord32 s2146 = table1[s2145];-  const SWord8  s2147 = (SWord8) (s1994 >> 8);-  const SWord32 s2148 = table1[s2147];-  const SWord16 s2149 = (SWord16) (s2048 >> 16);-  const SWord8  s2150 = (SWord8) s2149;-  const SWord32 s2151 = table3[s2150];-  const SWord32 s2152 = s2148 ^ s2151;-  const SWord8  s2153 = (SWord8) (s2102 >> 8);-  const SWord32 s2154 = table4[s2153];-  const SWord32 s2155 = s2152 ^ s2154;-  const SWord16 s2156 = (SWord16) s1939;-  const SWord8  s2157 = (SWord8) s2156;-  const SWord32 s2158 = table5[s2157];-  const SWord32 s2159 = s2155 ^ s2158;-  const SWord16 s2160 = (SWord16) (s633 >> 16);-  const SWord8  s2161 = (SWord8) (s2160 >> 8);-  const SWord8  s2162 = table6[s2161];-  const SWord8  s2163 = (SWord8) s2160;-  const SWord8  s2164 = table7[s2163];-  const SWord16 s2165 = (SWord16) s633;-  const SWord8  s2166 = (SWord8) (s2165 >> 8);-  const SWord8  s2167 = table8[s2166];-  const SWord8  s2168 = (SWord8) s2165;-  const SWord8  s2169 = table9[s2168];-  const SWord8  s2170 = s2167 ^ s2169;-  const SWord8  s2171 = s2164 ^ s2170;-  const SWord8  s2172 = s2162 ^ s2171;-  const SWord8  s2173 = table9[s2161];-  const SWord8  s2174 = table6[s2163];-  const SWord8  s2175 = table7[s2166];-  const SWord8  s2176 = table8[s2168];-  const SWord8  s2177 = s2175 ^ s2176;-  const SWord8  s2178 = s2174 ^ s2177;-  const SWord8  s2179 = s2173 ^ s2178;-  const SWord16 s2180 = (((SWord16) s2172) << 8) | ((SWord16) s2179);-  const SWord8  s2181 = table8[s2161];-  const SWord8  s2182 = table9[s2163];-  const SWord8  s2183 = table6[s2166];-  const SWord8  s2184 = table7[s2168];-  const SWord8  s2185 = s2183 ^ s2184;-  const SWord8  s2186 = s2182 ^ s2185;-  const SWord8  s2187 = s2181 ^ s2186;-  const SWord8  s2188 = table7[s2161];-  const SWord8  s2189 = table8[s2163];-  const SWord8  s2190 = table9[s2166];-  const SWord8  s2191 = table6[s2168];-  const SWord8  s2192 = s2190 ^ s2191;-  const SWord8  s2193 = s2189 ^ s2192;-  const SWord8  s2194 = s2188 ^ s2193;-  const SWord16 s2195 = (((SWord16) s2187) << 8) | ((SWord16) s2194);-  const SWord32 s2196 = (((SWord32) s2180) << 16) | ((SWord32) s2195);-  const SWord32 s2197 = s2159 ^ s2196;-  const SWord16 s2198 = (SWord16) (s2197 >> 16);-  const SWord8  s2199 = (SWord8) s2198;-  const SWord32 s2200 = table3[s2199];-  const SWord32 s2201 = s2146 ^ s2200;-  const SWord8  s2202 = (SWord8) (s2149 >> 8);-  const SWord32 s2203 = table1[s2202];-  const SWord16 s2204 = (SWord16) (s2101 >> 16);-  const SWord8  s2205 = (SWord8) s2204;-  const SWord32 s2206 = table3[s2205];-  const SWord32 s2207 = s2203 ^ s2206;-  const SWord8  s2208 = (SWord8) (s2156 >> 8);-  const SWord32 s2209 = table4[s2208];-  const SWord32 s2210 = s2207 ^ s2209;-  const SWord16 s2211 = (SWord16) s1993;-  const SWord8  s2212 = (SWord8) s2211;-  const SWord32 s2213 = table5[s2212];-  const SWord32 s2214 = s2210 ^ s2213;-  const SWord16 s2215 = (SWord16) (s632 >> 16);-  const SWord8  s2216 = (SWord8) (s2215 >> 8);-  const SWord8  s2217 = table6[s2216];-  const SWord8  s2218 = (SWord8) s2215;-  const SWord8  s2219 = table7[s2218];-  const SWord16 s2220 = (SWord16) s632;-  const SWord8  s2221 = (SWord8) (s2220 >> 8);-  const SWord8  s2222 = table8[s2221];-  const SWord8  s2223 = (SWord8) s2220;-  const SWord8  s2224 = table9[s2223];-  const SWord8  s2225 = s2222 ^ s2224;-  const SWord8  s2226 = s2219 ^ s2225;-  const SWord8  s2227 = s2217 ^ s2226;-  const SWord8  s2228 = table9[s2216];-  const SWord8  s2229 = table6[s2218];-  const SWord8  s2230 = table7[s2221];-  const SWord8  s2231 = table8[s2223];-  const SWord8  s2232 = s2230 ^ s2231;-  const SWord8  s2233 = s2229 ^ s2232;-  const SWord8  s2234 = s2228 ^ s2233;-  const SWord16 s2235 = (((SWord16) s2227) << 8) | ((SWord16) s2234);-  const SWord8  s2236 = table8[s2216];-  const SWord8  s2237 = table9[s2218];-  const SWord8  s2238 = table6[s2221];-  const SWord8  s2239 = table7[s2223];-  const SWord8  s2240 = s2238 ^ s2239;-  const SWord8  s2241 = s2237 ^ s2240;-  const SWord8  s2242 = s2236 ^ s2241;-  const SWord8  s2243 = table7[s2216];-  const SWord8  s2244 = table8[s2218];-  const SWord8  s2245 = table9[s2221];-  const SWord8  s2246 = table6[s2223];-  const SWord8  s2247 = s2245 ^ s2246;-  const SWord8  s2248 = s2244 ^ s2247;-  const SWord8  s2249 = s2243 ^ s2248;-  const SWord16 s2250 = (((SWord16) s2242) << 8) | ((SWord16) s2249);-  const SWord32 s2251 = (((SWord32) s2235) << 16) | ((SWord32) s2250);-  const SWord32 s2252 = s2214 ^ s2251;-  const SWord16 s2253 = (SWord16) s2252;-  const SWord8  s2254 = (SWord8) (s2253 >> 8);-  const SWord32 s2255 = table4[s2254];-  const SWord32 s2256 = s2201 ^ s2255;-  const SWord8  s2257 = (SWord8) (s2204 >> 8);-  const SWord32 s2258 = table1[s2257];-  const SWord8  s2259 = (SWord8) s1940;-  const SWord32 s2260 = table3[s2259];-  const SWord32 s2261 = s2258 ^ s2260;-  const SWord8  s2262 = (SWord8) (s2211 >> 8);-  const SWord32 s2263 = table4[s2262];-  const SWord32 s2264 = s2261 ^ s2263;-  const SWord8  s2265 = (SWord8) s2049;-  const SWord32 s2266 = table5[s2265];-  const SWord32 s2267 = s2264 ^ s2266;-  const SWord16 s2268 = (SWord16) (s631 >> 16);-  const SWord8  s2269 = (SWord8) (s2268 >> 8);-  const SWord8  s2270 = table6[s2269];-  const SWord8  s2271 = (SWord8) s2268;-  const SWord8  s2272 = table7[s2271];-  const SWord16 s2273 = (SWord16) s631;-  const SWord8  s2274 = (SWord8) (s2273 >> 8);-  const SWord8  s2275 = table8[s2274];-  const SWord8  s2276 = (SWord8) s2273;-  const SWord8  s2277 = table9[s2276];-  const SWord8  s2278 = s2275 ^ s2277;-  const SWord8  s2279 = s2272 ^ s2278;-  const SWord8  s2280 = s2270 ^ s2279;-  const SWord8  s2281 = table9[s2269];-  const SWord8  s2282 = table6[s2271];-  const SWord8  s2283 = table7[s2274];-  const SWord8  s2284 = table8[s2276];-  const SWord8  s2285 = s2283 ^ s2284;-  const SWord8  s2286 = s2282 ^ s2285;-  const SWord8  s2287 = s2281 ^ s2286;-  const SWord16 s2288 = (((SWord16) s2280) << 8) | ((SWord16) s2287);-  const SWord8  s2289 = table8[s2269];-  const SWord8  s2290 = table9[s2271];-  const SWord8  s2291 = table6[s2274];-  const SWord8  s2292 = table7[s2276];-  const SWord8  s2293 = s2291 ^ s2292;-  const SWord8  s2294 = s2290 ^ s2293;-  const SWord8  s2295 = s2289 ^ s2294;-  const SWord8  s2296 = table7[s2269];-  const SWord8  s2297 = table8[s2271];-  const SWord8  s2298 = table9[s2274];-  const SWord8  s2299 = table6[s2276];-  const SWord8  s2300 = s2298 ^ s2299;-  const SWord8  s2301 = s2297 ^ s2300;-  const SWord8  s2302 = s2296 ^ s2301;-  const SWord16 s2303 = (((SWord16) s2295) << 8) | ((SWord16) s2302);-  const SWord32 s2304 = (((SWord32) s2288) << 16) | ((SWord32) s2303);-  const SWord32 s2305 = s2267 ^ s2304;-  const SWord16 s2306 = (SWord16) s2305;-  const SWord8  s2307 = (SWord8) s2306;-  const SWord32 s2308 = table5[s2307];-  const SWord32 s2309 = s2256 ^ s2308;-  const SWord16 s2310 = (SWord16) (s611 >> 16);-  const SWord8  s2311 = (SWord8) (s2310 >> 8);-  const SWord8  s2312 = table6[s2311];-  const SWord8  s2313 = (SWord8) s2310;-  const SWord8  s2314 = table7[s2313];-  const SWord16 s2315 = (SWord16) s611;-  const SWord8  s2316 = (SWord8) (s2315 >> 8);-  const SWord8  s2317 = table8[s2316];-  const SWord8  s2318 = (SWord8) s2315;-  const SWord8  s2319 = table9[s2318];-  const SWord8  s2320 = s2317 ^ s2319;-  const SWord8  s2321 = s2314 ^ s2320;-  const SWord8  s2322 = s2312 ^ s2321;-  const SWord8  s2323 = table9[s2311];-  const SWord8  s2324 = table6[s2313];-  const SWord8  s2325 = table7[s2316];-  const SWord8  s2326 = table8[s2318];-  const SWord8  s2327 = s2325 ^ s2326;-  const SWord8  s2328 = s2324 ^ s2327;-  const SWord8  s2329 = s2323 ^ s2328;-  const SWord16 s2330 = (((SWord16) s2322) << 8) | ((SWord16) s2329);-  const SWord8  s2331 = table8[s2311];-  const SWord8  s2332 = table9[s2313];-  const SWord8  s2333 = table6[s2316];-  const SWord8  s2334 = table7[s2318];-  const SWord8  s2335 = s2333 ^ s2334;-  const SWord8  s2336 = s2332 ^ s2335;-  const SWord8  s2337 = s2331 ^ s2336;-  const SWord8  s2338 = table7[s2311];-  const SWord8  s2339 = table8[s2313];-  const SWord8  s2340 = table9[s2316];-  const SWord8  s2341 = table6[s2318];-  const SWord8  s2342 = s2340 ^ s2341;-  const SWord8  s2343 = s2339 ^ s2342;-  const SWord8  s2344 = s2338 ^ s2343;-  const SWord16 s2345 = (((SWord16) s2337) << 8) | ((SWord16) s2344);-  const SWord32 s2346 = (((SWord32) s2330) << 16) | ((SWord32) s2345);-  const SWord32 s2347 = s2309 ^ s2346;-  const SWord16 s2348 = (SWord16) (s2347 >> 16);-  const SWord8  s2349 = (SWord8) (s2348 >> 8);-  const SWord32 s2350 = table1[s2349];-  const SWord8  s2351 = (SWord8) (s2198 >> 8);-  const SWord32 s2352 = table1[s2351];-  const SWord16 s2353 = (SWord16) (s2252 >> 16);-  const SWord8  s2354 = (SWord8) s2353;-  const SWord32 s2355 = table3[s2354];-  const SWord32 s2356 = s2352 ^ s2355;-  const SWord8  s2357 = (SWord8) (s2306 >> 8);-  const SWord32 s2358 = table4[s2357];-  const SWord32 s2359 = s2356 ^ s2358;-  const SWord16 s2360 = (SWord16) s2143;-  const SWord8  s2361 = (SWord8) s2360;-  const SWord32 s2362 = table5[s2361];-  const SWord32 s2363 = s2359 ^ s2362;-  const SWord16 s2364 = (SWord16) (s614 >> 16);-  const SWord8  s2365 = (SWord8) (s2364 >> 8);-  const SWord8  s2366 = table6[s2365];-  const SWord8  s2367 = (SWord8) s2364;-  const SWord8  s2368 = table7[s2367];-  const SWord16 s2369 = (SWord16) s614;-  const SWord8  s2370 = (SWord8) (s2369 >> 8);-  const SWord8  s2371 = table8[s2370];-  const SWord8  s2372 = (SWord8) s2369;-  const SWord8  s2373 = table9[s2372];-  const SWord8  s2374 = s2371 ^ s2373;-  const SWord8  s2375 = s2368 ^ s2374;-  const SWord8  s2376 = s2366 ^ s2375;-  const SWord8  s2377 = table9[s2365];-  const SWord8  s2378 = table6[s2367];-  const SWord8  s2379 = table7[s2370];-  const SWord8  s2380 = table8[s2372];-  const SWord8  s2381 = s2379 ^ s2380;-  const SWord8  s2382 = s2378 ^ s2381;-  const SWord8  s2383 = s2377 ^ s2382;-  const SWord16 s2384 = (((SWord16) s2376) << 8) | ((SWord16) s2383);-  const SWord8  s2385 = table8[s2365];-  const SWord8  s2386 = table9[s2367];-  const SWord8  s2387 = table6[s2370];-  const SWord8  s2388 = table7[s2372];-  const SWord8  s2389 = s2387 ^ s2388;-  const SWord8  s2390 = s2386 ^ s2389;-  const SWord8  s2391 = s2385 ^ s2390;-  const SWord8  s2392 = table7[s2365];-  const SWord8  s2393 = table8[s2367];-  const SWord8  s2394 = table9[s2370];-  const SWord8  s2395 = table6[s2372];-  const SWord8  s2396 = s2394 ^ s2395;-  const SWord8  s2397 = s2393 ^ s2396;-  const SWord8  s2398 = s2392 ^ s2397;-  const SWord16 s2399 = (((SWord16) s2391) << 8) | ((SWord16) s2398);-  const SWord32 s2400 = (((SWord32) s2384) << 16) | ((SWord32) s2399);-  const SWord32 s2401 = s2363 ^ s2400;-  const SWord16 s2402 = (SWord16) (s2401 >> 16);-  const SWord8  s2403 = (SWord8) s2402;-  const SWord32 s2404 = table3[s2403];-  const SWord32 s2405 = s2350 ^ s2404;-  const SWord8  s2406 = (SWord8) (s2353 >> 8);-  const SWord32 s2407 = table1[s2406];-  const SWord16 s2408 = (SWord16) (s2305 >> 16);-  const SWord8  s2409 = (SWord8) s2408;-  const SWord32 s2410 = table3[s2409];-  const SWord32 s2411 = s2407 ^ s2410;-  const SWord8  s2412 = (SWord8) (s2360 >> 8);-  const SWord32 s2413 = table4[s2412];-  const SWord32 s2414 = s2411 ^ s2413;-  const SWord16 s2415 = (SWord16) s2197;-  const SWord8  s2416 = (SWord8) s2415;-  const SWord32 s2417 = table5[s2416];-  const SWord32 s2418 = s2414 ^ s2417;-  const SWord16 s2419 = (SWord16) (s613 >> 16);-  const SWord8  s2420 = (SWord8) (s2419 >> 8);-  const SWord8  s2421 = table6[s2420];-  const SWord8  s2422 = (SWord8) s2419;-  const SWord8  s2423 = table7[s2422];-  const SWord16 s2424 = (SWord16) s613;-  const SWord8  s2425 = (SWord8) (s2424 >> 8);-  const SWord8  s2426 = table8[s2425];-  const SWord8  s2427 = (SWord8) s2424;-  const SWord8  s2428 = table9[s2427];-  const SWord8  s2429 = s2426 ^ s2428;-  const SWord8  s2430 = s2423 ^ s2429;-  const SWord8  s2431 = s2421 ^ s2430;-  const SWord8  s2432 = table9[s2420];-  const SWord8  s2433 = table6[s2422];-  const SWord8  s2434 = table7[s2425];-  const SWord8  s2435 = table8[s2427];-  const SWord8  s2436 = s2434 ^ s2435;-  const SWord8  s2437 = s2433 ^ s2436;-  const SWord8  s2438 = s2432 ^ s2437;-  const SWord16 s2439 = (((SWord16) s2431) << 8) | ((SWord16) s2438);-  const SWord8  s2440 = table8[s2420];-  const SWord8  s2441 = table9[s2422];-  const SWord8  s2442 = table6[s2425];-  const SWord8  s2443 = table7[s2427];-  const SWord8  s2444 = s2442 ^ s2443;-  const SWord8  s2445 = s2441 ^ s2444;-  const SWord8  s2446 = s2440 ^ s2445;-  const SWord8  s2447 = table7[s2420];-  const SWord8  s2448 = table8[s2422];-  const SWord8  s2449 = table9[s2425];-  const SWord8  s2450 = table6[s2427];-  const SWord8  s2451 = s2449 ^ s2450;-  const SWord8  s2452 = s2448 ^ s2451;-  const SWord8  s2453 = s2447 ^ s2452;-  const SWord16 s2454 = (((SWord16) s2446) << 8) | ((SWord16) s2453);-  const SWord32 s2455 = (((SWord32) s2439) << 16) | ((SWord32) s2454);-  const SWord32 s2456 = s2418 ^ s2455;-  const SWord16 s2457 = (SWord16) s2456;-  const SWord8  s2458 = (SWord8) (s2457 >> 8);-  const SWord32 s2459 = table4[s2458];-  const SWord32 s2460 = s2405 ^ s2459;-  const SWord8  s2461 = (SWord8) (s2408 >> 8);-  const SWord32 s2462 = table1[s2461];-  const SWord8  s2463 = (SWord8) s2144;-  const SWord32 s2464 = table3[s2463];-  const SWord32 s2465 = s2462 ^ s2464;-  const SWord8  s2466 = (SWord8) (s2415 >> 8);-  const SWord32 s2467 = table4[s2466];-  const SWord32 s2468 = s2465 ^ s2467;-  const SWord8  s2469 = (SWord8) s2253;-  const SWord32 s2470 = table5[s2469];-  const SWord32 s2471 = s2468 ^ s2470;-  const SWord16 s2472 = (SWord16) (s612 >> 16);-  const SWord8  s2473 = (SWord8) (s2472 >> 8);-  const SWord8  s2474 = table6[s2473];-  const SWord8  s2475 = (SWord8) s2472;-  const SWord8  s2476 = table7[s2475];-  const SWord16 s2477 = (SWord16) s612;-  const SWord8  s2478 = (SWord8) (s2477 >> 8);-  const SWord8  s2479 = table8[s2478];-  const SWord8  s2480 = (SWord8) s2477;-  const SWord8  s2481 = table9[s2480];-  const SWord8  s2482 = s2479 ^ s2481;-  const SWord8  s2483 = s2476 ^ s2482;-  const SWord8  s2484 = s2474 ^ s2483;-  const SWord8  s2485 = table9[s2473];-  const SWord8  s2486 = table6[s2475];-  const SWord8  s2487 = table7[s2478];-  const SWord8  s2488 = table8[s2480];-  const SWord8  s2489 = s2487 ^ s2488;-  const SWord8  s2490 = s2486 ^ s2489;-  const SWord8  s2491 = s2485 ^ s2490;-  const SWord16 s2492 = (((SWord16) s2484) << 8) | ((SWord16) s2491);-  const SWord8  s2493 = table8[s2473];-  const SWord8  s2494 = table9[s2475];-  const SWord8  s2495 = table6[s2478];-  const SWord8  s2496 = table7[s2480];-  const SWord8  s2497 = s2495 ^ s2496;-  const SWord8  s2498 = s2494 ^ s2497;-  const SWord8  s2499 = s2493 ^ s2498;-  const SWord8  s2500 = table7[s2473];-  const SWord8  s2501 = table8[s2475];-  const SWord8  s2502 = table9[s2478];-  const SWord8  s2503 = table6[s2480];-  const SWord8  s2504 = s2502 ^ s2503;-  const SWord8  s2505 = s2501 ^ s2504;-  const SWord8  s2506 = s2500 ^ s2505;-  const SWord16 s2507 = (((SWord16) s2499) << 8) | ((SWord16) s2506);-  const SWord32 s2508 = (((SWord32) s2492) << 16) | ((SWord32) s2507);-  const SWord32 s2509 = s2471 ^ s2508;-  const SWord16 s2510 = (SWord16) s2509;-  const SWord8  s2511 = (SWord8) s2510;-  const SWord32 s2512 = table5[s2511];-  const SWord32 s2513 = s2460 ^ s2512;-  const SWord16 s2514 = (SWord16) (s592 >> 16);-  const SWord8  s2515 = (SWord8) (s2514 >> 8);-  const SWord8  s2516 = table6[s2515];-  const SWord8  s2517 = (SWord8) s2514;-  const SWord8  s2518 = table7[s2517];-  const SWord16 s2519 = (SWord16) s592;-  const SWord8  s2520 = (SWord8) (s2519 >> 8);-  const SWord8  s2521 = table8[s2520];-  const SWord8  s2522 = (SWord8) s2519;-  const SWord8  s2523 = table9[s2522];-  const SWord8  s2524 = s2521 ^ s2523;-  const SWord8  s2525 = s2518 ^ s2524;-  const SWord8  s2526 = s2516 ^ s2525;-  const SWord8  s2527 = table9[s2515];-  const SWord8  s2528 = table6[s2517];-  const SWord8  s2529 = table7[s2520];-  const SWord8  s2530 = table8[s2522];-  const SWord8  s2531 = s2529 ^ s2530;-  const SWord8  s2532 = s2528 ^ s2531;-  const SWord8  s2533 = s2527 ^ s2532;-  const SWord16 s2534 = (((SWord16) s2526) << 8) | ((SWord16) s2533);-  const SWord8  s2535 = table8[s2515];-  const SWord8  s2536 = table9[s2517];-  const SWord8  s2537 = table6[s2520];-  const SWord8  s2538 = table7[s2522];-  const SWord8  s2539 = s2537 ^ s2538;-  const SWord8  s2540 = s2536 ^ s2539;-  const SWord8  s2541 = s2535 ^ s2540;-  const SWord8  s2542 = table7[s2515];-  const SWord8  s2543 = table8[s2517];-  const SWord8  s2544 = table9[s2520];-  const SWord8  s2545 = table6[s2522];-  const SWord8  s2546 = s2544 ^ s2545;-  const SWord8  s2547 = s2543 ^ s2546;-  const SWord8  s2548 = s2542 ^ s2547;-  const SWord16 s2549 = (((SWord16) s2541) << 8) | ((SWord16) s2548);-  const SWord32 s2550 = (((SWord32) s2534) << 16) | ((SWord32) s2549);-  const SWord32 s2551 = s2513 ^ s2550;-  const SWord16 s2552 = (SWord16) (s2551 >> 16);-  const SWord8  s2553 = (SWord8) (s2552 >> 8);-  const SWord32 s2554 = table1[s2553];-  const SWord8  s2555 = (SWord8) (s2402 >> 8);-  const SWord32 s2556 = table1[s2555];-  const SWord16 s2557 = (SWord16) (s2456 >> 16);-  const SWord8  s2558 = (SWord8) s2557;-  const SWord32 s2559 = table3[s2558];-  const SWord32 s2560 = s2556 ^ s2559;-  const SWord8  s2561 = (SWord8) (s2510 >> 8);-  const SWord32 s2562 = table4[s2561];-  const SWord32 s2563 = s2560 ^ s2562;-  const SWord16 s2564 = (SWord16) s2347;-  const SWord8  s2565 = (SWord8) s2564;-  const SWord32 s2566 = table5[s2565];-  const SWord32 s2567 = s2563 ^ s2566;-  const SWord16 s2568 = (SWord16) (s595 >> 16);-  const SWord8  s2569 = (SWord8) (s2568 >> 8);-  const SWord8  s2570 = table6[s2569];-  const SWord8  s2571 = (SWord8) s2568;-  const SWord8  s2572 = table7[s2571];-  const SWord16 s2573 = (SWord16) s595;-  const SWord8  s2574 = (SWord8) (s2573 >> 8);-  const SWord8  s2575 = table8[s2574];-  const SWord8  s2576 = (SWord8) s2573;-  const SWord8  s2577 = table9[s2576];-  const SWord8  s2578 = s2575 ^ s2577;-  const SWord8  s2579 = s2572 ^ s2578;-  const SWord8  s2580 = s2570 ^ s2579;-  const SWord8  s2581 = table9[s2569];-  const SWord8  s2582 = table6[s2571];-  const SWord8  s2583 = table7[s2574];-  const SWord8  s2584 = table8[s2576];-  const SWord8  s2585 = s2583 ^ s2584;-  const SWord8  s2586 = s2582 ^ s2585;-  const SWord8  s2587 = s2581 ^ s2586;-  const SWord16 s2588 = (((SWord16) s2580) << 8) | ((SWord16) s2587);-  const SWord8  s2589 = table8[s2569];-  const SWord8  s2590 = table9[s2571];-  const SWord8  s2591 = table6[s2574];-  const SWord8  s2592 = table7[s2576];-  const SWord8  s2593 = s2591 ^ s2592;-  const SWord8  s2594 = s2590 ^ s2593;-  const SWord8  s2595 = s2589 ^ s2594;-  const SWord8  s2596 = table7[s2569];-  const SWord8  s2597 = table8[s2571];-  const SWord8  s2598 = table9[s2574];-  const SWord8  s2599 = table6[s2576];-  const SWord8  s2600 = s2598 ^ s2599;-  const SWord8  s2601 = s2597 ^ s2600;-  const SWord8  s2602 = s2596 ^ s2601;-  const SWord16 s2603 = (((SWord16) s2595) << 8) | ((SWord16) s2602);-  const SWord32 s2604 = (((SWord32) s2588) << 16) | ((SWord32) s2603);-  const SWord32 s2605 = s2567 ^ s2604;-  const SWord16 s2606 = (SWord16) (s2605 >> 16);-  const SWord8  s2607 = (SWord8) s2606;-  const SWord32 s2608 = table3[s2607];-  const SWord32 s2609 = s2554 ^ s2608;-  const SWord8  s2610 = (SWord8) (s2557 >> 8);-  const SWord32 s2611 = table1[s2610];-  const SWord16 s2612 = (SWord16) (s2509 >> 16);-  const SWord8  s2613 = (SWord8) s2612;-  const SWord32 s2614 = table3[s2613];-  const SWord32 s2615 = s2611 ^ s2614;-  const SWord8  s2616 = (SWord8) (s2564 >> 8);-  const SWord32 s2617 = table4[s2616];-  const SWord32 s2618 = s2615 ^ s2617;-  const SWord16 s2619 = (SWord16) s2401;-  const SWord8  s2620 = (SWord8) s2619;-  const SWord32 s2621 = table5[s2620];-  const SWord32 s2622 = s2618 ^ s2621;-  const SWord16 s2623 = (SWord16) (s594 >> 16);-  const SWord8  s2624 = (SWord8) (s2623 >> 8);-  const SWord8  s2625 = table6[s2624];-  const SWord8  s2626 = (SWord8) s2623;-  const SWord8  s2627 = table7[s2626];-  const SWord16 s2628 = (SWord16) s594;-  const SWord8  s2629 = (SWord8) (s2628 >> 8);-  const SWord8  s2630 = table8[s2629];-  const SWord8  s2631 = (SWord8) s2628;-  const SWord8  s2632 = table9[s2631];-  const SWord8  s2633 = s2630 ^ s2632;-  const SWord8  s2634 = s2627 ^ s2633;-  const SWord8  s2635 = s2625 ^ s2634;-  const SWord8  s2636 = table9[s2624];-  const SWord8  s2637 = table6[s2626];-  const SWord8  s2638 = table7[s2629];-  const SWord8  s2639 = table8[s2631];-  const SWord8  s2640 = s2638 ^ s2639;-  const SWord8  s2641 = s2637 ^ s2640;-  const SWord8  s2642 = s2636 ^ s2641;-  const SWord16 s2643 = (((SWord16) s2635) << 8) | ((SWord16) s2642);-  const SWord8  s2644 = table8[s2624];-  const SWord8  s2645 = table9[s2626];-  const SWord8  s2646 = table6[s2629];-  const SWord8  s2647 = table7[s2631];-  const SWord8  s2648 = s2646 ^ s2647;-  const SWord8  s2649 = s2645 ^ s2648;-  const SWord8  s2650 = s2644 ^ s2649;-  const SWord8  s2651 = table7[s2624];-  const SWord8  s2652 = table8[s2626];-  const SWord8  s2653 = table9[s2629];-  const SWord8  s2654 = table6[s2631];-  const SWord8  s2655 = s2653 ^ s2654;-  const SWord8  s2656 = s2652 ^ s2655;-  const SWord8  s2657 = s2651 ^ s2656;-  const SWord16 s2658 = (((SWord16) s2650) << 8) | ((SWord16) s2657);-  const SWord32 s2659 = (((SWord32) s2643) << 16) | ((SWord32) s2658);-  const SWord32 s2660 = s2622 ^ s2659;-  const SWord16 s2661 = (SWord16) s2660;-  const SWord8  s2662 = (SWord8) (s2661 >> 8);-  const SWord32 s2663 = table4[s2662];-  const SWord32 s2664 = s2609 ^ s2663;-  const SWord8  s2665 = (SWord8) (s2612 >> 8);-  const SWord32 s2666 = table1[s2665];-  const SWord8  s2667 = (SWord8) s2348;-  const SWord32 s2668 = table3[s2667];-  const SWord32 s2669 = s2666 ^ s2668;-  const SWord8  s2670 = (SWord8) (s2619 >> 8);-  const SWord32 s2671 = table4[s2670];-  const SWord32 s2672 = s2669 ^ s2671;-  const SWord8  s2673 = (SWord8) s2457;-  const SWord32 s2674 = table5[s2673];-  const SWord32 s2675 = s2672 ^ s2674;-  const SWord16 s2676 = (SWord16) (s593 >> 16);-  const SWord8  s2677 = (SWord8) (s2676 >> 8);-  const SWord8  s2678 = table6[s2677];-  const SWord8  s2679 = (SWord8) s2676;-  const SWord8  s2680 = table7[s2679];-  const SWord16 s2681 = (SWord16) s593;-  const SWord8  s2682 = (SWord8) (s2681 >> 8);-  const SWord8  s2683 = table8[s2682];-  const SWord8  s2684 = (SWord8) s2681;-  const SWord8  s2685 = table9[s2684];-  const SWord8  s2686 = s2683 ^ s2685;-  const SWord8  s2687 = s2680 ^ s2686;-  const SWord8  s2688 = s2678 ^ s2687;-  const SWord8  s2689 = table9[s2677];-  const SWord8  s2690 = table6[s2679];-  const SWord8  s2691 = table7[s2682];-  const SWord8  s2692 = table8[s2684];-  const SWord8  s2693 = s2691 ^ s2692;-  const SWord8  s2694 = s2690 ^ s2693;-  const SWord8  s2695 = s2689 ^ s2694;-  const SWord16 s2696 = (((SWord16) s2688) << 8) | ((SWord16) s2695);-  const SWord8  s2697 = table8[s2677];-  const SWord8  s2698 = table9[s2679];-  const SWord8  s2699 = table6[s2682];-  const SWord8  s2700 = table7[s2684];-  const SWord8  s2701 = s2699 ^ s2700;-  const SWord8  s2702 = s2698 ^ s2701;-  const SWord8  s2703 = s2697 ^ s2702;-  const SWord8  s2704 = table7[s2677];-  const SWord8  s2705 = table8[s2679];-  const SWord8  s2706 = table9[s2682];-  const SWord8  s2707 = table6[s2684];-  const SWord8  s2708 = s2706 ^ s2707;-  const SWord8  s2709 = s2705 ^ s2708;-  const SWord8  s2710 = s2704 ^ s2709;-  const SWord16 s2711 = (((SWord16) s2703) << 8) | ((SWord16) s2710);-  const SWord32 s2712 = (((SWord32) s2696) << 16) | ((SWord32) s2711);-  const SWord32 s2713 = s2675 ^ s2712;-  const SWord16 s2714 = (SWord16) s2713;-  const SWord8  s2715 = (SWord8) s2714;-  const SWord32 s2716 = table5[s2715];-  const SWord32 s2717 = s2664 ^ s2716;-  const SWord16 s2718 = (SWord16) (s573 >> 16);-  const SWord8  s2719 = (SWord8) (s2718 >> 8);-  const SWord8  s2720 = table6[s2719];-  const SWord8  s2721 = (SWord8) s2718;-  const SWord8  s2722 = table7[s2721];-  const SWord16 s2723 = (SWord16) s573;-  const SWord8  s2724 = (SWord8) (s2723 >> 8);-  const SWord8  s2725 = table8[s2724];-  const SWord8  s2726 = (SWord8) s2723;-  const SWord8  s2727 = table9[s2726];-  const SWord8  s2728 = s2725 ^ s2727;-  const SWord8  s2729 = s2722 ^ s2728;-  const SWord8  s2730 = s2720 ^ s2729;-  const SWord8  s2731 = table9[s2719];-  const SWord8  s2732 = table6[s2721];-  const SWord8  s2733 = table7[s2724];-  const SWord8  s2734 = table8[s2726];-  const SWord8  s2735 = s2733 ^ s2734;-  const SWord8  s2736 = s2732 ^ s2735;-  const SWord8  s2737 = s2731 ^ s2736;-  const SWord16 s2738 = (((SWord16) s2730) << 8) | ((SWord16) s2737);-  const SWord8  s2739 = table8[s2719];-  const SWord8  s2740 = table9[s2721];-  const SWord8  s2741 = table6[s2724];-  const SWord8  s2742 = table7[s2726];-  const SWord8  s2743 = s2741 ^ s2742;-  const SWord8  s2744 = s2740 ^ s2743;-  const SWord8  s2745 = s2739 ^ s2744;-  const SWord8  s2746 = table7[s2719];-  const SWord8  s2747 = table8[s2721];-  const SWord8  s2748 = table9[s2724];-  const SWord8  s2749 = table6[s2726];-  const SWord8  s2750 = s2748 ^ s2749;-  const SWord8  s2751 = s2747 ^ s2750;-  const SWord8  s2752 = s2746 ^ s2751;-  const SWord16 s2753 = (((SWord16) s2745) << 8) | ((SWord16) s2752);-  const SWord32 s2754 = (((SWord32) s2738) << 16) | ((SWord32) s2753);-  const SWord32 s2755 = s2717 ^ s2754;-  const SWord16 s2756 = (SWord16) (s2755 >> 16);-  const SWord8  s2757 = (SWord8) (s2756 >> 8);-  const SWord32 s2758 = table1[s2757];-  const SWord8  s2759 = (SWord8) (s2606 >> 8);-  const SWord32 s2760 = table1[s2759];-  const SWord16 s2761 = (SWord16) (s2660 >> 16);-  const SWord8  s2762 = (SWord8) s2761;-  const SWord32 s2763 = table3[s2762];-  const SWord32 s2764 = s2760 ^ s2763;-  const SWord8  s2765 = (SWord8) (s2714 >> 8);-  const SWord32 s2766 = table4[s2765];-  const SWord32 s2767 = s2764 ^ s2766;-  const SWord16 s2768 = (SWord16) s2551;-  const SWord8  s2769 = (SWord8) s2768;-  const SWord32 s2770 = table5[s2769];-  const SWord32 s2771 = s2767 ^ s2770;-  const SWord16 s2772 = (SWord16) (s576 >> 16);-  const SWord8  s2773 = (SWord8) (s2772 >> 8);-  const SWord8  s2774 = table6[s2773];-  const SWord8  s2775 = (SWord8) s2772;-  const SWord8  s2776 = table7[s2775];-  const SWord16 s2777 = (SWord16) s576;-  const SWord8  s2778 = (SWord8) (s2777 >> 8);-  const SWord8  s2779 = table8[s2778];-  const SWord8  s2780 = (SWord8) s2777;-  const SWord8  s2781 = table9[s2780];-  const SWord8  s2782 = s2779 ^ s2781;-  const SWord8  s2783 = s2776 ^ s2782;-  const SWord8  s2784 = s2774 ^ s2783;-  const SWord8  s2785 = table9[s2773];-  const SWord8  s2786 = table6[s2775];-  const SWord8  s2787 = table7[s2778];-  const SWord8  s2788 = table8[s2780];-  const SWord8  s2789 = s2787 ^ s2788;-  const SWord8  s2790 = s2786 ^ s2789;-  const SWord8  s2791 = s2785 ^ s2790;-  const SWord16 s2792 = (((SWord16) s2784) << 8) | ((SWord16) s2791);-  const SWord8  s2793 = table8[s2773];-  const SWord8  s2794 = table9[s2775];-  const SWord8  s2795 = table6[s2778];-  const SWord8  s2796 = table7[s2780];-  const SWord8  s2797 = s2795 ^ s2796;-  const SWord8  s2798 = s2794 ^ s2797;-  const SWord8  s2799 = s2793 ^ s2798;-  const SWord8  s2800 = table7[s2773];-  const SWord8  s2801 = table8[s2775];-  const SWord8  s2802 = table9[s2778];-  const SWord8  s2803 = table6[s2780];-  const SWord8  s2804 = s2802 ^ s2803;-  const SWord8  s2805 = s2801 ^ s2804;-  const SWord8  s2806 = s2800 ^ s2805;-  const SWord16 s2807 = (((SWord16) s2799) << 8) | ((SWord16) s2806);-  const SWord32 s2808 = (((SWord32) s2792) << 16) | ((SWord32) s2807);-  const SWord32 s2809 = s2771 ^ s2808;-  const SWord16 s2810 = (SWord16) (s2809 >> 16);-  const SWord8  s2811 = (SWord8) s2810;-  const SWord32 s2812 = table3[s2811];-  const SWord32 s2813 = s2758 ^ s2812;-  const SWord8  s2814 = (SWord8) (s2761 >> 8);-  const SWord32 s2815 = table1[s2814];-  const SWord16 s2816 = (SWord16) (s2713 >> 16);-  const SWord8  s2817 = (SWord8) s2816;-  const SWord32 s2818 = table3[s2817];-  const SWord32 s2819 = s2815 ^ s2818;-  const SWord8  s2820 = (SWord8) (s2768 >> 8);-  const SWord32 s2821 = table4[s2820];-  const SWord32 s2822 = s2819 ^ s2821;-  const SWord16 s2823 = (SWord16) s2605;-  const SWord8  s2824 = (SWord8) s2823;-  const SWord32 s2825 = table5[s2824];-  const SWord32 s2826 = s2822 ^ s2825;-  const SWord16 s2827 = (SWord16) (s575 >> 16);-  const SWord8  s2828 = (SWord8) (s2827 >> 8);-  const SWord8  s2829 = table6[s2828];-  const SWord8  s2830 = (SWord8) s2827;-  const SWord8  s2831 = table7[s2830];-  const SWord16 s2832 = (SWord16) s575;-  const SWord8  s2833 = (SWord8) (s2832 >> 8);-  const SWord8  s2834 = table8[s2833];-  const SWord8  s2835 = (SWord8) s2832;-  const SWord8  s2836 = table9[s2835];-  const SWord8  s2837 = s2834 ^ s2836;-  const SWord8  s2838 = s2831 ^ s2837;-  const SWord8  s2839 = s2829 ^ s2838;-  const SWord8  s2840 = table9[s2828];-  const SWord8  s2841 = table6[s2830];-  const SWord8  s2842 = table7[s2833];-  const SWord8  s2843 = table8[s2835];-  const SWord8  s2844 = s2842 ^ s2843;-  const SWord8  s2845 = s2841 ^ s2844;-  const SWord8  s2846 = s2840 ^ s2845;-  const SWord16 s2847 = (((SWord16) s2839) << 8) | ((SWord16) s2846);-  const SWord8  s2848 = table8[s2828];-  const SWord8  s2849 = table9[s2830];-  const SWord8  s2850 = table6[s2833];-  const SWord8  s2851 = table7[s2835];-  const SWord8  s2852 = s2850 ^ s2851;-  const SWord8  s2853 = s2849 ^ s2852;-  const SWord8  s2854 = s2848 ^ s2853;-  const SWord8  s2855 = table7[s2828];-  const SWord8  s2856 = table8[s2830];-  const SWord8  s2857 = table9[s2833];-  const SWord8  s2858 = table6[s2835];-  const SWord8  s2859 = s2857 ^ s2858;-  const SWord8  s2860 = s2856 ^ s2859;-  const SWord8  s2861 = s2855 ^ s2860;-  const SWord16 s2862 = (((SWord16) s2854) << 8) | ((SWord16) s2861);-  const SWord32 s2863 = (((SWord32) s2847) << 16) | ((SWord32) s2862);-  const SWord32 s2864 = s2826 ^ s2863;-  const SWord16 s2865 = (SWord16) s2864;-  const SWord8  s2866 = (SWord8) (s2865 >> 8);-  const SWord32 s2867 = table4[s2866];-  const SWord32 s2868 = s2813 ^ s2867;-  const SWord8  s2869 = (SWord8) (s2816 >> 8);-  const SWord32 s2870 = table1[s2869];-  const SWord8  s2871 = (SWord8) s2552;-  const SWord32 s2872 = table3[s2871];-  const SWord32 s2873 = s2870 ^ s2872;-  const SWord8  s2874 = (SWord8) (s2823 >> 8);-  const SWord32 s2875 = table4[s2874];-  const SWord32 s2876 = s2873 ^ s2875;-  const SWord8  s2877 = (SWord8) s2661;-  const SWord32 s2878 = table5[s2877];-  const SWord32 s2879 = s2876 ^ s2878;-  const SWord16 s2880 = (SWord16) (s574 >> 16);-  const SWord8  s2881 = (SWord8) (s2880 >> 8);-  const SWord8  s2882 = table6[s2881];-  const SWord8  s2883 = (SWord8) s2880;-  const SWord8  s2884 = table7[s2883];-  const SWord16 s2885 = (SWord16) s574;-  const SWord8  s2886 = (SWord8) (s2885 >> 8);-  const SWord8  s2887 = table8[s2886];-  const SWord8  s2888 = (SWord8) s2885;-  const SWord8  s2889 = table9[s2888];-  const SWord8  s2890 = s2887 ^ s2889;-  const SWord8  s2891 = s2884 ^ s2890;-  const SWord8  s2892 = s2882 ^ s2891;-  const SWord8  s2893 = table9[s2881];-  const SWord8  s2894 = table6[s2883];-  const SWord8  s2895 = table7[s2886];-  const SWord8  s2896 = table8[s2888];-  const SWord8  s2897 = s2895 ^ s2896;-  const SWord8  s2898 = s2894 ^ s2897;-  const SWord8  s2899 = s2893 ^ s2898;-  const SWord16 s2900 = (((SWord16) s2892) << 8) | ((SWord16) s2899);-  const SWord8  s2901 = table8[s2881];-  const SWord8  s2902 = table9[s2883];-  const SWord8  s2903 = table6[s2886];-  const SWord8  s2904 = table7[s2888];-  const SWord8  s2905 = s2903 ^ s2904;-  const SWord8  s2906 = s2902 ^ s2905;-  const SWord8  s2907 = s2901 ^ s2906;-  const SWord8  s2908 = table7[s2881];-  const SWord8  s2909 = table8[s2883];-  const SWord8  s2910 = table9[s2886];-  const SWord8  s2911 = table6[s2888];-  const SWord8  s2912 = s2910 ^ s2911;-  const SWord8  s2913 = s2909 ^ s2912;-  const SWord8  s2914 = s2908 ^ s2913;-  const SWord16 s2915 = (((SWord16) s2907) << 8) | ((SWord16) s2914);-  const SWord32 s2916 = (((SWord32) s2900) << 16) | ((SWord32) s2915);-  const SWord32 s2917 = s2879 ^ s2916;-  const SWord16 s2918 = (SWord16) s2917;-  const SWord8  s2919 = (SWord8) s2918;-  const SWord32 s2920 = table5[s2919];-  const SWord32 s2921 = s2868 ^ s2920;-  const SWord16 s2922 = (SWord16) (s554 >> 16);-  const SWord8  s2923 = (SWord8) (s2922 >> 8);-  const SWord8  s2924 = table6[s2923];-  const SWord8  s2925 = (SWord8) s2922;-  const SWord8  s2926 = table7[s2925];-  const SWord16 s2927 = (SWord16) s554;-  const SWord8  s2928 = (SWord8) (s2927 >> 8);-  const SWord8  s2929 = table8[s2928];-  const SWord8  s2930 = (SWord8) s2927;-  const SWord8  s2931 = table9[s2930];-  const SWord8  s2932 = s2929 ^ s2931;-  const SWord8  s2933 = s2926 ^ s2932;-  const SWord8  s2934 = s2924 ^ s2933;-  const SWord8  s2935 = table9[s2923];-  const SWord8  s2936 = table6[s2925];-  const SWord8  s2937 = table7[s2928];-  const SWord8  s2938 = table8[s2930];-  const SWord8  s2939 = s2937 ^ s2938;-  const SWord8  s2940 = s2936 ^ s2939;-  const SWord8  s2941 = s2935 ^ s2940;-  const SWord16 s2942 = (((SWord16) s2934) << 8) | ((SWord16) s2941);-  const SWord8  s2943 = table8[s2923];-  const SWord8  s2944 = table9[s2925];-  const SWord8  s2945 = table6[s2928];-  const SWord8  s2946 = table7[s2930];-  const SWord8  s2947 = s2945 ^ s2946;-  const SWord8  s2948 = s2944 ^ s2947;-  const SWord8  s2949 = s2943 ^ s2948;-  const SWord8  s2950 = table7[s2923];-  const SWord8  s2951 = table8[s2925];-  const SWord8  s2952 = table9[s2928];-  const SWord8  s2953 = table6[s2930];-  const SWord8  s2954 = s2952 ^ s2953;-  const SWord8  s2955 = s2951 ^ s2954;-  const SWord8  s2956 = s2950 ^ s2955;-  const SWord16 s2957 = (((SWord16) s2949) << 8) | ((SWord16) s2956);-  const SWord32 s2958 = (((SWord32) s2942) << 16) | ((SWord32) s2957);-  const SWord32 s2959 = s2921 ^ s2958;-  const SWord16 s2960 = (SWord16) (s2959 >> 16);-  const SWord8  s2961 = (SWord8) (s2960 >> 8);-  const SWord32 s2962 = table1[s2961];-  const SWord8  s2963 = (SWord8) (s2810 >> 8);-  const SWord32 s2964 = table1[s2963];-  const SWord16 s2965 = (SWord16) (s2864 >> 16);-  const SWord8  s2966 = (SWord8) s2965;-  const SWord32 s2967 = table3[s2966];-  const SWord32 s2968 = s2964 ^ s2967;-  const SWord8  s2969 = (SWord8) (s2918 >> 8);-  const SWord32 s2970 = table4[s2969];-  const SWord32 s2971 = s2968 ^ s2970;-  const SWord16 s2972 = (SWord16) s2755;-  const SWord8  s2973 = (SWord8) s2972;-  const SWord32 s2974 = table5[s2973];-  const SWord32 s2975 = s2971 ^ s2974;-  const SWord16 s2976 = (SWord16) (s557 >> 16);-  const SWord8  s2977 = (SWord8) (s2976 >> 8);-  const SWord8  s2978 = table6[s2977];-  const SWord8  s2979 = (SWord8) s2976;-  const SWord8  s2980 = table7[s2979];-  const SWord16 s2981 = (SWord16) s557;-  const SWord8  s2982 = (SWord8) (s2981 >> 8);-  const SWord8  s2983 = table8[s2982];-  const SWord8  s2984 = (SWord8) s2981;-  const SWord8  s2985 = table9[s2984];-  const SWord8  s2986 = s2983 ^ s2985;-  const SWord8  s2987 = s2980 ^ s2986;-  const SWord8  s2988 = s2978 ^ s2987;-  const SWord8  s2989 = table9[s2977];-  const SWord8  s2990 = table6[s2979];-  const SWord8  s2991 = table7[s2982];-  const SWord8  s2992 = table8[s2984];-  const SWord8  s2993 = s2991 ^ s2992;-  const SWord8  s2994 = s2990 ^ s2993;-  const SWord8  s2995 = s2989 ^ s2994;-  const SWord16 s2996 = (((SWord16) s2988) << 8) | ((SWord16) s2995);-  const SWord8  s2997 = table8[s2977];-  const SWord8  s2998 = table9[s2979];-  const SWord8  s2999 = table6[s2982];-  const SWord8  s3000 = table7[s2984];-  const SWord8  s3001 = s2999 ^ s3000;-  const SWord8  s3002 = s2998 ^ s3001;-  const SWord8  s3003 = s2997 ^ s3002;-  const SWord8  s3004 = table7[s2977];-  const SWord8  s3005 = table8[s2979];-  const SWord8  s3006 = table9[s2982];-  const SWord8  s3007 = table6[s2984];-  const SWord8  s3008 = s3006 ^ s3007;-  const SWord8  s3009 = s3005 ^ s3008;-  const SWord8  s3010 = s3004 ^ s3009;-  const SWord16 s3011 = (((SWord16) s3003) << 8) | ((SWord16) s3010);-  const SWord32 s3012 = (((SWord32) s2996) << 16) | ((SWord32) s3011);-  const SWord32 s3013 = s2975 ^ s3012;-  const SWord16 s3014 = (SWord16) (s3013 >> 16);-  const SWord8  s3015 = (SWord8) s3014;-  const SWord32 s3016 = table3[s3015];-  const SWord32 s3017 = s2962 ^ s3016;-  const SWord8  s3018 = (SWord8) (s2965 >> 8);-  const SWord32 s3019 = table1[s3018];-  const SWord16 s3020 = (SWord16) (s2917 >> 16);-  const SWord8  s3021 = (SWord8) s3020;-  const SWord32 s3022 = table3[s3021];-  const SWord32 s3023 = s3019 ^ s3022;-  const SWord8  s3024 = (SWord8) (s2972 >> 8);-  const SWord32 s3025 = table4[s3024];-  const SWord32 s3026 = s3023 ^ s3025;-  const SWord16 s3027 = (SWord16) s2809;-  const SWord8  s3028 = (SWord8) s3027;-  const SWord32 s3029 = table5[s3028];-  const SWord32 s3030 = s3026 ^ s3029;-  const SWord16 s3031 = (SWord16) (s556 >> 16);-  const SWord8  s3032 = (SWord8) (s3031 >> 8);-  const SWord8  s3033 = table6[s3032];-  const SWord8  s3034 = (SWord8) s3031;-  const SWord8  s3035 = table7[s3034];-  const SWord16 s3036 = (SWord16) s556;-  const SWord8  s3037 = (SWord8) (s3036 >> 8);-  const SWord8  s3038 = table8[s3037];-  const SWord8  s3039 = (SWord8) s3036;-  const SWord8  s3040 = table9[s3039];-  const SWord8  s3041 = s3038 ^ s3040;-  const SWord8  s3042 = s3035 ^ s3041;-  const SWord8  s3043 = s3033 ^ s3042;-  const SWord8  s3044 = table9[s3032];-  const SWord8  s3045 = table6[s3034];-  const SWord8  s3046 = table7[s3037];-  const SWord8  s3047 = table8[s3039];-  const SWord8  s3048 = s3046 ^ s3047;-  const SWord8  s3049 = s3045 ^ s3048;-  const SWord8  s3050 = s3044 ^ s3049;-  const SWord16 s3051 = (((SWord16) s3043) << 8) | ((SWord16) s3050);-  const SWord8  s3052 = table8[s3032];-  const SWord8  s3053 = table9[s3034];-  const SWord8  s3054 = table6[s3037];-  const SWord8  s3055 = table7[s3039];-  const SWord8  s3056 = s3054 ^ s3055;-  const SWord8  s3057 = s3053 ^ s3056;-  const SWord8  s3058 = s3052 ^ s3057;-  const SWord8  s3059 = table7[s3032];-  const SWord8  s3060 = table8[s3034];-  const SWord8  s3061 = table9[s3037];-  const SWord8  s3062 = table6[s3039];-  const SWord8  s3063 = s3061 ^ s3062;-  const SWord8  s3064 = s3060 ^ s3063;-  const SWord8  s3065 = s3059 ^ s3064;-  const SWord16 s3066 = (((SWord16) s3058) << 8) | ((SWord16) s3065);-  const SWord32 s3067 = (((SWord32) s3051) << 16) | ((SWord32) s3066);-  const SWord32 s3068 = s3030 ^ s3067;-  const SWord16 s3069 = (SWord16) s3068;-  const SWord8  s3070 = (SWord8) (s3069 >> 8);-  const SWord32 s3071 = table4[s3070];-  const SWord32 s3072 = s3017 ^ s3071;-  const SWord8  s3073 = (SWord8) (s3020 >> 8);-  const SWord32 s3074 = table1[s3073];-  const SWord8  s3075 = (SWord8) s2756;-  const SWord32 s3076 = table3[s3075];-  const SWord32 s3077 = s3074 ^ s3076;-  const SWord8  s3078 = (SWord8) (s3027 >> 8);-  const SWord32 s3079 = table4[s3078];-  const SWord32 s3080 = s3077 ^ s3079;-  const SWord8  s3081 = (SWord8) s2865;-  const SWord32 s3082 = table5[s3081];-  const SWord32 s3083 = s3080 ^ s3082;-  const SWord16 s3084 = (SWord16) (s555 >> 16);-  const SWord8  s3085 = (SWord8) (s3084 >> 8);-  const SWord8  s3086 = table6[s3085];-  const SWord8  s3087 = (SWord8) s3084;-  const SWord8  s3088 = table7[s3087];-  const SWord16 s3089 = (SWord16) s555;-  const SWord8  s3090 = (SWord8) (s3089 >> 8);-  const SWord8  s3091 = table8[s3090];-  const SWord8  s3092 = (SWord8) s3089;-  const SWord8  s3093 = table9[s3092];-  const SWord8  s3094 = s3091 ^ s3093;-  const SWord8  s3095 = s3088 ^ s3094;-  const SWord8  s3096 = s3086 ^ s3095;-  const SWord8  s3097 = table9[s3085];-  const SWord8  s3098 = table6[s3087];-  const SWord8  s3099 = table7[s3090];-  const SWord8  s3100 = table8[s3092];-  const SWord8  s3101 = s3099 ^ s3100;-  const SWord8  s3102 = s3098 ^ s3101;-  const SWord8  s3103 = s3097 ^ s3102;-  const SWord16 s3104 = (((SWord16) s3096) << 8) | ((SWord16) s3103);-  const SWord8  s3105 = table8[s3085];-  const SWord8  s3106 = table9[s3087];-  const SWord8  s3107 = table6[s3090];-  const SWord8  s3108 = table7[s3092];-  const SWord8  s3109 = s3107 ^ s3108;-  const SWord8  s3110 = s3106 ^ s3109;-  const SWord8  s3111 = s3105 ^ s3110;-  const SWord8  s3112 = table7[s3085];-  const SWord8  s3113 = table8[s3087];-  const SWord8  s3114 = table9[s3090];-  const SWord8  s3115 = table6[s3092];-  const SWord8  s3116 = s3114 ^ s3115;-  const SWord8  s3117 = s3113 ^ s3116;-  const SWord8  s3118 = s3112 ^ s3117;-  const SWord16 s3119 = (((SWord16) s3111) << 8) | ((SWord16) s3118);-  const SWord32 s3120 = (((SWord32) s3104) << 16) | ((SWord32) s3119);-  const SWord32 s3121 = s3083 ^ s3120;-  const SWord16 s3122 = (SWord16) s3121;-  const SWord8  s3123 = (SWord8) s3122;-  const SWord32 s3124 = table5[s3123];-  const SWord32 s3125 = s3072 ^ s3124;-  const SWord16 s3126 = (SWord16) (s535 >> 16);-  const SWord8  s3127 = (SWord8) (s3126 >> 8);-  const SWord8  s3128 = table6[s3127];-  const SWord8  s3129 = (SWord8) s3126;-  const SWord8  s3130 = table7[s3129];-  const SWord16 s3131 = (SWord16) s535;-  const SWord8  s3132 = (SWord8) (s3131 >> 8);-  const SWord8  s3133 = table8[s3132];-  const SWord8  s3134 = (SWord8) s3131;-  const SWord8  s3135 = table9[s3134];-  const SWord8  s3136 = s3133 ^ s3135;-  const SWord8  s3137 = s3130 ^ s3136;-  const SWord8  s3138 = s3128 ^ s3137;-  const SWord8  s3139 = table9[s3127];-  const SWord8  s3140 = table6[s3129];-  const SWord8  s3141 = table7[s3132];-  const SWord8  s3142 = table8[s3134];-  const SWord8  s3143 = s3141 ^ s3142;-  const SWord8  s3144 = s3140 ^ s3143;-  const SWord8  s3145 = s3139 ^ s3144;-  const SWord16 s3146 = (((SWord16) s3138) << 8) | ((SWord16) s3145);-  const SWord8  s3147 = table8[s3127];-  const SWord8  s3148 = table9[s3129];-  const SWord8  s3149 = table6[s3132];-  const SWord8  s3150 = table7[s3134];-  const SWord8  s3151 = s3149 ^ s3150;-  const SWord8  s3152 = s3148 ^ s3151;-  const SWord8  s3153 = s3147 ^ s3152;-  const SWord8  s3154 = table7[s3127];-  const SWord8  s3155 = table8[s3129];-  const SWord8  s3156 = table9[s3132];-  const SWord8  s3157 = table6[s3134];-  const SWord8  s3158 = s3156 ^ s3157;-  const SWord8  s3159 = s3155 ^ s3158;-  const SWord8  s3160 = s3154 ^ s3159;-  const SWord16 s3161 = (((SWord16) s3153) << 8) | ((SWord16) s3160);-  const SWord32 s3162 = (((SWord32) s3146) << 16) | ((SWord32) s3161);-  const SWord32 s3163 = s3125 ^ s3162;-  const SWord16 s3164 = (SWord16) (s3163 >> 16);-  const SWord8  s3165 = (SWord8) (s3164 >> 8);-  const SWord8  s3166 = table0[s3165];-  const SWord8  s3167 = (SWord8) (s3014 >> 8);-  const SWord32 s3168 = table1[s3167];-  const SWord16 s3169 = (SWord16) (s3068 >> 16);-  const SWord8  s3170 = (SWord8) s3169;-  const SWord32 s3171 = table3[s3170];-  const SWord32 s3172 = s3168 ^ s3171;-  const SWord8  s3173 = (SWord8) (s3122 >> 8);-  const SWord32 s3174 = table4[s3173];-  const SWord32 s3175 = s3172 ^ s3174;-  const SWord16 s3176 = (SWord16) s2959;-  const SWord8  s3177 = (SWord8) s3176;-  const SWord32 s3178 = table5[s3177];-  const SWord32 s3179 = s3175 ^ s3178;-  const SWord16 s3180 = (SWord16) (s538 >> 16);-  const SWord8  s3181 = (SWord8) (s3180 >> 8);-  const SWord8  s3182 = table6[s3181];-  const SWord8  s3183 = (SWord8) s3180;-  const SWord8  s3184 = table7[s3183];-  const SWord16 s3185 = (SWord16) s538;-  const SWord8  s3186 = (SWord8) (s3185 >> 8);-  const SWord8  s3187 = table8[s3186];-  const SWord8  s3188 = (SWord8) s3185;-  const SWord8  s3189 = table9[s3188];-  const SWord8  s3190 = s3187 ^ s3189;-  const SWord8  s3191 = s3184 ^ s3190;-  const SWord8  s3192 = s3182 ^ s3191;-  const SWord8  s3193 = table9[s3181];-  const SWord8  s3194 = table6[s3183];-  const SWord8  s3195 = table7[s3186];-  const SWord8  s3196 = table8[s3188];-  const SWord8  s3197 = s3195 ^ s3196;-  const SWord8  s3198 = s3194 ^ s3197;-  const SWord8  s3199 = s3193 ^ s3198;-  const SWord16 s3200 = (((SWord16) s3192) << 8) | ((SWord16) s3199);-  const SWord8  s3201 = table8[s3181];-  const SWord8  s3202 = table9[s3183];-  const SWord8  s3203 = table6[s3186];-  const SWord8  s3204 = table7[s3188];-  const SWord8  s3205 = s3203 ^ s3204;-  const SWord8  s3206 = s3202 ^ s3205;-  const SWord8  s3207 = s3201 ^ s3206;-  const SWord8  s3208 = table7[s3181];-  const SWord8  s3209 = table8[s3183];-  const SWord8  s3210 = table9[s3186];-  const SWord8  s3211 = table6[s3188];-  const SWord8  s3212 = s3210 ^ s3211;-  const SWord8  s3213 = s3209 ^ s3212;-  const SWord8  s3214 = s3208 ^ s3213;-  const SWord16 s3215 = (((SWord16) s3207) << 8) | ((SWord16) s3214);-  const SWord32 s3216 = (((SWord32) s3200) << 16) | ((SWord32) s3215);-  const SWord32 s3217 = s3179 ^ s3216;-  const SWord16 s3218 = (SWord16) (s3217 >> 16);-  const SWord8  s3219 = (SWord8) s3218;-  const SWord8  s3220 = table0[s3219];-  const SWord16 s3221 = (((SWord16) s3166) << 8) | ((SWord16) s3220);-  const SWord8  s3222 = (SWord8) (s3169 >> 8);-  const SWord32 s3223 = table1[s3222];-  const SWord16 s3224 = (SWord16) (s3121 >> 16);-  const SWord8  s3225 = (SWord8) s3224;-  const SWord32 s3226 = table3[s3225];-  const SWord32 s3227 = s3223 ^ s3226;-  const SWord8  s3228 = (SWord8) (s3176 >> 8);-  const SWord32 s3229 = table4[s3228];-  const SWord32 s3230 = s3227 ^ s3229;-  const SWord16 s3231 = (SWord16) s3013;-  const SWord8  s3232 = (SWord8) s3231;-  const SWord32 s3233 = table5[s3232];-  const SWord32 s3234 = s3230 ^ s3233;-  const SWord16 s3235 = (SWord16) (s537 >> 16);-  const SWord8  s3236 = (SWord8) (s3235 >> 8);-  const SWord8  s3237 = table6[s3236];-  const SWord8  s3238 = (SWord8) s3235;-  const SWord8  s3239 = table7[s3238];-  const SWord16 s3240 = (SWord16) s537;-  const SWord8  s3241 = (SWord8) (s3240 >> 8);-  const SWord8  s3242 = table8[s3241];-  const SWord8  s3243 = (SWord8) s3240;-  const SWord8  s3244 = table9[s3243];-  const SWord8  s3245 = s3242 ^ s3244;-  const SWord8  s3246 = s3239 ^ s3245;-  const SWord8  s3247 = s3237 ^ s3246;-  const SWord8  s3248 = table9[s3236];-  const SWord8  s3249 = table6[s3238];-  const SWord8  s3250 = table7[s3241];-  const SWord8  s3251 = table8[s3243];-  const SWord8  s3252 = s3250 ^ s3251;-  const SWord8  s3253 = s3249 ^ s3252;-  const SWord8  s3254 = s3248 ^ s3253;-  const SWord16 s3255 = (((SWord16) s3247) << 8) | ((SWord16) s3254);-  const SWord8  s3256 = table8[s3236];-  const SWord8  s3257 = table9[s3238];-  const SWord8  s3258 = table6[s3241];-  const SWord8  s3259 = table7[s3243];-  const SWord8  s3260 = s3258 ^ s3259;-  const SWord8  s3261 = s3257 ^ s3260;-  const SWord8  s3262 = s3256 ^ s3261;-  const SWord8  s3263 = table7[s3236];-  const SWord8  s3264 = table8[s3238];-  const SWord8  s3265 = table9[s3241];-  const SWord8  s3266 = table6[s3243];-  const SWord8  s3267 = s3265 ^ s3266;-  const SWord8  s3268 = s3264 ^ s3267;-  const SWord8  s3269 = s3263 ^ s3268;-  const SWord16 s3270 = (((SWord16) s3262) << 8) | ((SWord16) s3269);-  const SWord32 s3271 = (((SWord32) s3255) << 16) | ((SWord32) s3270);-  const SWord32 s3272 = s3234 ^ s3271;-  const SWord16 s3273 = (SWord16) s3272;-  const SWord8  s3274 = (SWord8) (s3273 >> 8);-  const SWord8  s3275 = table0[s3274];-  const SWord8  s3276 = (SWord8) (s3224 >> 8);-  const SWord32 s3277 = table1[s3276];-  const SWord8  s3278 = (SWord8) s2960;-  const SWord32 s3279 = table3[s3278];-  const SWord32 s3280 = s3277 ^ s3279;-  const SWord8  s3281 = (SWord8) (s3231 >> 8);-  const SWord32 s3282 = table4[s3281];-  const SWord32 s3283 = s3280 ^ s3282;-  const SWord8  s3284 = (SWord8) s3069;-  const SWord32 s3285 = table5[s3284];-  const SWord32 s3286 = s3283 ^ s3285;-  const SWord16 s3287 = (SWord16) (s536 >> 16);-  const SWord8  s3288 = (SWord8) (s3287 >> 8);-  const SWord8  s3289 = table6[s3288];-  const SWord8  s3290 = (SWord8) s3287;-  const SWord8  s3291 = table7[s3290];-  const SWord16 s3292 = (SWord16) s536;-  const SWord8  s3293 = (SWord8) (s3292 >> 8);-  const SWord8  s3294 = table8[s3293];-  const SWord8  s3295 = (SWord8) s3292;-  const SWord8  s3296 = table9[s3295];-  const SWord8  s3297 = s3294 ^ s3296;-  const SWord8  s3298 = s3291 ^ s3297;-  const SWord8  s3299 = s3289 ^ s3298;-  const SWord8  s3300 = table9[s3288];-  const SWord8  s3301 = table6[s3290];-  const SWord8  s3302 = table7[s3293];-  const SWord8  s3303 = table8[s3295];-  const SWord8  s3304 = s3302 ^ s3303;-  const SWord8  s3305 = s3301 ^ s3304;-  const SWord8  s3306 = s3300 ^ s3305;-  const SWord16 s3307 = (((SWord16) s3299) << 8) | ((SWord16) s3306);-  const SWord8  s3308 = table8[s3288];-  const SWord8  s3309 = table9[s3290];-  const SWord8  s3310 = table6[s3293];-  const SWord8  s3311 = table7[s3295];-  const SWord8  s3312 = s3310 ^ s3311;-  const SWord8  s3313 = s3309 ^ s3312;-  const SWord8  s3314 = s3308 ^ s3313;-  const SWord8  s3315 = table7[s3288];-  const SWord8  s3316 = table8[s3290];-  const SWord8  s3317 = table9[s3293];-  const SWord8  s3318 = table6[s3295];-  const SWord8  s3319 = s3317 ^ s3318;-  const SWord8  s3320 = s3316 ^ s3319;-  const SWord8  s3321 = s3315 ^ s3320;-  const SWord16 s3322 = (((SWord16) s3314) << 8) | ((SWord16) s3321);-  const SWord32 s3323 = (((SWord32) s3307) << 16) | ((SWord32) s3322);-  const SWord32 s3324 = s3286 ^ s3323;-  const SWord16 s3325 = (SWord16) s3324;-  const SWord8  s3326 = (SWord8) s3325;-  const SWord8  s3327 = table0[s3326];-  const SWord16 s3328 = (((SWord16) s3275) << 8) | ((SWord16) s3327);-  const SWord32 s3329 = (((SWord32) s3221) << 16) | ((SWord32) s3328);-  const SWord32 s3330 = s4 ^ s3329;-  const SWord16 s3331 = (SWord16) (s3324 >> 16);-  const SWord8  s3332 = (SWord8) (s3331 >> 8);-  const SWord8  s3333 = table0[s3332];-  const SWord8  s3334 = (SWord8) s3164;-  const SWord8  s3335 = table0[s3334];-  const SWord16 s3336 = (((SWord16) s3333) << 8) | ((SWord16) s3335);-  const SWord16 s3337 = (SWord16) s3217;-  const SWord8  s3338 = (SWord8) (s3337 >> 8);-  const SWord8  s3339 = table0[s3338];-  const SWord8  s3340 = (SWord8) s3273;-  const SWord8  s3341 = table0[s3340];-  const SWord16 s3342 = (((SWord16) s3339) << 8) | ((SWord16) s3341);-  const SWord32 s3343 = (((SWord32) s3336) << 16) | ((SWord32) s3342);-  const SWord32 s3344 = s5 ^ s3343;-  const SWord16 s3345 = (SWord16) (s3272 >> 16);-  const SWord8  s3346 = (SWord8) (s3345 >> 8);-  const SWord8  s3347 = table0[s3346];-  const SWord8  s3348 = (SWord8) s3331;-  const SWord8  s3349 = table0[s3348];-  const SWord16 s3350 = (((SWord16) s3347) << 8) | ((SWord16) s3349);-  const SWord16 s3351 = (SWord16) s3163;-  const SWord8  s3352 = (SWord8) (s3351 >> 8);-  const SWord8  s3353 = table0[s3352];-  const SWord8  s3354 = (SWord8) s3337;-  const SWord8  s3355 = table0[s3354];-  const SWord16 s3356 = (((SWord16) s3353) << 8) | ((SWord16) s3355);-  const SWord32 s3357 = (((SWord32) s3350) << 16) | ((SWord32) s3356);-  const SWord32 s3358 = s6 ^ s3357;-  const SWord8  s3359 = (SWord8) (s3218 >> 8);-  const SWord8  s3360 = table0[s3359];-  const SWord8  s3361 = (SWord8) s3345;-  const SWord8  s3362 = table0[s3361];-  const SWord16 s3363 = (((SWord16) s3360) << 8) | ((SWord16) s3362);-  const SWord8  s3364 = (SWord8) (s3325 >> 8);-  const SWord8  s3365 = table0[s3364];-  const SWord8  s3366 = (SWord8) s3351;-  const SWord8  s3367 = table0[s3366];-  const SWord16 s3368 = (((SWord16) s3365) << 8) | ((SWord16) s3367);-  const SWord32 s3369 = (((SWord32) s3363) << 16) | ((SWord32) s3368);-  const SWord32 s3370 = s7 ^ s3369;--  ct[0] = s3330;-  ct[1] = s3344;-  ct[2] = s3358;-  ct[3] = s3370;-}-== END: "aes128Dec.c" ==================
− SBVUnitTest/GoldFiles/aes128Enc.gold 
@@ -1,1167 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for aes128Enc. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: aes128Enc_driver--aes128Enc.o: aes128Enc.c aes128Enc.h-	${CC} ${CCFLAGS} -c $< -o $@--aes128Enc_driver.o: aes128Enc_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--aes128Enc_driver: aes128Enc.o aes128Enc_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f aes128Enc_driver-== END: "Makefile" ==================-== BEGIN: "aes128Enc.h" ================-/* Header file for aes128Enc. Automatically generated by SBV. Do not edit! */--#ifndef __aes128Enc__HEADER_INCLUDED__-#define __aes128Enc__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-void aes128Enc(const SWord32 *pt, const SWord32 *key, SWord32 *ct);--#endif /* __aes128Enc__HEADER_INCLUDED__ */-== END: "aes128Enc.h" ==================-== BEGIN: "aes128Enc_driver.c" ================-/* Example driver program for aes128Enc. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "aes128Enc.h"--int main(void)-{-  const SWord32 pt[4] = {-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL-  };--  printf("Contents of input array pt:\n");-  int pt_ctr;-  for(pt_ctr = 0; pt_ctr < 4 ; ++pt_ctr)-    printf("  pt[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]);--  const SWord32 key[4] = {-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL-  };--  printf("Contents of input array key:\n");-  int key_ctr;-  for(key_ctr = 0; key_ctr < 4 ; ++key_ctr)-    printf("  key[%d] = 0x%08"PRIx32"UL\n", key_ctr ,key[key_ctr]);--  SWord32 ct[4];--  aes128Enc(pt, key, ct);--  printf("aes128Enc(pt, key, ct) ->\n");-  int ct_ctr;-  for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr)-    printf("  ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]);--  return 0;-}-== END: "aes128Enc_driver.c" ==================-== BEGIN: "aes128Enc.c" ================-/* File: "aes128Enc.c". Automatically generated by SBV. Do not edit! */--#include "aes128Enc.h"--void aes128Enc(const SWord32 *pt, const SWord32 *key, SWord32 *ct)-{-  const SWord32 s0 = pt[0];-  const SWord32 s1 = pt[1];-  const SWord32 s2 = pt[2];-  const SWord32 s3 = pt[3];-  const SWord32 s4 = key[0];-  const SWord32 s5 = key[1];-  const SWord32 s6 = key[2];-  const SWord32 s7 = key[3];-  static const SWord8 table0[] = {-       99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254,-      215, 171, 118, 202, 130, 201, 125, 250,  89,  71, 240, 173, 212,-      162, 175, 156, 164, 114, 192, 183, 253, 147,  38,  54,  63, 247,-      204,  52, 165, 229, 241, 113, 216,  49,  21,   4, 199,  35, 195,-       24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,   9,-      131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,-       47, 132,  83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,-       57,  74,  76,  88, 207, 208, 239, 170, 251,  67,  77,  51, 133,-       69, 249,   2, 127,  80,  60, 159, 168,  81, 163,  64, 143, 146,-      157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210, 205,  12,-       19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25,-      115,  96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20,-      222,  94,  11, 219, 224,  50,  58,  10,  73,   6,  36,  92, 194,-      211, 172,  98, 145, 149, 228, 121, 231, 200,  55, 109, 141, 213,-       78, 169, 108,  86, 244, 234, 101, 122, 174,   8, 186, 120,  37,-       46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,-      112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134,-      193,  29, 158, 225, 248, 152,  17, 105, 217, 142, 148, 155,  30,-      135, 233, 206,  85,  40, 223, 140, 161, 137,  13, 191, 230,  66,-      104,  65, 153,  45,  15, 176,  84, 187,  22-  };-  static const SWord32 table1[] = {-      0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL,-      0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL,-      0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL,-      0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL,-      0x8fcaca45UL, 0x1f82829dUL, 0x89c9c940UL, 0xfa7d7d87UL,-      0xeffafa15UL, 0xb25959ebUL, 0x8e4747c9UL, 0xfbf0f00bUL,-      0x41adadecUL, 0xb3d4d467UL, 0x5fa2a2fdUL, 0x45afafeaUL,-      0x239c9cbfUL, 0x53a4a4f7UL, 0xe4727296UL, 0x9bc0c05bUL,-      0x75b7b7c2UL, 0xe1fdfd1cUL, 0x3d9393aeUL, 0x4c26266aUL,-      0x6c36365aUL, 0x7e3f3f41UL, 0xf5f7f702UL, 0x83cccc4fUL,-      0x6834345cUL, 0x51a5a5f4UL, 0xd1e5e534UL, 0xf9f1f108UL,-      0xe2717193UL, 0xabd8d873UL, 0x62313153UL, 0x2a15153fUL,-      0x0804040cUL, 0x95c7c752UL, 0x46232365UL, 0x9dc3c35eUL,-      0x30181828UL, 0x379696a1UL, 0x0a05050fUL, 0x2f9a9ab5UL,-      0x0e070709UL, 0x24121236UL, 0x1b80809bUL, 0xdfe2e23dUL,-      0xcdebeb26UL, 0x4e272769UL, 0x7fb2b2cdUL, 0xea75759fUL,-      0x1209091bUL, 0x1d83839eUL, 0x582c2c74UL, 0x341a1a2eUL,-      0x361b1b2dUL, 0xdc6e6eb2UL, 0xb45a5aeeUL, 0x5ba0a0fbUL,-      0xa45252f6UL, 0x763b3b4dUL, 0xb7d6d661UL, 0x7db3b3ceUL,-      0x5229297bUL, 0xdde3e33eUL, 0x5e2f2f71UL, 0x13848497UL,-      0xa65353f5UL, 0xb9d1d168UL, 0x00000000UL, 0xc1eded2cUL,-      0x40202060UL, 0xe3fcfc1fUL, 0x79b1b1c8UL, 0xb65b5bedUL,-      0xd46a6abeUL, 0x8dcbcb46UL, 0x67bebed9UL, 0x7239394bUL,-      0x944a4adeUL, 0x984c4cd4UL, 0xb05858e8UL, 0x85cfcf4aUL,-      0xbbd0d06bUL, 0xc5efef2aUL, 0x4faaaae5UL, 0xedfbfb16UL,-      0x864343c5UL, 0x9a4d4dd7UL, 0x66333355UL, 0x11858594UL,-      0x8a4545cfUL, 0xe9f9f910UL, 0x04020206UL, 0xfe7f7f81UL,-      0xa05050f0UL, 0x783c3c44UL, 0x259f9fbaUL, 0x4ba8a8e3UL,-      0xa25151f3UL, 0x5da3a3feUL, 0x804040c0UL, 0x058f8f8aUL,-      0x3f9292adUL, 0x219d9dbcUL, 0x70383848UL, 0xf1f5f504UL,-      0x63bcbcdfUL, 0x77b6b6c1UL, 0xafdada75UL, 0x42212163UL,-      0x20101030UL, 0xe5ffff1aUL, 0xfdf3f30eUL, 0xbfd2d26dUL,-      0x81cdcd4cUL, 0x180c0c14UL, 0x26131335UL, 0xc3ecec2fUL,-      0xbe5f5fe1UL, 0x359797a2UL, 0x884444ccUL, 0x2e171739UL,-      0x93c4c457UL, 0x55a7a7f2UL, 0xfc7e7e82UL, 0x7a3d3d47UL,-      0xc86464acUL, 0xba5d5de7UL, 0x3219192bUL, 0xe6737395UL,-      0xc06060a0UL, 0x19818198UL, 0x9e4f4fd1UL, 0xa3dcdc7fUL,-      0x44222266UL, 0x542a2a7eUL, 0x3b9090abUL, 0x0b888883UL,-      0x8c4646caUL, 0xc7eeee29UL, 0x6bb8b8d3UL, 0x2814143cUL,-      0xa7dede79UL, 0xbc5e5ee2UL, 0x160b0b1dUL, 0xaddbdb76UL,-      0xdbe0e03bUL, 0x64323256UL, 0x743a3a4eUL, 0x140a0a1eUL,-      0x924949dbUL, 0x0c06060aUL, 0x4824246cUL, 0xb85c5ce4UL,-      0x9fc2c25dUL, 0xbdd3d36eUL, 0x43acacefUL, 0xc46262a6UL,-      0x399191a8UL, 0x319595a4UL, 0xd3e4e437UL, 0xf279798bUL,-      0xd5e7e732UL, 0x8bc8c843UL, 0x6e373759UL, 0xda6d6db7UL,-      0x018d8d8cUL, 0xb1d5d564UL, 0x9c4e4ed2UL, 0x49a9a9e0UL,-      0xd86c6cb4UL, 0xac5656faUL, 0xf3f4f407UL, 0xcfeaea25UL,-      0xca6565afUL, 0xf47a7a8eUL, 0x47aeaee9UL, 0x10080818UL,-      0x6fbabad5UL, 0xf0787888UL, 0x4a25256fUL, 0x5c2e2e72UL,-      0x381c1c24UL, 0x57a6a6f1UL, 0x73b4b4c7UL, 0x97c6c651UL,-      0xcbe8e823UL, 0xa1dddd7cUL, 0xe874749cUL, 0x3e1f1f21UL,-      0x964b4bddUL, 0x61bdbddcUL, 0x0d8b8b86UL, 0x0f8a8a85UL,-      0xe0707090UL, 0x7c3e3e42UL, 0x71b5b5c4UL, 0xcc6666aaUL,-      0x904848d8UL, 0x06030305UL, 0xf7f6f601UL, 0x1c0e0e12UL,-      0xc26161a3UL, 0x6a35355fUL, 0xae5757f9UL, 0x69b9b9d0UL,-      0x17868691UL, 0x99c1c158UL, 0x3a1d1d27UL, 0x279e9eb9UL,-      0xd9e1e138UL, 0xebf8f813UL, 0x2b9898b3UL, 0x22111133UL,-      0xd26969bbUL, 0xa9d9d970UL, 0x078e8e89UL, 0x339494a7UL,-      0x2d9b9bb6UL, 0x3c1e1e22UL, 0x15878792UL, 0xc9e9e920UL,-      0x87cece49UL, 0xaa5555ffUL, 0x50282878UL, 0xa5dfdf7aUL,-      0x038c8c8fUL, 0x59a1a1f8UL, 0x09898980UL, 0x1a0d0d17UL,-      0x65bfbfdaUL, 0xd7e6e631UL, 0x844242c6UL, 0xd06868b8UL,-      0x824141c3UL, 0x299999b0UL, 0x5a2d2d77UL, 0x1e0f0f11UL,-      0x7bb0b0cbUL, 0xa85454fcUL, 0x6dbbbbd6UL, 0x2c16163aUL-  };-  static const SWord32 table2[] = {-      0xa5c66363UL, 0x84f87c7cUL, 0x99ee7777UL, 0x8df67b7bUL,-      0x0dfff2f2UL, 0xbdd66b6bUL, 0xb1de6f6fUL, 0x5491c5c5UL,-      0x50603030UL, 0x03020101UL, 0xa9ce6767UL, 0x7d562b2bUL,-      0x19e7fefeUL, 0x62b5d7d7UL, 0xe64dababUL, 0x9aec7676UL,-      0x458fcacaUL, 0x9d1f8282UL, 0x4089c9c9UL, 0x87fa7d7dUL,-      0x15effafaUL, 0xebb25959UL, 0xc98e4747UL, 0x0bfbf0f0UL,-      0xec41adadUL, 0x67b3d4d4UL, 0xfd5fa2a2UL, 0xea45afafUL,-      0xbf239c9cUL, 0xf753a4a4UL, 0x96e47272UL, 0x5b9bc0c0UL,-      0xc275b7b7UL, 0x1ce1fdfdUL, 0xae3d9393UL, 0x6a4c2626UL,-      0x5a6c3636UL, 0x417e3f3fUL, 0x02f5f7f7UL, 0x4f83ccccUL,-      0x5c683434UL, 0xf451a5a5UL, 0x34d1e5e5UL, 0x08f9f1f1UL,-      0x93e27171UL, 0x73abd8d8UL, 0x53623131UL, 0x3f2a1515UL,-      0x0c080404UL, 0x5295c7c7UL, 0x65462323UL, 0x5e9dc3c3UL,-      0x28301818UL, 0xa1379696UL, 0x0f0a0505UL, 0xb52f9a9aUL,-      0x090e0707UL, 0x36241212UL, 0x9b1b8080UL, 0x3ddfe2e2UL,-      0x26cdebebUL, 0x694e2727UL, 0xcd7fb2b2UL, 0x9fea7575UL,-      0x1b120909UL, 0x9e1d8383UL, 0x74582c2cUL, 0x2e341a1aUL,-      0x2d361b1bUL, 0xb2dc6e6eUL, 0xeeb45a5aUL, 0xfb5ba0a0UL,-      0xf6a45252UL, 0x4d763b3bUL, 0x61b7d6d6UL, 0xce7db3b3UL,-      0x7b522929UL, 0x3edde3e3UL, 0x715e2f2fUL, 0x97138484UL,-      0xf5a65353UL, 0x68b9d1d1UL, 0x00000000UL, 0x2cc1ededUL,-      0x60402020UL, 0x1fe3fcfcUL, 0xc879b1b1UL, 0xedb65b5bUL,-      0xbed46a6aUL, 0x468dcbcbUL, 0xd967bebeUL, 0x4b723939UL,-      0xde944a4aUL, 0xd4984c4cUL, 0xe8b05858UL, 0x4a85cfcfUL,-      0x6bbbd0d0UL, 0x2ac5efefUL, 0xe54faaaaUL, 0x16edfbfbUL,-      0xc5864343UL, 0xd79a4d4dUL, 0x55663333UL, 0x94118585UL,-      0xcf8a4545UL, 0x10e9f9f9UL, 0x06040202UL, 0x81fe7f7fUL,-      0xf0a05050UL, 0x44783c3cUL, 0xba259f9fUL, 0xe34ba8a8UL,-      0xf3a25151UL, 0xfe5da3a3UL, 0xc0804040UL, 0x8a058f8fUL,-      0xad3f9292UL, 0xbc219d9dUL, 0x48703838UL, 0x04f1f5f5UL,-      0xdf63bcbcUL, 0xc177b6b6UL, 0x75afdadaUL, 0x63422121UL,-      0x30201010UL, 0x1ae5ffffUL, 0x0efdf3f3UL, 0x6dbfd2d2UL,-      0x4c81cdcdUL, 0x14180c0cUL, 0x35261313UL, 0x2fc3ececUL,-      0xe1be5f5fUL, 0xa2359797UL, 0xcc884444UL, 0x392e1717UL,-      0x5793c4c4UL, 0xf255a7a7UL, 0x82fc7e7eUL, 0x477a3d3dUL,-      0xacc86464UL, 0xe7ba5d5dUL, 0x2b321919UL, 0x95e67373UL,-      0xa0c06060UL, 0x98198181UL, 0xd19e4f4fUL, 0x7fa3dcdcUL,-      0x66442222UL, 0x7e542a2aUL, 0xab3b9090UL, 0x830b8888UL,-      0xca8c4646UL, 0x29c7eeeeUL, 0xd36bb8b8UL, 0x3c281414UL,-      0x79a7dedeUL, 0xe2bc5e5eUL, 0x1d160b0bUL, 0x76addbdbUL,-      0x3bdbe0e0UL, 0x56643232UL, 0x4e743a3aUL, 0x1e140a0aUL,-      0xdb924949UL, 0x0a0c0606UL, 0x6c482424UL, 0xe4b85c5cUL,-      0x5d9fc2c2UL, 0x6ebdd3d3UL, 0xef43acacUL, 0xa6c46262UL,-      0xa8399191UL, 0xa4319595UL, 0x37d3e4e4UL, 0x8bf27979UL,-      0x32d5e7e7UL, 0x438bc8c8UL, 0x596e3737UL, 0xb7da6d6dUL,-      0x8c018d8dUL, 0x64b1d5d5UL, 0xd29c4e4eUL, 0xe049a9a9UL,-      0xb4d86c6cUL, 0xfaac5656UL, 0x07f3f4f4UL, 0x25cfeaeaUL,-      0xafca6565UL, 0x8ef47a7aUL, 0xe947aeaeUL, 0x18100808UL,-      0xd56fbabaUL, 0x88f07878UL, 0x6f4a2525UL, 0x725c2e2eUL,-      0x24381c1cUL, 0xf157a6a6UL, 0xc773b4b4UL, 0x5197c6c6UL,-      0x23cbe8e8UL, 0x7ca1ddddUL, 0x9ce87474UL, 0x213e1f1fUL,-      0xdd964b4bUL, 0xdc61bdbdUL, 0x860d8b8bUL, 0x850f8a8aUL,-      0x90e07070UL, 0x427c3e3eUL, 0xc471b5b5UL, 0xaacc6666UL,-      0xd8904848UL, 0x05060303UL, 0x01f7f6f6UL, 0x121c0e0eUL,-      0xa3c26161UL, 0x5f6a3535UL, 0xf9ae5757UL, 0xd069b9b9UL,-      0x91178686UL, 0x5899c1c1UL, 0x273a1d1dUL, 0xb9279e9eUL,-      0x38d9e1e1UL, 0x13ebf8f8UL, 0xb32b9898UL, 0x33221111UL,-      0xbbd26969UL, 0x70a9d9d9UL, 0x89078e8eUL, 0xa7339494UL,-      0xb62d9b9bUL, 0x223c1e1eUL, 0x92158787UL, 0x20c9e9e9UL,-      0x4987ceceUL, 0xffaa5555UL, 0x78502828UL, 0x7aa5dfdfUL,-      0x8f038c8cUL, 0xf859a1a1UL, 0x80098989UL, 0x171a0d0dUL,-      0xda65bfbfUL, 0x31d7e6e6UL, 0xc6844242UL, 0xb8d06868UL,-      0xc3824141UL, 0xb0299999UL, 0x775a2d2dUL, 0x111e0f0fUL,-      0xcb7bb0b0UL, 0xfca85454UL, 0xd66dbbbbUL, 0x3a2c1616UL-  };-  static const SWord32 table3[] = {-      0x63a5c663UL, 0x7c84f87cUL, 0x7799ee77UL, 0x7b8df67bUL,-      0xf20dfff2UL, 0x6bbdd66bUL, 0x6fb1de6fUL, 0xc55491c5UL,-      0x30506030UL, 0x01030201UL, 0x67a9ce67UL, 0x2b7d562bUL,-      0xfe19e7feUL, 0xd762b5d7UL, 0xabe64dabUL, 0x769aec76UL,-      0xca458fcaUL, 0x829d1f82UL, 0xc94089c9UL, 0x7d87fa7dUL,-      0xfa15effaUL, 0x59ebb259UL, 0x47c98e47UL, 0xf00bfbf0UL,-      0xadec41adUL, 0xd467b3d4UL, 0xa2fd5fa2UL, 0xafea45afUL,-      0x9cbf239cUL, 0xa4f753a4UL, 0x7296e472UL, 0xc05b9bc0UL,-      0xb7c275b7UL, 0xfd1ce1fdUL, 0x93ae3d93UL, 0x266a4c26UL,-      0x365a6c36UL, 0x3f417e3fUL, 0xf702f5f7UL, 0xcc4f83ccUL,-      0x345c6834UL, 0xa5f451a5UL, 0xe534d1e5UL, 0xf108f9f1UL,-      0x7193e271UL, 0xd873abd8UL, 0x31536231UL, 0x153f2a15UL,-      0x040c0804UL, 0xc75295c7UL, 0x23654623UL, 0xc35e9dc3UL,-      0x18283018UL, 0x96a13796UL, 0x050f0a05UL, 0x9ab52f9aUL,-      0x07090e07UL, 0x12362412UL, 0x809b1b80UL, 0xe23ddfe2UL,-      0xeb26cdebUL, 0x27694e27UL, 0xb2cd7fb2UL, 0x759fea75UL,-      0x091b1209UL, 0x839e1d83UL, 0x2c74582cUL, 0x1a2e341aUL,-      0x1b2d361bUL, 0x6eb2dc6eUL, 0x5aeeb45aUL, 0xa0fb5ba0UL,-      0x52f6a452UL, 0x3b4d763bUL, 0xd661b7d6UL, 0xb3ce7db3UL,-      0x297b5229UL, 0xe33edde3UL, 0x2f715e2fUL, 0x84971384UL,-      0x53f5a653UL, 0xd168b9d1UL, 0x00000000UL, 0xed2cc1edUL,-      0x20604020UL, 0xfc1fe3fcUL, 0xb1c879b1UL, 0x5bedb65bUL,-      0x6abed46aUL, 0xcb468dcbUL, 0xbed967beUL, 0x394b7239UL,-      0x4ade944aUL, 0x4cd4984cUL, 0x58e8b058UL, 0xcf4a85cfUL,-      0xd06bbbd0UL, 0xef2ac5efUL, 0xaae54faaUL, 0xfb16edfbUL,-      0x43c58643UL, 0x4dd79a4dUL, 0x33556633UL, 0x85941185UL,-      0x45cf8a45UL, 0xf910e9f9UL, 0x02060402UL, 0x7f81fe7fUL,-      0x50f0a050UL, 0x3c44783cUL, 0x9fba259fUL, 0xa8e34ba8UL,-      0x51f3a251UL, 0xa3fe5da3UL, 0x40c08040UL, 0x8f8a058fUL,-      0x92ad3f92UL, 0x9dbc219dUL, 0x38487038UL, 0xf504f1f5UL,-      0xbcdf63bcUL, 0xb6c177b6UL, 0xda75afdaUL, 0x21634221UL,-      0x10302010UL, 0xff1ae5ffUL, 0xf30efdf3UL, 0xd26dbfd2UL,-      0xcd4c81cdUL, 0x0c14180cUL, 0x13352613UL, 0xec2fc3ecUL,-      0x5fe1be5fUL, 0x97a23597UL, 0x44cc8844UL, 0x17392e17UL,-      0xc45793c4UL, 0xa7f255a7UL, 0x7e82fc7eUL, 0x3d477a3dUL,-      0x64acc864UL, 0x5de7ba5dUL, 0x192b3219UL, 0x7395e673UL,-      0x60a0c060UL, 0x81981981UL, 0x4fd19e4fUL, 0xdc7fa3dcUL,-      0x22664422UL, 0x2a7e542aUL, 0x90ab3b90UL, 0x88830b88UL,-      0x46ca8c46UL, 0xee29c7eeUL, 0xb8d36bb8UL, 0x143c2814UL,-      0xde79a7deUL, 0x5ee2bc5eUL, 0x0b1d160bUL, 0xdb76addbUL,-      0xe03bdbe0UL, 0x32566432UL, 0x3a4e743aUL, 0x0a1e140aUL,-      0x49db9249UL, 0x060a0c06UL, 0x246c4824UL, 0x5ce4b85cUL,-      0xc25d9fc2UL, 0xd36ebdd3UL, 0xacef43acUL, 0x62a6c462UL,-      0x91a83991UL, 0x95a43195UL, 0xe437d3e4UL, 0x798bf279UL,-      0xe732d5e7UL, 0xc8438bc8UL, 0x37596e37UL, 0x6db7da6dUL,-      0x8d8c018dUL, 0xd564b1d5UL, 0x4ed29c4eUL, 0xa9e049a9UL,-      0x6cb4d86cUL, 0x56faac56UL, 0xf407f3f4UL, 0xea25cfeaUL,-      0x65afca65UL, 0x7a8ef47aUL, 0xaee947aeUL, 0x08181008UL,-      0xbad56fbaUL, 0x7888f078UL, 0x256f4a25UL, 0x2e725c2eUL,-      0x1c24381cUL, 0xa6f157a6UL, 0xb4c773b4UL, 0xc65197c6UL,-      0xe823cbe8UL, 0xdd7ca1ddUL, 0x749ce874UL, 0x1f213e1fUL,-      0x4bdd964bUL, 0xbddc61bdUL, 0x8b860d8bUL, 0x8a850f8aUL,-      0x7090e070UL, 0x3e427c3eUL, 0xb5c471b5UL, 0x66aacc66UL,-      0x48d89048UL, 0x03050603UL, 0xf601f7f6UL, 0x0e121c0eUL,-      0x61a3c261UL, 0x355f6a35UL, 0x57f9ae57UL, 0xb9d069b9UL,-      0x86911786UL, 0xc15899c1UL, 0x1d273a1dUL, 0x9eb9279eUL,-      0xe138d9e1UL, 0xf813ebf8UL, 0x98b32b98UL, 0x11332211UL,-      0x69bbd269UL, 0xd970a9d9UL, 0x8e89078eUL, 0x94a73394UL,-      0x9bb62d9bUL, 0x1e223c1eUL, 0x87921587UL, 0xe920c9e9UL,-      0xce4987ceUL, 0x55ffaa55UL, 0x28785028UL, 0xdf7aa5dfUL,-      0x8c8f038cUL, 0xa1f859a1UL, 0x89800989UL, 0x0d171a0dUL,-      0xbfda65bfUL, 0xe631d7e6UL, 0x42c68442UL, 0x68b8d068UL,-      0x41c38241UL, 0x99b02999UL, 0x2d775a2dUL, 0x0f111e0fUL,-      0xb0cb7bb0UL, 0x54fca854UL, 0xbbd66dbbUL, 0x163a2c16UL-  };-  static const SWord32 table4[] = {-      0x6363a5c6UL, 0x7c7c84f8UL, 0x777799eeUL, 0x7b7b8df6UL,-      0xf2f20dffUL, 0x6b6bbdd6UL, 0x6f6fb1deUL, 0xc5c55491UL,-      0x30305060UL, 0x01010302UL, 0x6767a9ceUL, 0x2b2b7d56UL,-      0xfefe19e7UL, 0xd7d762b5UL, 0xababe64dUL, 0x76769aecUL,-      0xcaca458fUL, 0x82829d1fUL, 0xc9c94089UL, 0x7d7d87faUL,-      0xfafa15efUL, 0x5959ebb2UL, 0x4747c98eUL, 0xf0f00bfbUL,-      0xadadec41UL, 0xd4d467b3UL, 0xa2a2fd5fUL, 0xafafea45UL,-      0x9c9cbf23UL, 0xa4a4f753UL, 0x727296e4UL, 0xc0c05b9bUL,-      0xb7b7c275UL, 0xfdfd1ce1UL, 0x9393ae3dUL, 0x26266a4cUL,-      0x36365a6cUL, 0x3f3f417eUL, 0xf7f702f5UL, 0xcccc4f83UL,-      0x34345c68UL, 0xa5a5f451UL, 0xe5e534d1UL, 0xf1f108f9UL,-      0x717193e2UL, 0xd8d873abUL, 0x31315362UL, 0x15153f2aUL,-      0x04040c08UL, 0xc7c75295UL, 0x23236546UL, 0xc3c35e9dUL,-      0x18182830UL, 0x9696a137UL, 0x05050f0aUL, 0x9a9ab52fUL,-      0x0707090eUL, 0x12123624UL, 0x80809b1bUL, 0xe2e23ddfUL,-      0xebeb26cdUL, 0x2727694eUL, 0xb2b2cd7fUL, 0x75759feaUL,-      0x09091b12UL, 0x83839e1dUL, 0x2c2c7458UL, 0x1a1a2e34UL,-      0x1b1b2d36UL, 0x6e6eb2dcUL, 0x5a5aeeb4UL, 0xa0a0fb5bUL,-      0x5252f6a4UL, 0x3b3b4d76UL, 0xd6d661b7UL, 0xb3b3ce7dUL,-      0x29297b52UL, 0xe3e33eddUL, 0x2f2f715eUL, 0x84849713UL,-      0x5353f5a6UL, 0xd1d168b9UL, 0x00000000UL, 0xeded2cc1UL,-      0x20206040UL, 0xfcfc1fe3UL, 0xb1b1c879UL, 0x5b5bedb6UL,-      0x6a6abed4UL, 0xcbcb468dUL, 0xbebed967UL, 0x39394b72UL,-      0x4a4ade94UL, 0x4c4cd498UL, 0x5858e8b0UL, 0xcfcf4a85UL,-      0xd0d06bbbUL, 0xefef2ac5UL, 0xaaaae54fUL, 0xfbfb16edUL,-      0x4343c586UL, 0x4d4dd79aUL, 0x33335566UL, 0x85859411UL,-      0x4545cf8aUL, 0xf9f910e9UL, 0x02020604UL, 0x7f7f81feUL,-      0x5050f0a0UL, 0x3c3c4478UL, 0x9f9fba25UL, 0xa8a8e34bUL,-      0x5151f3a2UL, 0xa3a3fe5dUL, 0x4040c080UL, 0x8f8f8a05UL,-      0x9292ad3fUL, 0x9d9dbc21UL, 0x38384870UL, 0xf5f504f1UL,-      0xbcbcdf63UL, 0xb6b6c177UL, 0xdada75afUL, 0x21216342UL,-      0x10103020UL, 0xffff1ae5UL, 0xf3f30efdUL, 0xd2d26dbfUL,-      0xcdcd4c81UL, 0x0c0c1418UL, 0x13133526UL, 0xecec2fc3UL,-      0x5f5fe1beUL, 0x9797a235UL, 0x4444cc88UL, 0x1717392eUL,-      0xc4c45793UL, 0xa7a7f255UL, 0x7e7e82fcUL, 0x3d3d477aUL,-      0x6464acc8UL, 0x5d5de7baUL, 0x19192b32UL, 0x737395e6UL,-      0x6060a0c0UL, 0x81819819UL, 0x4f4fd19eUL, 0xdcdc7fa3UL,-      0x22226644UL, 0x2a2a7e54UL, 0x9090ab3bUL, 0x8888830bUL,-      0x4646ca8cUL, 0xeeee29c7UL, 0xb8b8d36bUL, 0x14143c28UL,-      0xdede79a7UL, 0x5e5ee2bcUL, 0x0b0b1d16UL, 0xdbdb76adUL,-      0xe0e03bdbUL, 0x32325664UL, 0x3a3a4e74UL, 0x0a0a1e14UL,-      0x4949db92UL, 0x06060a0cUL, 0x24246c48UL, 0x5c5ce4b8UL,-      0xc2c25d9fUL, 0xd3d36ebdUL, 0xacacef43UL, 0x6262a6c4UL,-      0x9191a839UL, 0x9595a431UL, 0xe4e437d3UL, 0x79798bf2UL,-      0xe7e732d5UL, 0xc8c8438bUL, 0x3737596eUL, 0x6d6db7daUL,-      0x8d8d8c01UL, 0xd5d564b1UL, 0x4e4ed29cUL, 0xa9a9e049UL,-      0x6c6cb4d8UL, 0x5656faacUL, 0xf4f407f3UL, 0xeaea25cfUL,-      0x6565afcaUL, 0x7a7a8ef4UL, 0xaeaee947UL, 0x08081810UL,-      0xbabad56fUL, 0x787888f0UL, 0x25256f4aUL, 0x2e2e725cUL,-      0x1c1c2438UL, 0xa6a6f157UL, 0xb4b4c773UL, 0xc6c65197UL,-      0xe8e823cbUL, 0xdddd7ca1UL, 0x74749ce8UL, 0x1f1f213eUL,-      0x4b4bdd96UL, 0xbdbddc61UL, 0x8b8b860dUL, 0x8a8a850fUL,-      0x707090e0UL, 0x3e3e427cUL, 0xb5b5c471UL, 0x6666aaccUL,-      0x4848d890UL, 0x03030506UL, 0xf6f601f7UL, 0x0e0e121cUL,-      0x6161a3c2UL, 0x35355f6aUL, 0x5757f9aeUL, 0xb9b9d069UL,-      0x86869117UL, 0xc1c15899UL, 0x1d1d273aUL, 0x9e9eb927UL,-      0xe1e138d9UL, 0xf8f813ebUL, 0x9898b32bUL, 0x11113322UL,-      0x6969bbd2UL, 0xd9d970a9UL, 0x8e8e8907UL, 0x9494a733UL,-      0x9b9bb62dUL, 0x1e1e223cUL, 0x87879215UL, 0xe9e920c9UL,-      0xcece4987UL, 0x5555ffaaUL, 0x28287850UL, 0xdfdf7aa5UL,-      0x8c8c8f03UL, 0xa1a1f859UL, 0x89898009UL, 0x0d0d171aUL,-      0xbfbfda65UL, 0xe6e631d7UL, 0x4242c684UL, 0x6868b8d0UL,-      0x4141c382UL, 0x9999b029UL, 0x2d2d775aUL, 0x0f0f111eUL,-      0xb0b0cb7bUL, 0x5454fca8UL, 0xbbbbd66dUL, 0x16163a2cUL-  };-  const SWord32 s520 = s0 ^ s4;-  const SWord16 s521 = (SWord16) (s520 >> 16);-  const SWord8  s522 = (SWord8) (s521 >> 8);-  const SWord32 s523 = table1[s522];-  const SWord32 s779 = s1 ^ s5;-  const SWord16 s780 = (SWord16) (s779 >> 16);-  const SWord8  s781 = (SWord8) s780;-  const SWord32 s782 = table2[s781];-  const SWord32 s783 = s523 ^ s782;-  const SWord32 s1039 = s2 ^ s6;-  const SWord16 s1040 = (SWord16) s1039;-  const SWord8  s1041 = (SWord8) (s1040 >> 8);-  const SWord32 s1042 = table3[s1041];-  const SWord32 s1043 = s783 ^ s1042;-  const SWord32 s1299 = s3 ^ s7;-  const SWord16 s1300 = (SWord16) s1299;-  const SWord8  s1301 = (SWord8) s1300;-  const SWord32 s1302 = table4[s1301];-  const SWord32 s1303 = s1043 ^ s1302;-  const SWord32 s1304 = (s7 << 8) | (s7 >> 24);-  const SWord16 s1305 = (SWord16) (s1304 >> 16);-  const SWord8  s1306 = (SWord8) (s1305 >> 8);-  const SWord8  s1307 = table0[s1306];-  const SWord8  s1308 = 1 ^ s1307;-  const SWord8  s1309 = (SWord8) s1305;-  const SWord8  s1310 = table0[s1309];-  const SWord16 s1311 = (((SWord16) s1308) << 8) | ((SWord16) s1310);-  const SWord16 s1312 = (SWord16) s1304;-  const SWord8  s1313 = (SWord8) (s1312 >> 8);-  const SWord8  s1314 = table0[s1313];-  const SWord8  s1315 = (SWord8) s1312;-  const SWord8  s1316 = table0[s1315];-  const SWord16 s1317 = (((SWord16) s1314) << 8) | ((SWord16) s1316);-  const SWord32 s1318 = (((SWord32) s1311) << 16) | ((SWord32) s1317);-  const SWord32 s1319 = s4 ^ s1318;-  const SWord32 s1320 = s1303 ^ s1319;-  const SWord16 s1321 = (SWord16) (s1320 >> 16);-  const SWord8  s1322 = (SWord8) (s1321 >> 8);-  const SWord32 s1323 = table1[s1322];-  const SWord8  s1324 = (SWord8) (s780 >> 8);-  const SWord32 s1325 = table1[s1324];-  const SWord16 s1326 = (SWord16) (s1039 >> 16);-  const SWord8  s1327 = (SWord8) s1326;-  const SWord32 s1328 = table2[s1327];-  const SWord32 s1329 = s1325 ^ s1328;-  const SWord8  s1330 = (SWord8) (s1300 >> 8);-  const SWord32 s1331 = table3[s1330];-  const SWord32 s1332 = s1329 ^ s1331;-  const SWord16 s1333 = (SWord16) s520;-  const SWord8  s1334 = (SWord8) s1333;-  const SWord32 s1335 = table4[s1334];-  const SWord32 s1336 = s1332 ^ s1335;-  const SWord32 s1337 = s5 ^ s1319;-  const SWord32 s1338 = s1336 ^ s1337;-  const SWord16 s1339 = (SWord16) (s1338 >> 16);-  const SWord8  s1340 = (SWord8) s1339;-  const SWord32 s1341 = table2[s1340];-  const SWord32 s1342 = s1323 ^ s1341;-  const SWord8  s1343 = (SWord8) (s1326 >> 8);-  const SWord32 s1344 = table1[s1343];-  const SWord16 s1345 = (SWord16) (s1299 >> 16);-  const SWord8  s1346 = (SWord8) s1345;-  const SWord32 s1347 = table2[s1346];-  const SWord32 s1348 = s1344 ^ s1347;-  const SWord8  s1349 = (SWord8) (s1333 >> 8);-  const SWord32 s1350 = table3[s1349];-  const SWord32 s1351 = s1348 ^ s1350;-  const SWord16 s1352 = (SWord16) s779;-  const SWord8  s1353 = (SWord8) s1352;-  const SWord32 s1354 = table4[s1353];-  const SWord32 s1355 = s1351 ^ s1354;-  const SWord32 s1356 = s6 ^ s1337;-  const SWord32 s1357 = s1355 ^ s1356;-  const SWord16 s1358 = (SWord16) s1357;-  const SWord8  s1359 = (SWord8) (s1358 >> 8);-  const SWord32 s1360 = table3[s1359];-  const SWord32 s1361 = s1342 ^ s1360;-  const SWord8  s1362 = (SWord8) (s1345 >> 8);-  const SWord32 s1363 = table1[s1362];-  const SWord8  s1364 = (SWord8) s521;-  const SWord32 s1365 = table2[s1364];-  const SWord32 s1366 = s1363 ^ s1365;-  const SWord8  s1367 = (SWord8) (s1352 >> 8);-  const SWord32 s1368 = table3[s1367];-  const SWord32 s1369 = s1366 ^ s1368;-  const SWord8  s1370 = (SWord8) s1040;-  const SWord32 s1371 = table4[s1370];-  const SWord32 s1372 = s1369 ^ s1371;-  const SWord32 s1373 = s7 ^ s1356;-  const SWord32 s1374 = s1372 ^ s1373;-  const SWord16 s1375 = (SWord16) s1374;-  const SWord8  s1376 = (SWord8) s1375;-  const SWord32 s1377 = table4[s1376];-  const SWord32 s1378 = s1361 ^ s1377;-  const SWord32 s1379 = (s1373 << 8) | (s1373 >> 24);-  const SWord16 s1380 = (SWord16) (s1379 >> 16);-  const SWord8  s1381 = (SWord8) (s1380 >> 8);-  const SWord8  s1382 = table0[s1381];-  const SWord8  s1383 = 2 ^ s1382;-  const SWord8  s1384 = (SWord8) s1380;-  const SWord8  s1385 = table0[s1384];-  const SWord16 s1386 = (((SWord16) s1383) << 8) | ((SWord16) s1385);-  const SWord16 s1387 = (SWord16) s1379;-  const SWord8  s1388 = (SWord8) (s1387 >> 8);-  const SWord8  s1389 = table0[s1388];-  const SWord8  s1390 = (SWord8) s1387;-  const SWord8  s1391 = table0[s1390];-  const SWord16 s1392 = (((SWord16) s1389) << 8) | ((SWord16) s1391);-  const SWord32 s1393 = (((SWord32) s1386) << 16) | ((SWord32) s1392);-  const SWord32 s1394 = s1319 ^ s1393;-  const SWord32 s1395 = s1378 ^ s1394;-  const SWord16 s1396 = (SWord16) (s1395 >> 16);-  const SWord8  s1397 = (SWord8) (s1396 >> 8);-  const SWord32 s1398 = table1[s1397];-  const SWord8  s1399 = (SWord8) (s1339 >> 8);-  const SWord32 s1400 = table1[s1399];-  const SWord16 s1401 = (SWord16) (s1357 >> 16);-  const SWord8  s1402 = (SWord8) s1401;-  const SWord32 s1403 = table2[s1402];-  const SWord32 s1404 = s1400 ^ s1403;-  const SWord8  s1405 = (SWord8) (s1375 >> 8);-  const SWord32 s1406 = table3[s1405];-  const SWord32 s1407 = s1404 ^ s1406;-  const SWord16 s1408 = (SWord16) s1320;-  const SWord8  s1409 = (SWord8) s1408;-  const SWord32 s1410 = table4[s1409];-  const SWord32 s1411 = s1407 ^ s1410;-  const SWord32 s1412 = s1337 ^ s1394;-  const SWord32 s1413 = s1411 ^ s1412;-  const SWord16 s1414 = (SWord16) (s1413 >> 16);-  const SWord8  s1415 = (SWord8) s1414;-  const SWord32 s1416 = table2[s1415];-  const SWord32 s1417 = s1398 ^ s1416;-  const SWord8  s1418 = (SWord8) (s1401 >> 8);-  const SWord32 s1419 = table1[s1418];-  const SWord16 s1420 = (SWord16) (s1374 >> 16);-  const SWord8  s1421 = (SWord8) s1420;-  const SWord32 s1422 = table2[s1421];-  const SWord32 s1423 = s1419 ^ s1422;-  const SWord8  s1424 = (SWord8) (s1408 >> 8);-  const SWord32 s1425 = table3[s1424];-  const SWord32 s1426 = s1423 ^ s1425;-  const SWord16 s1427 = (SWord16) s1338;-  const SWord8  s1428 = (SWord8) s1427;-  const SWord32 s1429 = table4[s1428];-  const SWord32 s1430 = s1426 ^ s1429;-  const SWord32 s1431 = s1356 ^ s1412;-  const SWord32 s1432 = s1430 ^ s1431;-  const SWord16 s1433 = (SWord16) s1432;-  const SWord8  s1434 = (SWord8) (s1433 >> 8);-  const SWord32 s1435 = table3[s1434];-  const SWord32 s1436 = s1417 ^ s1435;-  const SWord8  s1437 = (SWord8) (s1420 >> 8);-  const SWord32 s1438 = table1[s1437];-  const SWord8  s1439 = (SWord8) s1321;-  const SWord32 s1440 = table2[s1439];-  const SWord32 s1441 = s1438 ^ s1440;-  const SWord8  s1442 = (SWord8) (s1427 >> 8);-  const SWord32 s1443 = table3[s1442];-  const SWord32 s1444 = s1441 ^ s1443;-  const SWord8  s1445 = (SWord8) s1358;-  const SWord32 s1446 = table4[s1445];-  const SWord32 s1447 = s1444 ^ s1446;-  const SWord32 s1448 = s1373 ^ s1431;-  const SWord32 s1449 = s1447 ^ s1448;-  const SWord16 s1450 = (SWord16) s1449;-  const SWord8  s1451 = (SWord8) s1450;-  const SWord32 s1452 = table4[s1451];-  const SWord32 s1453 = s1436 ^ s1452;-  const SWord32 s1454 = (s1448 << 8) | (s1448 >> 24);-  const SWord16 s1455 = (SWord16) (s1454 >> 16);-  const SWord8  s1456 = (SWord8) (s1455 >> 8);-  const SWord8  s1457 = table0[s1456];-  const SWord8  s1458 = 4 ^ s1457;-  const SWord8  s1459 = (SWord8) s1455;-  const SWord8  s1460 = table0[s1459];-  const SWord16 s1461 = (((SWord16) s1458) << 8) | ((SWord16) s1460);-  const SWord16 s1462 = (SWord16) s1454;-  const SWord8  s1463 = (SWord8) (s1462 >> 8);-  const SWord8  s1464 = table0[s1463];-  const SWord8  s1465 = (SWord8) s1462;-  const SWord8  s1466 = table0[s1465];-  const SWord16 s1467 = (((SWord16) s1464) << 8) | ((SWord16) s1466);-  const SWord32 s1468 = (((SWord32) s1461) << 16) | ((SWord32) s1467);-  const SWord32 s1469 = s1394 ^ s1468;-  const SWord32 s1470 = s1453 ^ s1469;-  const SWord16 s1471 = (SWord16) (s1470 >> 16);-  const SWord8  s1472 = (SWord8) (s1471 >> 8);-  const SWord32 s1473 = table1[s1472];-  const SWord8  s1474 = (SWord8) (s1414 >> 8);-  const SWord32 s1475 = table1[s1474];-  const SWord16 s1476 = (SWord16) (s1432 >> 16);-  const SWord8  s1477 = (SWord8) s1476;-  const SWord32 s1478 = table2[s1477];-  const SWord32 s1479 = s1475 ^ s1478;-  const SWord8  s1480 = (SWord8) (s1450 >> 8);-  const SWord32 s1481 = table3[s1480];-  const SWord32 s1482 = s1479 ^ s1481;-  const SWord16 s1483 = (SWord16) s1395;-  const SWord8  s1484 = (SWord8) s1483;-  const SWord32 s1485 = table4[s1484];-  const SWord32 s1486 = s1482 ^ s1485;-  const SWord32 s1487 = s1412 ^ s1469;-  const SWord32 s1488 = s1486 ^ s1487;-  const SWord16 s1489 = (SWord16) (s1488 >> 16);-  const SWord8  s1490 = (SWord8) s1489;-  const SWord32 s1491 = table2[s1490];-  const SWord32 s1492 = s1473 ^ s1491;-  const SWord8  s1493 = (SWord8) (s1476 >> 8);-  const SWord32 s1494 = table1[s1493];-  const SWord16 s1495 = (SWord16) (s1449 >> 16);-  const SWord8  s1496 = (SWord8) s1495;-  const SWord32 s1497 = table2[s1496];-  const SWord32 s1498 = s1494 ^ s1497;-  const SWord8  s1499 = (SWord8) (s1483 >> 8);-  const SWord32 s1500 = table3[s1499];-  const SWord32 s1501 = s1498 ^ s1500;-  const SWord16 s1502 = (SWord16) s1413;-  const SWord8  s1503 = (SWord8) s1502;-  const SWord32 s1504 = table4[s1503];-  const SWord32 s1505 = s1501 ^ s1504;-  const SWord32 s1506 = s1431 ^ s1487;-  const SWord32 s1507 = s1505 ^ s1506;-  const SWord16 s1508 = (SWord16) s1507;-  const SWord8  s1509 = (SWord8) (s1508 >> 8);-  const SWord32 s1510 = table3[s1509];-  const SWord32 s1511 = s1492 ^ s1510;-  const SWord8  s1512 = (SWord8) (s1495 >> 8);-  const SWord32 s1513 = table1[s1512];-  const SWord8  s1514 = (SWord8) s1396;-  const SWord32 s1515 = table2[s1514];-  const SWord32 s1516 = s1513 ^ s1515;-  const SWord8  s1517 = (SWord8) (s1502 >> 8);-  const SWord32 s1518 = table3[s1517];-  const SWord32 s1519 = s1516 ^ s1518;-  const SWord8  s1520 = (SWord8) s1433;-  const SWord32 s1521 = table4[s1520];-  const SWord32 s1522 = s1519 ^ s1521;-  const SWord32 s1523 = s1448 ^ s1506;-  const SWord32 s1524 = s1522 ^ s1523;-  const SWord16 s1525 = (SWord16) s1524;-  const SWord8  s1526 = (SWord8) s1525;-  const SWord32 s1527 = table4[s1526];-  const SWord32 s1528 = s1511 ^ s1527;-  const SWord32 s1529 = (s1523 << 8) | (s1523 >> 24);-  const SWord16 s1530 = (SWord16) (s1529 >> 16);-  const SWord8  s1531 = (SWord8) (s1530 >> 8);-  const SWord8  s1532 = table0[s1531];-  const SWord8  s1533 = 8 ^ s1532;-  const SWord8  s1534 = (SWord8) s1530;-  const SWord8  s1535 = table0[s1534];-  const SWord16 s1536 = (((SWord16) s1533) << 8) | ((SWord16) s1535);-  const SWord16 s1537 = (SWord16) s1529;-  const SWord8  s1538 = (SWord8) (s1537 >> 8);-  const SWord8  s1539 = table0[s1538];-  const SWord8  s1540 = (SWord8) s1537;-  const SWord8  s1541 = table0[s1540];-  const SWord16 s1542 = (((SWord16) s1539) << 8) | ((SWord16) s1541);-  const SWord32 s1543 = (((SWord32) s1536) << 16) | ((SWord32) s1542);-  const SWord32 s1544 = s1469 ^ s1543;-  const SWord32 s1545 = s1528 ^ s1544;-  const SWord16 s1546 = (SWord16) (s1545 >> 16);-  const SWord8  s1547 = (SWord8) (s1546 >> 8);-  const SWord32 s1548 = table1[s1547];-  const SWord8  s1549 = (SWord8) (s1489 >> 8);-  const SWord32 s1550 = table1[s1549];-  const SWord16 s1551 = (SWord16) (s1507 >> 16);-  const SWord8  s1552 = (SWord8) s1551;-  const SWord32 s1553 = table2[s1552];-  const SWord32 s1554 = s1550 ^ s1553;-  const SWord8  s1555 = (SWord8) (s1525 >> 8);-  const SWord32 s1556 = table3[s1555];-  const SWord32 s1557 = s1554 ^ s1556;-  const SWord16 s1558 = (SWord16) s1470;-  const SWord8  s1559 = (SWord8) s1558;-  const SWord32 s1560 = table4[s1559];-  const SWord32 s1561 = s1557 ^ s1560;-  const SWord32 s1562 = s1487 ^ s1544;-  const SWord32 s1563 = s1561 ^ s1562;-  const SWord16 s1564 = (SWord16) (s1563 >> 16);-  const SWord8  s1565 = (SWord8) s1564;-  const SWord32 s1566 = table2[s1565];-  const SWord32 s1567 = s1548 ^ s1566;-  const SWord8  s1568 = (SWord8) (s1551 >> 8);-  const SWord32 s1569 = table1[s1568];-  const SWord16 s1570 = (SWord16) (s1524 >> 16);-  const SWord8  s1571 = (SWord8) s1570;-  const SWord32 s1572 = table2[s1571];-  const SWord32 s1573 = s1569 ^ s1572;-  const SWord8  s1574 = (SWord8) (s1558 >> 8);-  const SWord32 s1575 = table3[s1574];-  const SWord32 s1576 = s1573 ^ s1575;-  const SWord16 s1577 = (SWord16) s1488;-  const SWord8  s1578 = (SWord8) s1577;-  const SWord32 s1579 = table4[s1578];-  const SWord32 s1580 = s1576 ^ s1579;-  const SWord32 s1581 = s1506 ^ s1562;-  const SWord32 s1582 = s1580 ^ s1581;-  const SWord16 s1583 = (SWord16) s1582;-  const SWord8  s1584 = (SWord8) (s1583 >> 8);-  const SWord32 s1585 = table3[s1584];-  const SWord32 s1586 = s1567 ^ s1585;-  const SWord8  s1587 = (SWord8) (s1570 >> 8);-  const SWord32 s1588 = table1[s1587];-  const SWord8  s1589 = (SWord8) s1471;-  const SWord32 s1590 = table2[s1589];-  const SWord32 s1591 = s1588 ^ s1590;-  const SWord8  s1592 = (SWord8) (s1577 >> 8);-  const SWord32 s1593 = table3[s1592];-  const SWord32 s1594 = s1591 ^ s1593;-  const SWord8  s1595 = (SWord8) s1508;-  const SWord32 s1596 = table4[s1595];-  const SWord32 s1597 = s1594 ^ s1596;-  const SWord32 s1598 = s1523 ^ s1581;-  const SWord32 s1599 = s1597 ^ s1598;-  const SWord16 s1600 = (SWord16) s1599;-  const SWord8  s1601 = (SWord8) s1600;-  const SWord32 s1602 = table4[s1601];-  const SWord32 s1603 = s1586 ^ s1602;-  const SWord32 s1604 = (s1598 << 8) | (s1598 >> 24);-  const SWord16 s1605 = (SWord16) (s1604 >> 16);-  const SWord8  s1606 = (SWord8) (s1605 >> 8);-  const SWord8  s1607 = table0[s1606];-  const SWord8  s1608 = 16 ^ s1607;-  const SWord8  s1609 = (SWord8) s1605;-  const SWord8  s1610 = table0[s1609];-  const SWord16 s1611 = (((SWord16) s1608) << 8) | ((SWord16) s1610);-  const SWord16 s1612 = (SWord16) s1604;-  const SWord8  s1613 = (SWord8) (s1612 >> 8);-  const SWord8  s1614 = table0[s1613];-  const SWord8  s1615 = (SWord8) s1612;-  const SWord8  s1616 = table0[s1615];-  const SWord16 s1617 = (((SWord16) s1614) << 8) | ((SWord16) s1616);-  const SWord32 s1618 = (((SWord32) s1611) << 16) | ((SWord32) s1617);-  const SWord32 s1619 = s1544 ^ s1618;-  const SWord32 s1620 = s1603 ^ s1619;-  const SWord16 s1621 = (SWord16) (s1620 >> 16);-  const SWord8  s1622 = (SWord8) (s1621 >> 8);-  const SWord32 s1623 = table1[s1622];-  const SWord8  s1624 = (SWord8) (s1564 >> 8);-  const SWord32 s1625 = table1[s1624];-  const SWord16 s1626 = (SWord16) (s1582 >> 16);-  const SWord8  s1627 = (SWord8) s1626;-  const SWord32 s1628 = table2[s1627];-  const SWord32 s1629 = s1625 ^ s1628;-  const SWord8  s1630 = (SWord8) (s1600 >> 8);-  const SWord32 s1631 = table3[s1630];-  const SWord32 s1632 = s1629 ^ s1631;-  const SWord16 s1633 = (SWord16) s1545;-  const SWord8  s1634 = (SWord8) s1633;-  const SWord32 s1635 = table4[s1634];-  const SWord32 s1636 = s1632 ^ s1635;-  const SWord32 s1637 = s1562 ^ s1619;-  const SWord32 s1638 = s1636 ^ s1637;-  const SWord16 s1639 = (SWord16) (s1638 >> 16);-  const SWord8  s1640 = (SWord8) s1639;-  const SWord32 s1641 = table2[s1640];-  const SWord32 s1642 = s1623 ^ s1641;-  const SWord8  s1643 = (SWord8) (s1626 >> 8);-  const SWord32 s1644 = table1[s1643];-  const SWord16 s1645 = (SWord16) (s1599 >> 16);-  const SWord8  s1646 = (SWord8) s1645;-  const SWord32 s1647 = table2[s1646];-  const SWord32 s1648 = s1644 ^ s1647;-  const SWord8  s1649 = (SWord8) (s1633 >> 8);-  const SWord32 s1650 = table3[s1649];-  const SWord32 s1651 = s1648 ^ s1650;-  const SWord16 s1652 = (SWord16) s1563;-  const SWord8  s1653 = (SWord8) s1652;-  const SWord32 s1654 = table4[s1653];-  const SWord32 s1655 = s1651 ^ s1654;-  const SWord32 s1656 = s1581 ^ s1637;-  const SWord32 s1657 = s1655 ^ s1656;-  const SWord16 s1658 = (SWord16) s1657;-  const SWord8  s1659 = (SWord8) (s1658 >> 8);-  const SWord32 s1660 = table3[s1659];-  const SWord32 s1661 = s1642 ^ s1660;-  const SWord8  s1662 = (SWord8) (s1645 >> 8);-  const SWord32 s1663 = table1[s1662];-  const SWord8  s1664 = (SWord8) s1546;-  const SWord32 s1665 = table2[s1664];-  const SWord32 s1666 = s1663 ^ s1665;-  const SWord8  s1667 = (SWord8) (s1652 >> 8);-  const SWord32 s1668 = table3[s1667];-  const SWord32 s1669 = s1666 ^ s1668;-  const SWord8  s1670 = (SWord8) s1583;-  const SWord32 s1671 = table4[s1670];-  const SWord32 s1672 = s1669 ^ s1671;-  const SWord32 s1673 = s1598 ^ s1656;-  const SWord32 s1674 = s1672 ^ s1673;-  const SWord16 s1675 = (SWord16) s1674;-  const SWord8  s1676 = (SWord8) s1675;-  const SWord32 s1677 = table4[s1676];-  const SWord32 s1678 = s1661 ^ s1677;-  const SWord32 s1679 = (s1673 << 8) | (s1673 >> 24);-  const SWord16 s1680 = (SWord16) (s1679 >> 16);-  const SWord8  s1681 = (SWord8) (s1680 >> 8);-  const SWord8  s1682 = table0[s1681];-  const SWord8  s1683 = 32 ^ s1682;-  const SWord8  s1684 = (SWord8) s1680;-  const SWord8  s1685 = table0[s1684];-  const SWord16 s1686 = (((SWord16) s1683) << 8) | ((SWord16) s1685);-  const SWord16 s1687 = (SWord16) s1679;-  const SWord8  s1688 = (SWord8) (s1687 >> 8);-  const SWord8  s1689 = table0[s1688];-  const SWord8  s1690 = (SWord8) s1687;-  const SWord8  s1691 = table0[s1690];-  const SWord16 s1692 = (((SWord16) s1689) << 8) | ((SWord16) s1691);-  const SWord32 s1693 = (((SWord32) s1686) << 16) | ((SWord32) s1692);-  const SWord32 s1694 = s1619 ^ s1693;-  const SWord32 s1695 = s1678 ^ s1694;-  const SWord16 s1696 = (SWord16) (s1695 >> 16);-  const SWord8  s1697 = (SWord8) (s1696 >> 8);-  const SWord32 s1698 = table1[s1697];-  const SWord8  s1699 = (SWord8) (s1639 >> 8);-  const SWord32 s1700 = table1[s1699];-  const SWord16 s1701 = (SWord16) (s1657 >> 16);-  const SWord8  s1702 = (SWord8) s1701;-  const SWord32 s1703 = table2[s1702];-  const SWord32 s1704 = s1700 ^ s1703;-  const SWord8  s1705 = (SWord8) (s1675 >> 8);-  const SWord32 s1706 = table3[s1705];-  const SWord32 s1707 = s1704 ^ s1706;-  const SWord16 s1708 = (SWord16) s1620;-  const SWord8  s1709 = (SWord8) s1708;-  const SWord32 s1710 = table4[s1709];-  const SWord32 s1711 = s1707 ^ s1710;-  const SWord32 s1712 = s1637 ^ s1694;-  const SWord32 s1713 = s1711 ^ s1712;-  const SWord16 s1714 = (SWord16) (s1713 >> 16);-  const SWord8  s1715 = (SWord8) s1714;-  const SWord32 s1716 = table2[s1715];-  const SWord32 s1717 = s1698 ^ s1716;-  const SWord8  s1718 = (SWord8) (s1701 >> 8);-  const SWord32 s1719 = table1[s1718];-  const SWord16 s1720 = (SWord16) (s1674 >> 16);-  const SWord8  s1721 = (SWord8) s1720;-  const SWord32 s1722 = table2[s1721];-  const SWord32 s1723 = s1719 ^ s1722;-  const SWord8  s1724 = (SWord8) (s1708 >> 8);-  const SWord32 s1725 = table3[s1724];-  const SWord32 s1726 = s1723 ^ s1725;-  const SWord16 s1727 = (SWord16) s1638;-  const SWord8  s1728 = (SWord8) s1727;-  const SWord32 s1729 = table4[s1728];-  const SWord32 s1730 = s1726 ^ s1729;-  const SWord32 s1731 = s1656 ^ s1712;-  const SWord32 s1732 = s1730 ^ s1731;-  const SWord16 s1733 = (SWord16) s1732;-  const SWord8  s1734 = (SWord8) (s1733 >> 8);-  const SWord32 s1735 = table3[s1734];-  const SWord32 s1736 = s1717 ^ s1735;-  const SWord8  s1737 = (SWord8) (s1720 >> 8);-  const SWord32 s1738 = table1[s1737];-  const SWord8  s1739 = (SWord8) s1621;-  const SWord32 s1740 = table2[s1739];-  const SWord32 s1741 = s1738 ^ s1740;-  const SWord8  s1742 = (SWord8) (s1727 >> 8);-  const SWord32 s1743 = table3[s1742];-  const SWord32 s1744 = s1741 ^ s1743;-  const SWord8  s1745 = (SWord8) s1658;-  const SWord32 s1746 = table4[s1745];-  const SWord32 s1747 = s1744 ^ s1746;-  const SWord32 s1748 = s1673 ^ s1731;-  const SWord32 s1749 = s1747 ^ s1748;-  const SWord16 s1750 = (SWord16) s1749;-  const SWord8  s1751 = (SWord8) s1750;-  const SWord32 s1752 = table4[s1751];-  const SWord32 s1753 = s1736 ^ s1752;-  const SWord32 s1754 = (s1748 << 8) | (s1748 >> 24);-  const SWord16 s1755 = (SWord16) (s1754 >> 16);-  const SWord8  s1756 = (SWord8) (s1755 >> 8);-  const SWord8  s1757 = table0[s1756];-  const SWord8  s1758 = 64 ^ s1757;-  const SWord8  s1759 = (SWord8) s1755;-  const SWord8  s1760 = table0[s1759];-  const SWord16 s1761 = (((SWord16) s1758) << 8) | ((SWord16) s1760);-  const SWord16 s1762 = (SWord16) s1754;-  const SWord8  s1763 = (SWord8) (s1762 >> 8);-  const SWord8  s1764 = table0[s1763];-  const SWord8  s1765 = (SWord8) s1762;-  const SWord8  s1766 = table0[s1765];-  const SWord16 s1767 = (((SWord16) s1764) << 8) | ((SWord16) s1766);-  const SWord32 s1768 = (((SWord32) s1761) << 16) | ((SWord32) s1767);-  const SWord32 s1769 = s1694 ^ s1768;-  const SWord32 s1770 = s1753 ^ s1769;-  const SWord16 s1771 = (SWord16) (s1770 >> 16);-  const SWord8  s1772 = (SWord8) (s1771 >> 8);-  const SWord32 s1773 = table1[s1772];-  const SWord8  s1774 = (SWord8) (s1714 >> 8);-  const SWord32 s1775 = table1[s1774];-  const SWord16 s1776 = (SWord16) (s1732 >> 16);-  const SWord8  s1777 = (SWord8) s1776;-  const SWord32 s1778 = table2[s1777];-  const SWord32 s1779 = s1775 ^ s1778;-  const SWord8  s1780 = (SWord8) (s1750 >> 8);-  const SWord32 s1781 = table3[s1780];-  const SWord32 s1782 = s1779 ^ s1781;-  const SWord16 s1783 = (SWord16) s1695;-  const SWord8  s1784 = (SWord8) s1783;-  const SWord32 s1785 = table4[s1784];-  const SWord32 s1786 = s1782 ^ s1785;-  const SWord32 s1787 = s1712 ^ s1769;-  const SWord32 s1788 = s1786 ^ s1787;-  const SWord16 s1789 = (SWord16) (s1788 >> 16);-  const SWord8  s1790 = (SWord8) s1789;-  const SWord32 s1791 = table2[s1790];-  const SWord32 s1792 = s1773 ^ s1791;-  const SWord8  s1793 = (SWord8) (s1776 >> 8);-  const SWord32 s1794 = table1[s1793];-  const SWord16 s1795 = (SWord16) (s1749 >> 16);-  const SWord8  s1796 = (SWord8) s1795;-  const SWord32 s1797 = table2[s1796];-  const SWord32 s1798 = s1794 ^ s1797;-  const SWord8  s1799 = (SWord8) (s1783 >> 8);-  const SWord32 s1800 = table3[s1799];-  const SWord32 s1801 = s1798 ^ s1800;-  const SWord16 s1802 = (SWord16) s1713;-  const SWord8  s1803 = (SWord8) s1802;-  const SWord32 s1804 = table4[s1803];-  const SWord32 s1805 = s1801 ^ s1804;-  const SWord32 s1806 = s1731 ^ s1787;-  const SWord32 s1807 = s1805 ^ s1806;-  const SWord16 s1808 = (SWord16) s1807;-  const SWord8  s1809 = (SWord8) (s1808 >> 8);-  const SWord32 s1810 = table3[s1809];-  const SWord32 s1811 = s1792 ^ s1810;-  const SWord8  s1812 = (SWord8) (s1795 >> 8);-  const SWord32 s1813 = table1[s1812];-  const SWord8  s1814 = (SWord8) s1696;-  const SWord32 s1815 = table2[s1814];-  const SWord32 s1816 = s1813 ^ s1815;-  const SWord8  s1817 = (SWord8) (s1802 >> 8);-  const SWord32 s1818 = table3[s1817];-  const SWord32 s1819 = s1816 ^ s1818;-  const SWord8  s1820 = (SWord8) s1733;-  const SWord32 s1821 = table4[s1820];-  const SWord32 s1822 = s1819 ^ s1821;-  const SWord32 s1823 = s1748 ^ s1806;-  const SWord32 s1824 = s1822 ^ s1823;-  const SWord16 s1825 = (SWord16) s1824;-  const SWord8  s1826 = (SWord8) s1825;-  const SWord32 s1827 = table4[s1826];-  const SWord32 s1828 = s1811 ^ s1827;-  const SWord32 s1829 = (s1823 << 8) | (s1823 >> 24);-  const SWord16 s1830 = (SWord16) (s1829 >> 16);-  const SWord8  s1831 = (SWord8) (s1830 >> 8);-  const SWord8  s1832 = table0[s1831];-  const SWord8  s1833 = 128 ^ s1832;-  const SWord8  s1834 = (SWord8) s1830;-  const SWord8  s1835 = table0[s1834];-  const SWord16 s1836 = (((SWord16) s1833) << 8) | ((SWord16) s1835);-  const SWord16 s1837 = (SWord16) s1829;-  const SWord8  s1838 = (SWord8) (s1837 >> 8);-  const SWord8  s1839 = table0[s1838];-  const SWord8  s1840 = (SWord8) s1837;-  const SWord8  s1841 = table0[s1840];-  const SWord16 s1842 = (((SWord16) s1839) << 8) | ((SWord16) s1841);-  const SWord32 s1843 = (((SWord32) s1836) << 16) | ((SWord32) s1842);-  const SWord32 s1844 = s1769 ^ s1843;-  const SWord32 s1845 = s1828 ^ s1844;-  const SWord16 s1846 = (SWord16) (s1845 >> 16);-  const SWord8  s1847 = (SWord8) (s1846 >> 8);-  const SWord32 s1848 = table1[s1847];-  const SWord8  s1849 = (SWord8) (s1789 >> 8);-  const SWord32 s1850 = table1[s1849];-  const SWord16 s1851 = (SWord16) (s1807 >> 16);-  const SWord8  s1852 = (SWord8) s1851;-  const SWord32 s1853 = table2[s1852];-  const SWord32 s1854 = s1850 ^ s1853;-  const SWord8  s1855 = (SWord8) (s1825 >> 8);-  const SWord32 s1856 = table3[s1855];-  const SWord32 s1857 = s1854 ^ s1856;-  const SWord16 s1858 = (SWord16) s1770;-  const SWord8  s1859 = (SWord8) s1858;-  const SWord32 s1860 = table4[s1859];-  const SWord32 s1861 = s1857 ^ s1860;-  const SWord32 s1862 = s1787 ^ s1844;-  const SWord32 s1863 = s1861 ^ s1862;-  const SWord16 s1864 = (SWord16) (s1863 >> 16);-  const SWord8  s1865 = (SWord8) s1864;-  const SWord32 s1866 = table2[s1865];-  const SWord32 s1867 = s1848 ^ s1866;-  const SWord8  s1868 = (SWord8) (s1851 >> 8);-  const SWord32 s1869 = table1[s1868];-  const SWord16 s1870 = (SWord16) (s1824 >> 16);-  const SWord8  s1871 = (SWord8) s1870;-  const SWord32 s1872 = table2[s1871];-  const SWord32 s1873 = s1869 ^ s1872;-  const SWord8  s1874 = (SWord8) (s1858 >> 8);-  const SWord32 s1875 = table3[s1874];-  const SWord32 s1876 = s1873 ^ s1875;-  const SWord16 s1877 = (SWord16) s1788;-  const SWord8  s1878 = (SWord8) s1877;-  const SWord32 s1879 = table4[s1878];-  const SWord32 s1880 = s1876 ^ s1879;-  const SWord32 s1881 = s1806 ^ s1862;-  const SWord32 s1882 = s1880 ^ s1881;-  const SWord16 s1883 = (SWord16) s1882;-  const SWord8  s1884 = (SWord8) (s1883 >> 8);-  const SWord32 s1885 = table3[s1884];-  const SWord32 s1886 = s1867 ^ s1885;-  const SWord8  s1887 = (SWord8) (s1870 >> 8);-  const SWord32 s1888 = table1[s1887];-  const SWord8  s1889 = (SWord8) s1771;-  const SWord32 s1890 = table2[s1889];-  const SWord32 s1891 = s1888 ^ s1890;-  const SWord8  s1892 = (SWord8) (s1877 >> 8);-  const SWord32 s1893 = table3[s1892];-  const SWord32 s1894 = s1891 ^ s1893;-  const SWord8  s1895 = (SWord8) s1808;-  const SWord32 s1896 = table4[s1895];-  const SWord32 s1897 = s1894 ^ s1896;-  const SWord32 s1898 = s1823 ^ s1881;-  const SWord32 s1899 = s1897 ^ s1898;-  const SWord16 s1900 = (SWord16) s1899;-  const SWord8  s1901 = (SWord8) s1900;-  const SWord32 s1902 = table4[s1901];-  const SWord32 s1903 = s1886 ^ s1902;-  const SWord32 s1904 = (s1898 << 8) | (s1898 >> 24);-  const SWord16 s1905 = (SWord16) (s1904 >> 16);-  const SWord8  s1906 = (SWord8) (s1905 >> 8);-  const SWord8  s1907 = table0[s1906];-  const SWord8  s1908 = 27 ^ s1907;-  const SWord8  s1909 = (SWord8) s1905;-  const SWord8  s1910 = table0[s1909];-  const SWord16 s1911 = (((SWord16) s1908) << 8) | ((SWord16) s1910);-  const SWord16 s1912 = (SWord16) s1904;-  const SWord8  s1913 = (SWord8) (s1912 >> 8);-  const SWord8  s1914 = table0[s1913];-  const SWord8  s1915 = (SWord8) s1912;-  const SWord8  s1916 = table0[s1915];-  const SWord16 s1917 = (((SWord16) s1914) << 8) | ((SWord16) s1916);-  const SWord32 s1918 = (((SWord32) s1911) << 16) | ((SWord32) s1917);-  const SWord32 s1919 = s1844 ^ s1918;-  const SWord32 s1920 = s1903 ^ s1919;-  const SWord16 s1921 = (SWord16) (s1920 >> 16);-  const SWord8  s1922 = (SWord8) (s1921 >> 8);-  const SWord8  s1923 = table0[s1922];-  const SWord8  s1924 = (SWord8) (s1864 >> 8);-  const SWord32 s1925 = table1[s1924];-  const SWord16 s1926 = (SWord16) (s1882 >> 16);-  const SWord8  s1927 = (SWord8) s1926;-  const SWord32 s1928 = table2[s1927];-  const SWord32 s1929 = s1925 ^ s1928;-  const SWord8  s1930 = (SWord8) (s1900 >> 8);-  const SWord32 s1931 = table3[s1930];-  const SWord32 s1932 = s1929 ^ s1931;-  const SWord16 s1933 = (SWord16) s1845;-  const SWord8  s1934 = (SWord8) s1933;-  const SWord32 s1935 = table4[s1934];-  const SWord32 s1936 = s1932 ^ s1935;-  const SWord32 s1937 = s1862 ^ s1919;-  const SWord32 s1938 = s1936 ^ s1937;-  const SWord16 s1939 = (SWord16) (s1938 >> 16);-  const SWord8  s1940 = (SWord8) s1939;-  const SWord8  s1941 = table0[s1940];-  const SWord16 s1942 = (((SWord16) s1923) << 8) | ((SWord16) s1941);-  const SWord8  s1943 = (SWord8) (s1926 >> 8);-  const SWord32 s1944 = table1[s1943];-  const SWord16 s1945 = (SWord16) (s1899 >> 16);-  const SWord8  s1946 = (SWord8) s1945;-  const SWord32 s1947 = table2[s1946];-  const SWord32 s1948 = s1944 ^ s1947;-  const SWord8  s1949 = (SWord8) (s1933 >> 8);-  const SWord32 s1950 = table3[s1949];-  const SWord32 s1951 = s1948 ^ s1950;-  const SWord16 s1952 = (SWord16) s1863;-  const SWord8  s1953 = (SWord8) s1952;-  const SWord32 s1954 = table4[s1953];-  const SWord32 s1955 = s1951 ^ s1954;-  const SWord32 s1956 = s1881 ^ s1937;-  const SWord32 s1957 = s1955 ^ s1956;-  const SWord16 s1958 = (SWord16) s1957;-  const SWord8  s1959 = (SWord8) (s1958 >> 8);-  const SWord8  s1960 = table0[s1959];-  const SWord8  s1961 = (SWord8) (s1945 >> 8);-  const SWord32 s1962 = table1[s1961];-  const SWord8  s1963 = (SWord8) s1846;-  const SWord32 s1964 = table2[s1963];-  const SWord32 s1965 = s1962 ^ s1964;-  const SWord8  s1966 = (SWord8) (s1952 >> 8);-  const SWord32 s1967 = table3[s1966];-  const SWord32 s1968 = s1965 ^ s1967;-  const SWord8  s1969 = (SWord8) s1883;-  const SWord32 s1970 = table4[s1969];-  const SWord32 s1971 = s1968 ^ s1970;-  const SWord32 s1972 = s1898 ^ s1956;-  const SWord32 s1973 = s1971 ^ s1972;-  const SWord16 s1974 = (SWord16) s1973;-  const SWord8  s1975 = (SWord8) s1974;-  const SWord8  s1976 = table0[s1975];-  const SWord16 s1977 = (((SWord16) s1960) << 8) | ((SWord16) s1976);-  const SWord32 s1978 = (((SWord32) s1942) << 16) | ((SWord32) s1977);-  const SWord32 s1979 = (s1972 << 8) | (s1972 >> 24);-  const SWord16 s1980 = (SWord16) (s1979 >> 16);-  const SWord8  s1981 = (SWord8) (s1980 >> 8);-  const SWord8  s1982 = table0[s1981];-  const SWord8  s1983 = 54 ^ s1982;-  const SWord8  s1984 = (SWord8) s1980;-  const SWord8  s1985 = table0[s1984];-  const SWord16 s1986 = (((SWord16) s1983) << 8) | ((SWord16) s1985);-  const SWord16 s1987 = (SWord16) s1979;-  const SWord8  s1988 = (SWord8) (s1987 >> 8);-  const SWord8  s1989 = table0[s1988];-  const SWord8  s1990 = (SWord8) s1987;-  const SWord8  s1991 = table0[s1990];-  const SWord16 s1992 = (((SWord16) s1989) << 8) | ((SWord16) s1991);-  const SWord32 s1993 = (((SWord32) s1986) << 16) | ((SWord32) s1992);-  const SWord32 s1994 = s1919 ^ s1993;-  const SWord32 s1995 = s1978 ^ s1994;-  const SWord8  s1996 = (SWord8) (s1939 >> 8);-  const SWord8  s1997 = table0[s1996];-  const SWord16 s1998 = (SWord16) (s1957 >> 16);-  const SWord8  s1999 = (SWord8) s1998;-  const SWord8  s2000 = table0[s1999];-  const SWord16 s2001 = (((SWord16) s1997) << 8) | ((SWord16) s2000);-  const SWord8  s2002 = (SWord8) (s1974 >> 8);-  const SWord8  s2003 = table0[s2002];-  const SWord16 s2004 = (SWord16) s1920;-  const SWord8  s2005 = (SWord8) s2004;-  const SWord8  s2006 = table0[s2005];-  const SWord16 s2007 = (((SWord16) s2003) << 8) | ((SWord16) s2006);-  const SWord32 s2008 = (((SWord32) s2001) << 16) | ((SWord32) s2007);-  const SWord32 s2009 = s1937 ^ s1994;-  const SWord32 s2010 = s2008 ^ s2009;-  const SWord8  s2011 = (SWord8) (s1998 >> 8);-  const SWord8  s2012 = table0[s2011];-  const SWord16 s2013 = (SWord16) (s1973 >> 16);-  const SWord8  s2014 = (SWord8) s2013;-  const SWord8  s2015 = table0[s2014];-  const SWord16 s2016 = (((SWord16) s2012) << 8) | ((SWord16) s2015);-  const SWord8  s2017 = (SWord8) (s2004 >> 8);-  const SWord8  s2018 = table0[s2017];-  const SWord16 s2019 = (SWord16) s1938;-  const SWord8  s2020 = (SWord8) s2019;-  const SWord8  s2021 = table0[s2020];-  const SWord16 s2022 = (((SWord16) s2018) << 8) | ((SWord16) s2021);-  const SWord32 s2023 = (((SWord32) s2016) << 16) | ((SWord32) s2022);-  const SWord32 s2024 = s1956 ^ s2009;-  const SWord32 s2025 = s2023 ^ s2024;-  const SWord8  s2026 = (SWord8) (s2013 >> 8);-  const SWord8  s2027 = table0[s2026];-  const SWord8  s2028 = (SWord8) s1921;-  const SWord8  s2029 = table0[s2028];-  const SWord16 s2030 = (((SWord16) s2027) << 8) | ((SWord16) s2029);-  const SWord8  s2031 = (SWord8) (s2019 >> 8);-  const SWord8  s2032 = table0[s2031];-  const SWord8  s2033 = (SWord8) s1958;-  const SWord8  s2034 = table0[s2033];-  const SWord16 s2035 = (((SWord16) s2032) << 8) | ((SWord16) s2034);-  const SWord32 s2036 = (((SWord32) s2030) << 16) | ((SWord32) s2035);-  const SWord32 s2037 = s1972 ^ s2024;-  const SWord32 s2038 = s2036 ^ s2037;--  ct[0] = s1995;-  ct[1] = s2010;-  ct[2] = s2025;-  ct[3] = s2038;-}-== END: "aes128Enc.c" ==================
− SBVUnitTest/GoldFiles/aes128Lib.gold 
@@ -1,3772 +0,0 @@-== BEGIN: "aes128KeySchedule.c" ================-/* File: "aes128KeySchedule.c". Automatically generated by SBV. Do not edit! */--#include "aes128Lib.h"--void aes128KeySchedule(const SWord32 *key, SWord32 *encKS,-                       SWord32 *decKS)-{-  const SWord32 s0 = key[0];-  const SWord32 s1 = key[1];-  const SWord32 s2 = key[2];-  const SWord32 s3 = key[3];-  static const SWord8 table0[] = {-       99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254,-      215, 171, 118, 202, 130, 201, 125, 250,  89,  71, 240, 173, 212,-      162, 175, 156, 164, 114, 192, 183, 253, 147,  38,  54,  63, 247,-      204,  52, 165, 229, 241, 113, 216,  49,  21,   4, 199,  35, 195,-       24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,   9,-      131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,-       47, 132,  83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,-       57,  74,  76,  88, 207, 208, 239, 170, 251,  67,  77,  51, 133,-       69, 249,   2, 127,  80,  60, 159, 168,  81, 163,  64, 143, 146,-      157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210, 205,  12,-       19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25,-      115,  96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20,-      222,  94,  11, 219, 224,  50,  58,  10,  73,   6,  36,  92, 194,-      211, 172,  98, 145, 149, 228, 121, 231, 200,  55, 109, 141, 213,-       78, 169, 108,  86, 244, 234, 101, 122, 174,   8, 186, 120,  37,-       46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,-      112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134,-      193,  29, 158, 225, 248, 152,  17, 105, 217, 142, 148, 155,  30,-      135, 233, 206,  85,  40, 223, 140, 161, 137,  13, 191, 230,  66,-      104,  65, 153,  45,  15, 176,  84, 187,  22-  };-  static const SWord8 table1[] = {-        0,  14,  28,  18,  56,  54,  36,  42, 112, 126, 108,  98,  72,-       70,  84,  90, 224, 238, 252, 242, 216, 214, 196, 202, 144, 158,-      140, 130, 168, 166, 180, 186, 219, 213, 199, 201, 227, 237, 255,-      241, 171, 165, 183, 185, 147, 157, 143, 129,  59,  53,  39,  41,-        3,  13,  31,  17,  75,  69,  87,  89, 115, 125, 111,  97, 173,-      163, 177, 191, 149, 155, 137, 135, 221, 211, 193, 207, 229, 235,-      249, 247,  77,  67,  81,  95, 117, 123, 105, 103,  61,  51,  33,-       47,   5,  11,  25,  23, 118, 120, 106, 100,  78,  64,  82,  92,-        6,   8,  26,  20,  62,  48,  34,  44, 150, 152, 138, 132, 174,-      160, 178, 188, 230, 232, 250, 244, 222, 208, 194, 204,  65,  79,-       93,  83, 121, 119, 101, 107,  49,  63,  45,  35,   9,   7,  21,-       27, 161, 175, 189, 179, 153, 151, 133, 139, 209, 223, 205, 195,-      233, 231, 245, 251, 154, 148, 134, 136, 162, 172, 190, 176, 234,-      228, 246, 248, 210, 220, 206, 192, 122, 116, 102, 104,  66,  76,-       94,  80,  10,   4,  22,  24,  50,  60,  46,  32, 236, 226, 240,-      254, 212, 218, 200, 198, 156, 146, 128, 142, 164, 170, 184, 182,-       12,   2,  16,  30,  52,  58,  40,  38, 124, 114,  96, 110,  68,-       74,  88,  86,  55,  57,  43,  37,  15,   1,  19,  29,  71,  73,-       91,  85, 127, 113,  99, 109, 215, 217, 203, 197, 239, 225, 243,-      253, 167, 169, 187, 181, 159, 145, 131, 141-  };-  static const SWord8 table2[] = {-        0,  11,  22,  29,  44,  39,  58,  49,  88,  83,  78,  69, 116,-      127,  98, 105, 176, 187, 166, 173, 156, 151, 138, 129, 232, 227,-      254, 245, 196, 207, 210, 217, 123, 112, 109, 102,  87,  92,  65,-       74,  35,  40,  53,  62,  15,   4,  25,  18, 203, 192, 221, 214,-      231, 236, 241, 250, 147, 152, 133, 142, 191, 180, 169, 162, 246,-      253, 224, 235, 218, 209, 204, 199, 174, 165, 184, 179, 130, 137,-      148, 159,  70,  77,  80,  91, 106,  97, 124, 119,  30,  21,   8,-        3,  50,  57,  36,  47, 141, 134, 155, 144, 161, 170, 183, 188,-      213, 222, 195, 200, 249, 242, 239, 228,  61,  54,  43,  32,  17,-       26,   7,  12, 101, 110, 115, 120,  73,  66,  95,  84, 247, 252,-      225, 234, 219, 208, 205, 198, 175, 164, 185, 178, 131, 136, 149,-      158,  71,  76,  81,  90, 107,  96, 125, 118,  31,  20,   9,   2,-       51,  56,  37,  46, 140, 135, 154, 145, 160, 171, 182, 189, 212,-      223, 194, 201, 248, 243, 238, 229,  60,  55,  42,  33,  16,  27,-        6,  13, 100, 111, 114, 121,  72,  67,  94,  85,   1,  10,  23,-       28,  45,  38,  59,  48,  89,  82,  79,  68, 117, 126,  99, 104,-      177, 186, 167, 172, 157, 150, 139, 128, 233, 226, 255, 244, 197,-      206, 211, 216, 122, 113, 108, 103,  86,  93,  64,  75,  34,  41,-       52,  63,  14,   5,  24,  19, 202, 193, 220, 215, 230, 237, 240,-      251, 146, 153, 132, 143, 190, 181, 168, 163-  };-  static const SWord8 table3[] = {-        0,  13,  26,  23,  52,  57,  46,  35, 104, 101, 114, 127,  92,-       81,  70,  75, 208, 221, 202, 199, 228, 233, 254, 243, 184, 181,-      162, 175, 140, 129, 150, 155, 187, 182, 161, 172, 143, 130, 149,-      152, 211, 222, 201, 196, 231, 234, 253, 240, 107, 102, 113, 124,-       95,  82,  69,  72,   3,  14,  25,  20,  55,  58,  45,  32, 109,-       96, 119, 122,  89,  84,  67,  78,   5,   8,  31,  18,  49,  60,-       43,  38, 189, 176, 167, 170, 137, 132, 147, 158, 213, 216, 207,-      194, 225, 236, 251, 246, 214, 219, 204, 193, 226, 239, 248, 245,-      190, 179, 164, 169, 138, 135, 144, 157,   6,  11,  28,  17,  50,-       63,  40,  37, 110,  99, 116, 121,  90,  87,  64,  77, 218, 215,-      192, 205, 238, 227, 244, 249, 178, 191, 168, 165, 134, 139, 156,-      145,  10,   7,  16,  29,  62,  51,  36,  41,  98, 111, 120, 117,-       86,  91,  76,  65,  97, 108, 123, 118,  85,  88,  79,  66,   9,-        4,  19,  30,  61,  48,  39,  42, 177, 188, 171, 166, 133, 136,-      159, 146, 217, 212, 195, 206, 237, 224, 247, 250, 183, 186, 173,-      160, 131, 142, 153, 148, 223, 210, 197, 200, 235, 230, 241, 252,-      103, 106, 125, 112,  83,  94,  73,  68,  15,   2,  21,  24,  59,-       54,  33,  44,  12,   1,  22,  27,  56,  53,  34,  47, 100, 105,-      126, 115,  80,  93,  74,  71, 220, 209, 198, 203, 232, 229, 242,-      255, 180, 185, 174, 163, 128, 141, 154, 151-  };-  static const SWord8 table4[] = {-        0,   9,  18,  27,  36,  45,  54,  63,  72,  65,  90,  83, 108,-      101, 126, 119, 144, 153, 130, 139, 180, 189, 166, 175, 216, 209,-      202, 195, 252, 245, 238, 231,  59,  50,  41,  32,  31,  22,  13,-        4, 115, 122,  97, 104,  87,  94,  69,  76, 171, 162, 185, 176,-      143, 134, 157, 148, 227, 234, 241, 248, 199, 206, 213, 220, 118,-      127, 100, 109,  82,  91,  64,  73,  62,  55,  44,  37,  26,  19,-        8,   1, 230, 239, 244, 253, 194, 203, 208, 217, 174, 167, 188,-      181, 138, 131, 152, 145,  77,  68,  95,  86, 105,  96, 123, 114,-        5,  12,  23,  30,  33,  40,  51,  58, 221, 212, 207, 198, 249,-      240, 235, 226, 149, 156, 135, 142, 177, 184, 163, 170, 236, 229,-      254, 247, 200, 193, 218, 211, 164, 173, 182, 191, 128, 137, 146,-      155, 124, 117, 110, 103,  88,  81,  74,  67,  52,  61,  38,  47,-       16,  25,   2,  11, 215, 222, 197, 204, 243, 250, 225, 232, 159,-      150, 141, 132, 187, 178, 169, 160,  71,  78,  85,  92,  99, 106,-      113, 120,  15,   6,  29,  20,  43,  34,  57,  48, 154, 147, 136,-      129, 190, 183, 172, 165, 210, 219, 192, 201, 246, 255, 228, 237,-       10,   3,  24,  17,  46,  39,  60,  53,  66,  75,  80,  89, 102,-      111, 116, 125, 161, 168, 179, 186, 133, 140, 151, 158, 233, 224,-      251, 242, 205, 196, 223, 214,  49,  56,  35,  42,  21,  28,   7,-       14, 121, 112, 107,  98,  93,  84,  79,  70-  };-  const SWord32 s260 = (s3 << 8) | (s3 >> 24);-  const SWord16 s261 = (SWord16) (s260 >> 16);-  const SWord8  s262 = (SWord8) (s261 >> 8);-  const SWord8  s263 = table0[s262];-  const SWord8  s264 = 1 ^ s263;-  const SWord8  s265 = (SWord8) s261;-  const SWord8  s266 = table0[s265];-  const SWord16 s267 = (((SWord16) s264) << 8) | ((SWord16) s266);-  const SWord16 s268 = (SWord16) s260;-  const SWord8  s269 = (SWord8) (s268 >> 8);-  const SWord8  s270 = table0[s269];-  const SWord8  s271 = (SWord8) s268;-  const SWord8  s272 = table0[s271];-  const SWord16 s273 = (((SWord16) s270) << 8) | ((SWord16) s272);-  const SWord32 s274 = (((SWord32) s267) << 16) | ((SWord32) s273);-  const SWord32 s275 = s0 ^ s274;-  const SWord32 s276 = s1 ^ s275;-  const SWord32 s277 = s2 ^ s276;-  const SWord32 s278 = s3 ^ s277;-  const SWord32 s279 = (s278 << 8) | (s278 >> 24);-  const SWord16 s280 = (SWord16) (s279 >> 16);-  const SWord8  s281 = (SWord8) (s280 >> 8);-  const SWord8  s282 = table0[s281];-  const SWord8  s283 = 2 ^ s282;-  const SWord8  s284 = (SWord8) s280;-  const SWord8  s285 = table0[s284];-  const SWord16 s286 = (((SWord16) s283) << 8) | ((SWord16) s285);-  const SWord16 s287 = (SWord16) s279;-  const SWord8  s288 = (SWord8) (s287 >> 8);-  const SWord8  s289 = table0[s288];-  const SWord8  s290 = (SWord8) s287;-  const SWord8  s291 = table0[s290];-  const SWord16 s292 = (((SWord16) s289) << 8) | ((SWord16) s291);-  const SWord32 s293 = (((SWord32) s286) << 16) | ((SWord32) s292);-  const SWord32 s294 = s275 ^ s293;-  const SWord32 s295 = s276 ^ s294;-  const SWord32 s296 = s277 ^ s295;-  const SWord32 s297 = s278 ^ s296;-  const SWord32 s298 = (s297 << 8) | (s297 >> 24);-  const SWord16 s299 = (SWord16) (s298 >> 16);-  const SWord8  s300 = (SWord8) (s299 >> 8);-  const SWord8  s301 = table0[s300];-  const SWord8  s302 = 4 ^ s301;-  const SWord8  s303 = (SWord8) s299;-  const SWord8  s304 = table0[s303];-  const SWord16 s305 = (((SWord16) s302) << 8) | ((SWord16) s304);-  const SWord16 s306 = (SWord16) s298;-  const SWord8  s307 = (SWord8) (s306 >> 8);-  const SWord8  s308 = table0[s307];-  const SWord8  s309 = (SWord8) s306;-  const SWord8  s310 = table0[s309];-  const SWord16 s311 = (((SWord16) s308) << 8) | ((SWord16) s310);-  const SWord32 s312 = (((SWord32) s305) << 16) | ((SWord32) s311);-  const SWord32 s313 = s294 ^ s312;-  const SWord32 s314 = s295 ^ s313;-  const SWord32 s315 = s296 ^ s314;-  const SWord32 s316 = s297 ^ s315;-  const SWord32 s317 = (s316 << 8) | (s316 >> 24);-  const SWord16 s318 = (SWord16) (s317 >> 16);-  const SWord8  s319 = (SWord8) (s318 >> 8);-  const SWord8  s320 = table0[s319];-  const SWord8  s321 = 8 ^ s320;-  const SWord8  s322 = (SWord8) s318;-  const SWord8  s323 = table0[s322];-  const SWord16 s324 = (((SWord16) s321) << 8) | ((SWord16) s323);-  const SWord16 s325 = (SWord16) s317;-  const SWord8  s326 = (SWord8) (s325 >> 8);-  const SWord8  s327 = table0[s326];-  const SWord8  s328 = (SWord8) s325;-  const SWord8  s329 = table0[s328];-  const SWord16 s330 = (((SWord16) s327) << 8) | ((SWord16) s329);-  const SWord32 s331 = (((SWord32) s324) << 16) | ((SWord32) s330);-  const SWord32 s332 = s313 ^ s331;-  const SWord32 s333 = s314 ^ s332;-  const SWord32 s334 = s315 ^ s333;-  const SWord32 s335 = s316 ^ s334;-  const SWord32 s336 = (s335 << 8) | (s335 >> 24);-  const SWord16 s337 = (SWord16) (s336 >> 16);-  const SWord8  s338 = (SWord8) (s337 >> 8);-  const SWord8  s339 = table0[s338];-  const SWord8  s340 = 16 ^ s339;-  const SWord8  s341 = (SWord8) s337;-  const SWord8  s342 = table0[s341];-  const SWord16 s343 = (((SWord16) s340) << 8) | ((SWord16) s342);-  const SWord16 s344 = (SWord16) s336;-  const SWord8  s345 = (SWord8) (s344 >> 8);-  const SWord8  s346 = table0[s345];-  const SWord8  s347 = (SWord8) s344;-  const SWord8  s348 = table0[s347];-  const SWord16 s349 = (((SWord16) s346) << 8) | ((SWord16) s348);-  const SWord32 s350 = (((SWord32) s343) << 16) | ((SWord32) s349);-  const SWord32 s351 = s332 ^ s350;-  const SWord32 s352 = s333 ^ s351;-  const SWord32 s353 = s334 ^ s352;-  const SWord32 s354 = s335 ^ s353;-  const SWord32 s355 = (s354 << 8) | (s354 >> 24);-  const SWord16 s356 = (SWord16) (s355 >> 16);-  const SWord8  s357 = (SWord8) (s356 >> 8);-  const SWord8  s358 = table0[s357];-  const SWord8  s359 = 32 ^ s358;-  const SWord8  s360 = (SWord8) s356;-  const SWord8  s361 = table0[s360];-  const SWord16 s362 = (((SWord16) s359) << 8) | ((SWord16) s361);-  const SWord16 s363 = (SWord16) s355;-  const SWord8  s364 = (SWord8) (s363 >> 8);-  const SWord8  s365 = table0[s364];-  const SWord8  s366 = (SWord8) s363;-  const SWord8  s367 = table0[s366];-  const SWord16 s368 = (((SWord16) s365) << 8) | ((SWord16) s367);-  const SWord32 s369 = (((SWord32) s362) << 16) | ((SWord32) s368);-  const SWord32 s370 = s351 ^ s369;-  const SWord32 s371 = s352 ^ s370;-  const SWord32 s372 = s353 ^ s371;-  const SWord32 s373 = s354 ^ s372;-  const SWord32 s374 = (s373 << 8) | (s373 >> 24);-  const SWord16 s375 = (SWord16) (s374 >> 16);-  const SWord8  s376 = (SWord8) (s375 >> 8);-  const SWord8  s377 = table0[s376];-  const SWord8  s378 = 64 ^ s377;-  const SWord8  s379 = (SWord8) s375;-  const SWord8  s380 = table0[s379];-  const SWord16 s381 = (((SWord16) s378) << 8) | ((SWord16) s380);-  const SWord16 s382 = (SWord16) s374;-  const SWord8  s383 = (SWord8) (s382 >> 8);-  const SWord8  s384 = table0[s383];-  const SWord8  s385 = (SWord8) s382;-  const SWord8  s386 = table0[s385];-  const SWord16 s387 = (((SWord16) s384) << 8) | ((SWord16) s386);-  const SWord32 s388 = (((SWord32) s381) << 16) | ((SWord32) s387);-  const SWord32 s389 = s370 ^ s388;-  const SWord32 s390 = s371 ^ s389;-  const SWord32 s391 = s372 ^ s390;-  const SWord32 s392 = s373 ^ s391;-  const SWord32 s393 = (s392 << 8) | (s392 >> 24);-  const SWord16 s394 = (SWord16) (s393 >> 16);-  const SWord8  s395 = (SWord8) (s394 >> 8);-  const SWord8  s396 = table0[s395];-  const SWord8  s397 = 128 ^ s396;-  const SWord8  s398 = (SWord8) s394;-  const SWord8  s399 = table0[s398];-  const SWord16 s400 = (((SWord16) s397) << 8) | ((SWord16) s399);-  const SWord16 s401 = (SWord16) s393;-  const SWord8  s402 = (SWord8) (s401 >> 8);-  const SWord8  s403 = table0[s402];-  const SWord8  s404 = (SWord8) s401;-  const SWord8  s405 = table0[s404];-  const SWord16 s406 = (((SWord16) s403) << 8) | ((SWord16) s405);-  const SWord32 s407 = (((SWord32) s400) << 16) | ((SWord32) s406);-  const SWord32 s408 = s389 ^ s407;-  const SWord32 s409 = s390 ^ s408;-  const SWord32 s410 = s391 ^ s409;-  const SWord32 s411 = s392 ^ s410;-  const SWord32 s412 = (s411 << 8) | (s411 >> 24);-  const SWord16 s413 = (SWord16) (s412 >> 16);-  const SWord8  s414 = (SWord8) (s413 >> 8);-  const SWord8  s415 = table0[s414];-  const SWord8  s416 = 27 ^ s415;-  const SWord8  s417 = (SWord8) s413;-  const SWord8  s418 = table0[s417];-  const SWord16 s419 = (((SWord16) s416) << 8) | ((SWord16) s418);-  const SWord16 s420 = (SWord16) s412;-  const SWord8  s421 = (SWord8) (s420 >> 8);-  const SWord8  s422 = table0[s421];-  const SWord8  s423 = (SWord8) s420;-  const SWord8  s424 = table0[s423];-  const SWord16 s425 = (((SWord16) s422) << 8) | ((SWord16) s424);-  const SWord32 s426 = (((SWord32) s419) << 16) | ((SWord32) s425);-  const SWord32 s427 = s408 ^ s426;-  const SWord32 s428 = s409 ^ s427;-  const SWord32 s429 = s410 ^ s428;-  const SWord32 s430 = s411 ^ s429;-  const SWord32 s431 = (s430 << 8) | (s430 >> 24);-  const SWord16 s432 = (SWord16) (s431 >> 16);-  const SWord8  s433 = (SWord8) (s432 >> 8);-  const SWord8  s434 = table0[s433];-  const SWord8  s435 = 54 ^ s434;-  const SWord8  s436 = (SWord8) s432;-  const SWord8  s437 = table0[s436];-  const SWord16 s438 = (((SWord16) s435) << 8) | ((SWord16) s437);-  const SWord16 s439 = (SWord16) s431;-  const SWord8  s440 = (SWord8) (s439 >> 8);-  const SWord8  s441 = table0[s440];-  const SWord8  s442 = (SWord8) s439;-  const SWord8  s443 = table0[s442];-  const SWord16 s444 = (((SWord16) s441) << 8) | ((SWord16) s443);-  const SWord32 s445 = (((SWord32) s438) << 16) | ((SWord32) s444);-  const SWord32 s446 = s427 ^ s445;-  const SWord32 s447 = s428 ^ s446;-  const SWord32 s448 = s429 ^ s447;-  const SWord32 s449 = s430 ^ s448;-  const SWord16 s450 = (SWord16) (s427 >> 16);-  const SWord8  s451 = (SWord8) (s450 >> 8);-  const SWord8  s452 = table1[s451];-  const SWord8  s453 = (SWord8) s450;-  const SWord8  s454 = table2[s453];-  const SWord16 s455 = (SWord16) s427;-  const SWord8  s456 = (SWord8) (s455 >> 8);-  const SWord8  s457 = table3[s456];-  const SWord8  s458 = (SWord8) s455;-  const SWord8  s459 = table4[s458];-  const SWord8  s460 = s457 ^ s459;-  const SWord8  s461 = s454 ^ s460;-  const SWord8  s462 = s452 ^ s461;-  const SWord8  s463 = table4[s451];-  const SWord8  s464 = table1[s453];-  const SWord8  s465 = table2[s456];-  const SWord8  s466 = table3[s458];-  const SWord8  s467 = s465 ^ s466;-  const SWord8  s468 = s464 ^ s467;-  const SWord8  s469 = s463 ^ s468;-  const SWord16 s470 = (((SWord16) s462) << 8) | ((SWord16) s469);-  const SWord8  s471 = table3[s451];-  const SWord8  s472 = table4[s453];-  const SWord8  s473 = table1[s456];-  const SWord8  s474 = table2[s458];-  const SWord8  s475 = s473 ^ s474;-  const SWord8  s476 = s472 ^ s475;-  const SWord8  s477 = s471 ^ s476;-  const SWord8  s478 = table2[s451];-  const SWord8  s479 = table3[s453];-  const SWord8  s480 = table4[s456];-  const SWord8  s481 = table1[s458];-  const SWord8  s482 = s480 ^ s481;-  const SWord8  s483 = s479 ^ s482;-  const SWord8  s484 = s478 ^ s483;-  const SWord16 s485 = (((SWord16) s477) << 8) | ((SWord16) s484);-  const SWord32 s486 = (((SWord32) s470) << 16) | ((SWord32) s485);-  const SWord16 s487 = (SWord16) (s428 >> 16);-  const SWord8  s488 = (SWord8) (s487 >> 8);-  const SWord8  s489 = table1[s488];-  const SWord8  s490 = (SWord8) s487;-  const SWord8  s491 = table2[s490];-  const SWord16 s492 = (SWord16) s428;-  const SWord8  s493 = (SWord8) (s492 >> 8);-  const SWord8  s494 = table3[s493];-  const SWord8  s495 = (SWord8) s492;-  const SWord8  s496 = table4[s495];-  const SWord8  s497 = s494 ^ s496;-  const SWord8  s498 = s491 ^ s497;-  const SWord8  s499 = s489 ^ s498;-  const SWord8  s500 = table4[s488];-  const SWord8  s501 = table1[s490];-  const SWord8  s502 = table2[s493];-  const SWord8  s503 = table3[s495];-  const SWord8  s504 = s502 ^ s503;-  const SWord8  s505 = s501 ^ s504;-  const SWord8  s506 = s500 ^ s505;-  const SWord16 s507 = (((SWord16) s499) << 8) | ((SWord16) s506);-  const SWord8  s508 = table3[s488];-  const SWord8  s509 = table4[s490];-  const SWord8  s510 = table1[s493];-  const SWord8  s511 = table2[s495];-  const SWord8  s512 = s510 ^ s511;-  const SWord8  s513 = s509 ^ s512;-  const SWord8  s514 = s508 ^ s513;-  const SWord8  s515 = table2[s488];-  const SWord8  s516 = table3[s490];-  const SWord8  s517 = table4[s493];-  const SWord8  s518 = table1[s495];-  const SWord8  s519 = s517 ^ s518;-  const SWord8  s520 = s516 ^ s519;-  const SWord8  s521 = s515 ^ s520;-  const SWord16 s522 = (((SWord16) s514) << 8) | ((SWord16) s521);-  const SWord32 s523 = (((SWord32) s507) << 16) | ((SWord32) s522);-  const SWord16 s524 = (SWord16) (s429 >> 16);-  const SWord8  s525 = (SWord8) (s524 >> 8);-  const SWord8  s526 = table1[s525];-  const SWord8  s527 = (SWord8) s524;-  const SWord8  s528 = table2[s527];-  const SWord16 s529 = (SWord16) s429;-  const SWord8  s530 = (SWord8) (s529 >> 8);-  const SWord8  s531 = table3[s530];-  const SWord8  s532 = (SWord8) s529;-  const SWord8  s533 = table4[s532];-  const SWord8  s534 = s531 ^ s533;-  const SWord8  s535 = s528 ^ s534;-  const SWord8  s536 = s526 ^ s535;-  const SWord8  s537 = table4[s525];-  const SWord8  s538 = table1[s527];-  const SWord8  s539 = table2[s530];-  const SWord8  s540 = table3[s532];-  const SWord8  s541 = s539 ^ s540;-  const SWord8  s542 = s538 ^ s541;-  const SWord8  s543 = s537 ^ s542;-  const SWord16 s544 = (((SWord16) s536) << 8) | ((SWord16) s543);-  const SWord8  s545 = table3[s525];-  const SWord8  s546 = table4[s527];-  const SWord8  s547 = table1[s530];-  const SWord8  s548 = table2[s532];-  const SWord8  s549 = s547 ^ s548;-  const SWord8  s550 = s546 ^ s549;-  const SWord8  s551 = s545 ^ s550;-  const SWord8  s552 = table2[s525];-  const SWord8  s553 = table3[s527];-  const SWord8  s554 = table4[s530];-  const SWord8  s555 = table1[s532];-  const SWord8  s556 = s554 ^ s555;-  const SWord8  s557 = s553 ^ s556;-  const SWord8  s558 = s552 ^ s557;-  const SWord16 s559 = (((SWord16) s551) << 8) | ((SWord16) s558);-  const SWord32 s560 = (((SWord32) s544) << 16) | ((SWord32) s559);-  const SWord16 s561 = (SWord16) (s430 >> 16);-  const SWord8  s562 = (SWord8) (s561 >> 8);-  const SWord8  s563 = table1[s562];-  const SWord8  s564 = (SWord8) s561;-  const SWord8  s565 = table2[s564];-  const SWord16 s566 = (SWord16) s430;-  const SWord8  s567 = (SWord8) (s566 >> 8);-  const SWord8  s568 = table3[s567];-  const SWord8  s569 = (SWord8) s566;-  const SWord8  s570 = table4[s569];-  const SWord8  s571 = s568 ^ s570;-  const SWord8  s572 = s565 ^ s571;-  const SWord8  s573 = s563 ^ s572;-  const SWord8  s574 = table4[s562];-  const SWord8  s575 = table1[s564];-  const SWord8  s576 = table2[s567];-  const SWord8  s577 = table3[s569];-  const SWord8  s578 = s576 ^ s577;-  const SWord8  s579 = s575 ^ s578;-  const SWord8  s580 = s574 ^ s579;-  const SWord16 s581 = (((SWord16) s573) << 8) | ((SWord16) s580);-  const SWord8  s582 = table3[s562];-  const SWord8  s583 = table4[s564];-  const SWord8  s584 = table1[s567];-  const SWord8  s585 = table2[s569];-  const SWord8  s586 = s584 ^ s585;-  const SWord8  s587 = s583 ^ s586;-  const SWord8  s588 = s582 ^ s587;-  const SWord8  s589 = table2[s562];-  const SWord8  s590 = table3[s564];-  const SWord8  s591 = table4[s567];-  const SWord8  s592 = table1[s569];-  const SWord8  s593 = s591 ^ s592;-  const SWord8  s594 = s590 ^ s593;-  const SWord8  s595 = s589 ^ s594;-  const SWord16 s596 = (((SWord16) s588) << 8) | ((SWord16) s595);-  const SWord32 s597 = (((SWord32) s581) << 16) | ((SWord32) s596);-  const SWord16 s598 = (SWord16) (s408 >> 16);-  const SWord8  s599 = (SWord8) (s598 >> 8);-  const SWord8  s600 = table1[s599];-  const SWord8  s601 = (SWord8) s598;-  const SWord8  s602 = table2[s601];-  const SWord16 s603 = (SWord16) s408;-  const SWord8  s604 = (SWord8) (s603 >> 8);-  const SWord8  s605 = table3[s604];-  const SWord8  s606 = (SWord8) s603;-  const SWord8  s607 = table4[s606];-  const SWord8  s608 = s605 ^ s607;-  const SWord8  s609 = s602 ^ s608;-  const SWord8  s610 = s600 ^ s609;-  const SWord8  s611 = table4[s599];-  const SWord8  s612 = table1[s601];-  const SWord8  s613 = table2[s604];-  const SWord8  s614 = table3[s606];-  const SWord8  s615 = s613 ^ s614;-  const SWord8  s616 = s612 ^ s615;-  const SWord8  s617 = s611 ^ s616;-  const SWord16 s618 = (((SWord16) s610) << 8) | ((SWord16) s617);-  const SWord8  s619 = table3[s599];-  const SWord8  s620 = table4[s601];-  const SWord8  s621 = table1[s604];-  const SWord8  s622 = table2[s606];-  const SWord8  s623 = s621 ^ s622;-  const SWord8  s624 = s620 ^ s623;-  const SWord8  s625 = s619 ^ s624;-  const SWord8  s626 = table2[s599];-  const SWord8  s627 = table3[s601];-  const SWord8  s628 = table4[s604];-  const SWord8  s629 = table1[s606];-  const SWord8  s630 = s628 ^ s629;-  const SWord8  s631 = s627 ^ s630;-  const SWord8  s632 = s626 ^ s631;-  const SWord16 s633 = (((SWord16) s625) << 8) | ((SWord16) s632);-  const SWord32 s634 = (((SWord32) s618) << 16) | ((SWord32) s633);-  const SWord16 s635 = (SWord16) (s409 >> 16);-  const SWord8  s636 = (SWord8) (s635 >> 8);-  const SWord8  s637 = table1[s636];-  const SWord8  s638 = (SWord8) s635;-  const SWord8  s639 = table2[s638];-  const SWord16 s640 = (SWord16) s409;-  const SWord8  s641 = (SWord8) (s640 >> 8);-  const SWord8  s642 = table3[s641];-  const SWord8  s643 = (SWord8) s640;-  const SWord8  s644 = table4[s643];-  const SWord8  s645 = s642 ^ s644;-  const SWord8  s646 = s639 ^ s645;-  const SWord8  s647 = s637 ^ s646;-  const SWord8  s648 = table4[s636];-  const SWord8  s649 = table1[s638];-  const SWord8  s650 = table2[s641];-  const SWord8  s651 = table3[s643];-  const SWord8  s652 = s650 ^ s651;-  const SWord8  s653 = s649 ^ s652;-  const SWord8  s654 = s648 ^ s653;-  const SWord16 s655 = (((SWord16) s647) << 8) | ((SWord16) s654);-  const SWord8  s656 = table3[s636];-  const SWord8  s657 = table4[s638];-  const SWord8  s658 = table1[s641];-  const SWord8  s659 = table2[s643];-  const SWord8  s660 = s658 ^ s659;-  const SWord8  s661 = s657 ^ s660;-  const SWord8  s662 = s656 ^ s661;-  const SWord8  s663 = table2[s636];-  const SWord8  s664 = table3[s638];-  const SWord8  s665 = table4[s641];-  const SWord8  s666 = table1[s643];-  const SWord8  s667 = s665 ^ s666;-  const SWord8  s668 = s664 ^ s667;-  const SWord8  s669 = s663 ^ s668;-  const SWord16 s670 = (((SWord16) s662) << 8) | ((SWord16) s669);-  const SWord32 s671 = (((SWord32) s655) << 16) | ((SWord32) s670);-  const SWord16 s672 = (SWord16) (s410 >> 16);-  const SWord8  s673 = (SWord8) (s672 >> 8);-  const SWord8  s674 = table1[s673];-  const SWord8  s675 = (SWord8) s672;-  const SWord8  s676 = table2[s675];-  const SWord16 s677 = (SWord16) s410;-  const SWord8  s678 = (SWord8) (s677 >> 8);-  const SWord8  s679 = table3[s678];-  const SWord8  s680 = (SWord8) s677;-  const SWord8  s681 = table4[s680];-  const SWord8  s682 = s679 ^ s681;-  const SWord8  s683 = s676 ^ s682;-  const SWord8  s684 = s674 ^ s683;-  const SWord8  s685 = table4[s673];-  const SWord8  s686 = table1[s675];-  const SWord8  s687 = table2[s678];-  const SWord8  s688 = table3[s680];-  const SWord8  s689 = s687 ^ s688;-  const SWord8  s690 = s686 ^ s689;-  const SWord8  s691 = s685 ^ s690;-  const SWord16 s692 = (((SWord16) s684) << 8) | ((SWord16) s691);-  const SWord8  s693 = table3[s673];-  const SWord8  s694 = table4[s675];-  const SWord8  s695 = table1[s678];-  const SWord8  s696 = table2[s680];-  const SWord8  s697 = s695 ^ s696;-  const SWord8  s698 = s694 ^ s697;-  const SWord8  s699 = s693 ^ s698;-  const SWord8  s700 = table2[s673];-  const SWord8  s701 = table3[s675];-  const SWord8  s702 = table4[s678];-  const SWord8  s703 = table1[s680];-  const SWord8  s704 = s702 ^ s703;-  const SWord8  s705 = s701 ^ s704;-  const SWord8  s706 = s700 ^ s705;-  const SWord16 s707 = (((SWord16) s699) << 8) | ((SWord16) s706);-  const SWord32 s708 = (((SWord32) s692) << 16) | ((SWord32) s707);-  const SWord16 s709 = (SWord16) (s411 >> 16);-  const SWord8  s710 = (SWord8) (s709 >> 8);-  const SWord8  s711 = table1[s710];-  const SWord8  s712 = (SWord8) s709;-  const SWord8  s713 = table2[s712];-  const SWord16 s714 = (SWord16) s411;-  const SWord8  s715 = (SWord8) (s714 >> 8);-  const SWord8  s716 = table3[s715];-  const SWord8  s717 = (SWord8) s714;-  const SWord8  s718 = table4[s717];-  const SWord8  s719 = s716 ^ s718;-  const SWord8  s720 = s713 ^ s719;-  const SWord8  s721 = s711 ^ s720;-  const SWord8  s722 = table4[s710];-  const SWord8  s723 = table1[s712];-  const SWord8  s724 = table2[s715];-  const SWord8  s725 = table3[s717];-  const SWord8  s726 = s724 ^ s725;-  const SWord8  s727 = s723 ^ s726;-  const SWord8  s728 = s722 ^ s727;-  const SWord16 s729 = (((SWord16) s721) << 8) | ((SWord16) s728);-  const SWord8  s730 = table3[s710];-  const SWord8  s731 = table4[s712];-  const SWord8  s732 = table1[s715];-  const SWord8  s733 = table2[s717];-  const SWord8  s734 = s732 ^ s733;-  const SWord8  s735 = s731 ^ s734;-  const SWord8  s736 = s730 ^ s735;-  const SWord8  s737 = table2[s710];-  const SWord8  s738 = table3[s712];-  const SWord8  s739 = table4[s715];-  const SWord8  s740 = table1[s717];-  const SWord8  s741 = s739 ^ s740;-  const SWord8  s742 = s738 ^ s741;-  const SWord8  s743 = s737 ^ s742;-  const SWord16 s744 = (((SWord16) s736) << 8) | ((SWord16) s743);-  const SWord32 s745 = (((SWord32) s729) << 16) | ((SWord32) s744);-  const SWord16 s746 = (SWord16) (s389 >> 16);-  const SWord8  s747 = (SWord8) (s746 >> 8);-  const SWord8  s748 = table1[s747];-  const SWord8  s749 = (SWord8) s746;-  const SWord8  s750 = table2[s749];-  const SWord16 s751 = (SWord16) s389;-  const SWord8  s752 = (SWord8) (s751 >> 8);-  const SWord8  s753 = table3[s752];-  const SWord8  s754 = (SWord8) s751;-  const SWord8  s755 = table4[s754];-  const SWord8  s756 = s753 ^ s755;-  const SWord8  s757 = s750 ^ s756;-  const SWord8  s758 = s748 ^ s757;-  const SWord8  s759 = table4[s747];-  const SWord8  s760 = table1[s749];-  const SWord8  s761 = table2[s752];-  const SWord8  s762 = table3[s754];-  const SWord8  s763 = s761 ^ s762;-  const SWord8  s764 = s760 ^ s763;-  const SWord8  s765 = s759 ^ s764;-  const SWord16 s766 = (((SWord16) s758) << 8) | ((SWord16) s765);-  const SWord8  s767 = table3[s747];-  const SWord8  s768 = table4[s749];-  const SWord8  s769 = table1[s752];-  const SWord8  s770 = table2[s754];-  const SWord8  s771 = s769 ^ s770;-  const SWord8  s772 = s768 ^ s771;-  const SWord8  s773 = s767 ^ s772;-  const SWord8  s774 = table2[s747];-  const SWord8  s775 = table3[s749];-  const SWord8  s776 = table4[s752];-  const SWord8  s777 = table1[s754];-  const SWord8  s778 = s776 ^ s777;-  const SWord8  s779 = s775 ^ s778;-  const SWord8  s780 = s774 ^ s779;-  const SWord16 s781 = (((SWord16) s773) << 8) | ((SWord16) s780);-  const SWord32 s782 = (((SWord32) s766) << 16) | ((SWord32) s781);-  const SWord16 s783 = (SWord16) (s390 >> 16);-  const SWord8  s784 = (SWord8) (s783 >> 8);-  const SWord8  s785 = table1[s784];-  const SWord8  s786 = (SWord8) s783;-  const SWord8  s787 = table2[s786];-  const SWord16 s788 = (SWord16) s390;-  const SWord8  s789 = (SWord8) (s788 >> 8);-  const SWord8  s790 = table3[s789];-  const SWord8  s791 = (SWord8) s788;-  const SWord8  s792 = table4[s791];-  const SWord8  s793 = s790 ^ s792;-  const SWord8  s794 = s787 ^ s793;-  const SWord8  s795 = s785 ^ s794;-  const SWord8  s796 = table4[s784];-  const SWord8  s797 = table1[s786];-  const SWord8  s798 = table2[s789];-  const SWord8  s799 = table3[s791];-  const SWord8  s800 = s798 ^ s799;-  const SWord8  s801 = s797 ^ s800;-  const SWord8  s802 = s796 ^ s801;-  const SWord16 s803 = (((SWord16) s795) << 8) | ((SWord16) s802);-  const SWord8  s804 = table3[s784];-  const SWord8  s805 = table4[s786];-  const SWord8  s806 = table1[s789];-  const SWord8  s807 = table2[s791];-  const SWord8  s808 = s806 ^ s807;-  const SWord8  s809 = s805 ^ s808;-  const SWord8  s810 = s804 ^ s809;-  const SWord8  s811 = table2[s784];-  const SWord8  s812 = table3[s786];-  const SWord8  s813 = table4[s789];-  const SWord8  s814 = table1[s791];-  const SWord8  s815 = s813 ^ s814;-  const SWord8  s816 = s812 ^ s815;-  const SWord8  s817 = s811 ^ s816;-  const SWord16 s818 = (((SWord16) s810) << 8) | ((SWord16) s817);-  const SWord32 s819 = (((SWord32) s803) << 16) | ((SWord32) s818);-  const SWord16 s820 = (SWord16) (s391 >> 16);-  const SWord8  s821 = (SWord8) (s820 >> 8);-  const SWord8  s822 = table1[s821];-  const SWord8  s823 = (SWord8) s820;-  const SWord8  s824 = table2[s823];-  const SWord16 s825 = (SWord16) s391;-  const SWord8  s826 = (SWord8) (s825 >> 8);-  const SWord8  s827 = table3[s826];-  const SWord8  s828 = (SWord8) s825;-  const SWord8  s829 = table4[s828];-  const SWord8  s830 = s827 ^ s829;-  const SWord8  s831 = s824 ^ s830;-  const SWord8  s832 = s822 ^ s831;-  const SWord8  s833 = table4[s821];-  const SWord8  s834 = table1[s823];-  const SWord8  s835 = table2[s826];-  const SWord8  s836 = table3[s828];-  const SWord8  s837 = s835 ^ s836;-  const SWord8  s838 = s834 ^ s837;-  const SWord8  s839 = s833 ^ s838;-  const SWord16 s840 = (((SWord16) s832) << 8) | ((SWord16) s839);-  const SWord8  s841 = table3[s821];-  const SWord8  s842 = table4[s823];-  const SWord8  s843 = table1[s826];-  const SWord8  s844 = table2[s828];-  const SWord8  s845 = s843 ^ s844;-  const SWord8  s846 = s842 ^ s845;-  const SWord8  s847 = s841 ^ s846;-  const SWord8  s848 = table2[s821];-  const SWord8  s849 = table3[s823];-  const SWord8  s850 = table4[s826];-  const SWord8  s851 = table1[s828];-  const SWord8  s852 = s850 ^ s851;-  const SWord8  s853 = s849 ^ s852;-  const SWord8  s854 = s848 ^ s853;-  const SWord16 s855 = (((SWord16) s847) << 8) | ((SWord16) s854);-  const SWord32 s856 = (((SWord32) s840) << 16) | ((SWord32) s855);-  const SWord16 s857 = (SWord16) (s392 >> 16);-  const SWord8  s858 = (SWord8) (s857 >> 8);-  const SWord8  s859 = table1[s858];-  const SWord8  s860 = (SWord8) s857;-  const SWord8  s861 = table2[s860];-  const SWord16 s862 = (SWord16) s392;-  const SWord8  s863 = (SWord8) (s862 >> 8);-  const SWord8  s864 = table3[s863];-  const SWord8  s865 = (SWord8) s862;-  const SWord8  s866 = table4[s865];-  const SWord8  s867 = s864 ^ s866;-  const SWord8  s868 = s861 ^ s867;-  const SWord8  s869 = s859 ^ s868;-  const SWord8  s870 = table4[s858];-  const SWord8  s871 = table1[s860];-  const SWord8  s872 = table2[s863];-  const SWord8  s873 = table3[s865];-  const SWord8  s874 = s872 ^ s873;-  const SWord8  s875 = s871 ^ s874;-  const SWord8  s876 = s870 ^ s875;-  const SWord16 s877 = (((SWord16) s869) << 8) | ((SWord16) s876);-  const SWord8  s878 = table3[s858];-  const SWord8  s879 = table4[s860];-  const SWord8  s880 = table1[s863];-  const SWord8  s881 = table2[s865];-  const SWord8  s882 = s880 ^ s881;-  const SWord8  s883 = s879 ^ s882;-  const SWord8  s884 = s878 ^ s883;-  const SWord8  s885 = table2[s858];-  const SWord8  s886 = table3[s860];-  const SWord8  s887 = table4[s863];-  const SWord8  s888 = table1[s865];-  const SWord8  s889 = s887 ^ s888;-  const SWord8  s890 = s886 ^ s889;-  const SWord8  s891 = s885 ^ s890;-  const SWord16 s892 = (((SWord16) s884) << 8) | ((SWord16) s891);-  const SWord32 s893 = (((SWord32) s877) << 16) | ((SWord32) s892);-  const SWord16 s894 = (SWord16) (s370 >> 16);-  const SWord8  s895 = (SWord8) (s894 >> 8);-  const SWord8  s896 = table1[s895];-  const SWord8  s897 = (SWord8) s894;-  const SWord8  s898 = table2[s897];-  const SWord16 s899 = (SWord16) s370;-  const SWord8  s900 = (SWord8) (s899 >> 8);-  const SWord8  s901 = table3[s900];-  const SWord8  s902 = (SWord8) s899;-  const SWord8  s903 = table4[s902];-  const SWord8  s904 = s901 ^ s903;-  const SWord8  s905 = s898 ^ s904;-  const SWord8  s906 = s896 ^ s905;-  const SWord8  s907 = table4[s895];-  const SWord8  s908 = table1[s897];-  const SWord8  s909 = table2[s900];-  const SWord8  s910 = table3[s902];-  const SWord8  s911 = s909 ^ s910;-  const SWord8  s912 = s908 ^ s911;-  const SWord8  s913 = s907 ^ s912;-  const SWord16 s914 = (((SWord16) s906) << 8) | ((SWord16) s913);-  const SWord8  s915 = table3[s895];-  const SWord8  s916 = table4[s897];-  const SWord8  s917 = table1[s900];-  const SWord8  s918 = table2[s902];-  const SWord8  s919 = s917 ^ s918;-  const SWord8  s920 = s916 ^ s919;-  const SWord8  s921 = s915 ^ s920;-  const SWord8  s922 = table2[s895];-  const SWord8  s923 = table3[s897];-  const SWord8  s924 = table4[s900];-  const SWord8  s925 = table1[s902];-  const SWord8  s926 = s924 ^ s925;-  const SWord8  s927 = s923 ^ s926;-  const SWord8  s928 = s922 ^ s927;-  const SWord16 s929 = (((SWord16) s921) << 8) | ((SWord16) s928);-  const SWord32 s930 = (((SWord32) s914) << 16) | ((SWord32) s929);-  const SWord16 s931 = (SWord16) (s371 >> 16);-  const SWord8  s932 = (SWord8) (s931 >> 8);-  const SWord8  s933 = table1[s932];-  const SWord8  s934 = (SWord8) s931;-  const SWord8  s935 = table2[s934];-  const SWord16 s936 = (SWord16) s371;-  const SWord8  s937 = (SWord8) (s936 >> 8);-  const SWord8  s938 = table3[s937];-  const SWord8  s939 = (SWord8) s936;-  const SWord8  s940 = table4[s939];-  const SWord8  s941 = s938 ^ s940;-  const SWord8  s942 = s935 ^ s941;-  const SWord8  s943 = s933 ^ s942;-  const SWord8  s944 = table4[s932];-  const SWord8  s945 = table1[s934];-  const SWord8  s946 = table2[s937];-  const SWord8  s947 = table3[s939];-  const SWord8  s948 = s946 ^ s947;-  const SWord8  s949 = s945 ^ s948;-  const SWord8  s950 = s944 ^ s949;-  const SWord16 s951 = (((SWord16) s943) << 8) | ((SWord16) s950);-  const SWord8  s952 = table3[s932];-  const SWord8  s953 = table4[s934];-  const SWord8  s954 = table1[s937];-  const SWord8  s955 = table2[s939];-  const SWord8  s956 = s954 ^ s955;-  const SWord8  s957 = s953 ^ s956;-  const SWord8  s958 = s952 ^ s957;-  const SWord8  s959 = table2[s932];-  const SWord8  s960 = table3[s934];-  const SWord8  s961 = table4[s937];-  const SWord8  s962 = table1[s939];-  const SWord8  s963 = s961 ^ s962;-  const SWord8  s964 = s960 ^ s963;-  const SWord8  s965 = s959 ^ s964;-  const SWord16 s966 = (((SWord16) s958) << 8) | ((SWord16) s965);-  const SWord32 s967 = (((SWord32) s951) << 16) | ((SWord32) s966);-  const SWord16 s968 = (SWord16) (s372 >> 16);-  const SWord8  s969 = (SWord8) (s968 >> 8);-  const SWord8  s970 = table1[s969];-  const SWord8  s971 = (SWord8) s968;-  const SWord8  s972 = table2[s971];-  const SWord16 s973 = (SWord16) s372;-  const SWord8  s974 = (SWord8) (s973 >> 8);-  const SWord8  s975 = table3[s974];-  const SWord8  s976 = (SWord8) s973;-  const SWord8  s977 = table4[s976];-  const SWord8  s978 = s975 ^ s977;-  const SWord8  s979 = s972 ^ s978;-  const SWord8  s980 = s970 ^ s979;-  const SWord8  s981 = table4[s969];-  const SWord8  s982 = table1[s971];-  const SWord8  s983 = table2[s974];-  const SWord8  s984 = table3[s976];-  const SWord8  s985 = s983 ^ s984;-  const SWord8  s986 = s982 ^ s985;-  const SWord8  s987 = s981 ^ s986;-  const SWord16 s988 = (((SWord16) s980) << 8) | ((SWord16) s987);-  const SWord8  s989 = table3[s969];-  const SWord8  s990 = table4[s971];-  const SWord8  s991 = table1[s974];-  const SWord8  s992 = table2[s976];-  const SWord8  s993 = s991 ^ s992;-  const SWord8  s994 = s990 ^ s993;-  const SWord8  s995 = s989 ^ s994;-  const SWord8  s996 = table2[s969];-  const SWord8  s997 = table3[s971];-  const SWord8  s998 = table4[s974];-  const SWord8  s999 = table1[s976];-  const SWord8  s1000 = s998 ^ s999;-  const SWord8  s1001 = s997 ^ s1000;-  const SWord8  s1002 = s996 ^ s1001;-  const SWord16 s1003 = (((SWord16) s995) << 8) | ((SWord16) s1002);-  const SWord32 s1004 = (((SWord32) s988) << 16) | ((SWord32) s1003);-  const SWord16 s1005 = (SWord16) (s373 >> 16);-  const SWord8  s1006 = (SWord8) (s1005 >> 8);-  const SWord8  s1007 = table1[s1006];-  const SWord8  s1008 = (SWord8) s1005;-  const SWord8  s1009 = table2[s1008];-  const SWord16 s1010 = (SWord16) s373;-  const SWord8  s1011 = (SWord8) (s1010 >> 8);-  const SWord8  s1012 = table3[s1011];-  const SWord8  s1013 = (SWord8) s1010;-  const SWord8  s1014 = table4[s1013];-  const SWord8  s1015 = s1012 ^ s1014;-  const SWord8  s1016 = s1009 ^ s1015;-  const SWord8  s1017 = s1007 ^ s1016;-  const SWord8  s1018 = table4[s1006];-  const SWord8  s1019 = table1[s1008];-  const SWord8  s1020 = table2[s1011];-  const SWord8  s1021 = table3[s1013];-  const SWord8  s1022 = s1020 ^ s1021;-  const SWord8  s1023 = s1019 ^ s1022;-  const SWord8  s1024 = s1018 ^ s1023;-  const SWord16 s1025 = (((SWord16) s1017) << 8) | ((SWord16) s1024);-  const SWord8  s1026 = table3[s1006];-  const SWord8  s1027 = table4[s1008];-  const SWord8  s1028 = table1[s1011];-  const SWord8  s1029 = table2[s1013];-  const SWord8  s1030 = s1028 ^ s1029;-  const SWord8  s1031 = s1027 ^ s1030;-  const SWord8  s1032 = s1026 ^ s1031;-  const SWord8  s1033 = table2[s1006];-  const SWord8  s1034 = table3[s1008];-  const SWord8  s1035 = table4[s1011];-  const SWord8  s1036 = table1[s1013];-  const SWord8  s1037 = s1035 ^ s1036;-  const SWord8  s1038 = s1034 ^ s1037;-  const SWord8  s1039 = s1033 ^ s1038;-  const SWord16 s1040 = (((SWord16) s1032) << 8) | ((SWord16) s1039);-  const SWord32 s1041 = (((SWord32) s1025) << 16) | ((SWord32) s1040);-  const SWord16 s1042 = (SWord16) (s351 >> 16);-  const SWord8  s1043 = (SWord8) (s1042 >> 8);-  const SWord8  s1044 = table1[s1043];-  const SWord8  s1045 = (SWord8) s1042;-  const SWord8  s1046 = table2[s1045];-  const SWord16 s1047 = (SWord16) s351;-  const SWord8  s1048 = (SWord8) (s1047 >> 8);-  const SWord8  s1049 = table3[s1048];-  const SWord8  s1050 = (SWord8) s1047;-  const SWord8  s1051 = table4[s1050];-  const SWord8  s1052 = s1049 ^ s1051;-  const SWord8  s1053 = s1046 ^ s1052;-  const SWord8  s1054 = s1044 ^ s1053;-  const SWord8  s1055 = table4[s1043];-  const SWord8  s1056 = table1[s1045];-  const SWord8  s1057 = table2[s1048];-  const SWord8  s1058 = table3[s1050];-  const SWord8  s1059 = s1057 ^ s1058;-  const SWord8  s1060 = s1056 ^ s1059;-  const SWord8  s1061 = s1055 ^ s1060;-  const SWord16 s1062 = (((SWord16) s1054) << 8) | ((SWord16) s1061);-  const SWord8  s1063 = table3[s1043];-  const SWord8  s1064 = table4[s1045];-  const SWord8  s1065 = table1[s1048];-  const SWord8  s1066 = table2[s1050];-  const SWord8  s1067 = s1065 ^ s1066;-  const SWord8  s1068 = s1064 ^ s1067;-  const SWord8  s1069 = s1063 ^ s1068;-  const SWord8  s1070 = table2[s1043];-  const SWord8  s1071 = table3[s1045];-  const SWord8  s1072 = table4[s1048];-  const SWord8  s1073 = table1[s1050];-  const SWord8  s1074 = s1072 ^ s1073;-  const SWord8  s1075 = s1071 ^ s1074;-  const SWord8  s1076 = s1070 ^ s1075;-  const SWord16 s1077 = (((SWord16) s1069) << 8) | ((SWord16) s1076);-  const SWord32 s1078 = (((SWord32) s1062) << 16) | ((SWord32) s1077);-  const SWord16 s1079 = (SWord16) (s352 >> 16);-  const SWord8  s1080 = (SWord8) (s1079 >> 8);-  const SWord8  s1081 = table1[s1080];-  const SWord8  s1082 = (SWord8) s1079;-  const SWord8  s1083 = table2[s1082];-  const SWord16 s1084 = (SWord16) s352;-  const SWord8  s1085 = (SWord8) (s1084 >> 8);-  const SWord8  s1086 = table3[s1085];-  const SWord8  s1087 = (SWord8) s1084;-  const SWord8  s1088 = table4[s1087];-  const SWord8  s1089 = s1086 ^ s1088;-  const SWord8  s1090 = s1083 ^ s1089;-  const SWord8  s1091 = s1081 ^ s1090;-  const SWord8  s1092 = table4[s1080];-  const SWord8  s1093 = table1[s1082];-  const SWord8  s1094 = table2[s1085];-  const SWord8  s1095 = table3[s1087];-  const SWord8  s1096 = s1094 ^ s1095;-  const SWord8  s1097 = s1093 ^ s1096;-  const SWord8  s1098 = s1092 ^ s1097;-  const SWord16 s1099 = (((SWord16) s1091) << 8) | ((SWord16) s1098);-  const SWord8  s1100 = table3[s1080];-  const SWord8  s1101 = table4[s1082];-  const SWord8  s1102 = table1[s1085];-  const SWord8  s1103 = table2[s1087];-  const SWord8  s1104 = s1102 ^ s1103;-  const SWord8  s1105 = s1101 ^ s1104;-  const SWord8  s1106 = s1100 ^ s1105;-  const SWord8  s1107 = table2[s1080];-  const SWord8  s1108 = table3[s1082];-  const SWord8  s1109 = table4[s1085];-  const SWord8  s1110 = table1[s1087];-  const SWord8  s1111 = s1109 ^ s1110;-  const SWord8  s1112 = s1108 ^ s1111;-  const SWord8  s1113 = s1107 ^ s1112;-  const SWord16 s1114 = (((SWord16) s1106) << 8) | ((SWord16) s1113);-  const SWord32 s1115 = (((SWord32) s1099) << 16) | ((SWord32) s1114);-  const SWord16 s1116 = (SWord16) (s353 >> 16);-  const SWord8  s1117 = (SWord8) (s1116 >> 8);-  const SWord8  s1118 = table1[s1117];-  const SWord8  s1119 = (SWord8) s1116;-  const SWord8  s1120 = table2[s1119];-  const SWord16 s1121 = (SWord16) s353;-  const SWord8  s1122 = (SWord8) (s1121 >> 8);-  const SWord8  s1123 = table3[s1122];-  const SWord8  s1124 = (SWord8) s1121;-  const SWord8  s1125 = table4[s1124];-  const SWord8  s1126 = s1123 ^ s1125;-  const SWord8  s1127 = s1120 ^ s1126;-  const SWord8  s1128 = s1118 ^ s1127;-  const SWord8  s1129 = table4[s1117];-  const SWord8  s1130 = table1[s1119];-  const SWord8  s1131 = table2[s1122];-  const SWord8  s1132 = table3[s1124];-  const SWord8  s1133 = s1131 ^ s1132;-  const SWord8  s1134 = s1130 ^ s1133;-  const SWord8  s1135 = s1129 ^ s1134;-  const SWord16 s1136 = (((SWord16) s1128) << 8) | ((SWord16) s1135);-  const SWord8  s1137 = table3[s1117];-  const SWord8  s1138 = table4[s1119];-  const SWord8  s1139 = table1[s1122];-  const SWord8  s1140 = table2[s1124];-  const SWord8  s1141 = s1139 ^ s1140;-  const SWord8  s1142 = s1138 ^ s1141;-  const SWord8  s1143 = s1137 ^ s1142;-  const SWord8  s1144 = table2[s1117];-  const SWord8  s1145 = table3[s1119];-  const SWord8  s1146 = table4[s1122];-  const SWord8  s1147 = table1[s1124];-  const SWord8  s1148 = s1146 ^ s1147;-  const SWord8  s1149 = s1145 ^ s1148;-  const SWord8  s1150 = s1144 ^ s1149;-  const SWord16 s1151 = (((SWord16) s1143) << 8) | ((SWord16) s1150);-  const SWord32 s1152 = (((SWord32) s1136) << 16) | ((SWord32) s1151);-  const SWord16 s1153 = (SWord16) (s354 >> 16);-  const SWord8  s1154 = (SWord8) (s1153 >> 8);-  const SWord8  s1155 = table1[s1154];-  const SWord8  s1156 = (SWord8) s1153;-  const SWord8  s1157 = table2[s1156];-  const SWord16 s1158 = (SWord16) s354;-  const SWord8  s1159 = (SWord8) (s1158 >> 8);-  const SWord8  s1160 = table3[s1159];-  const SWord8  s1161 = (SWord8) s1158;-  const SWord8  s1162 = table4[s1161];-  const SWord8  s1163 = s1160 ^ s1162;-  const SWord8  s1164 = s1157 ^ s1163;-  const SWord8  s1165 = s1155 ^ s1164;-  const SWord8  s1166 = table4[s1154];-  const SWord8  s1167 = table1[s1156];-  const SWord8  s1168 = table2[s1159];-  const SWord8  s1169 = table3[s1161];-  const SWord8  s1170 = s1168 ^ s1169;-  const SWord8  s1171 = s1167 ^ s1170;-  const SWord8  s1172 = s1166 ^ s1171;-  const SWord16 s1173 = (((SWord16) s1165) << 8) | ((SWord16) s1172);-  const SWord8  s1174 = table3[s1154];-  const SWord8  s1175 = table4[s1156];-  const SWord8  s1176 = table1[s1159];-  const SWord8  s1177 = table2[s1161];-  const SWord8  s1178 = s1176 ^ s1177;-  const SWord8  s1179 = s1175 ^ s1178;-  const SWord8  s1180 = s1174 ^ s1179;-  const SWord8  s1181 = table2[s1154];-  const SWord8  s1182 = table3[s1156];-  const SWord8  s1183 = table4[s1159];-  const SWord8  s1184 = table1[s1161];-  const SWord8  s1185 = s1183 ^ s1184;-  const SWord8  s1186 = s1182 ^ s1185;-  const SWord8  s1187 = s1181 ^ s1186;-  const SWord16 s1188 = (((SWord16) s1180) << 8) | ((SWord16) s1187);-  const SWord32 s1189 = (((SWord32) s1173) << 16) | ((SWord32) s1188);-  const SWord16 s1190 = (SWord16) (s332 >> 16);-  const SWord8  s1191 = (SWord8) (s1190 >> 8);-  const SWord8  s1192 = table1[s1191];-  const SWord8  s1193 = (SWord8) s1190;-  const SWord8  s1194 = table2[s1193];-  const SWord16 s1195 = (SWord16) s332;-  const SWord8  s1196 = (SWord8) (s1195 >> 8);-  const SWord8  s1197 = table3[s1196];-  const SWord8  s1198 = (SWord8) s1195;-  const SWord8  s1199 = table4[s1198];-  const SWord8  s1200 = s1197 ^ s1199;-  const SWord8  s1201 = s1194 ^ s1200;-  const SWord8  s1202 = s1192 ^ s1201;-  const SWord8  s1203 = table4[s1191];-  const SWord8  s1204 = table1[s1193];-  const SWord8  s1205 = table2[s1196];-  const SWord8  s1206 = table3[s1198];-  const SWord8  s1207 = s1205 ^ s1206;-  const SWord8  s1208 = s1204 ^ s1207;-  const SWord8  s1209 = s1203 ^ s1208;-  const SWord16 s1210 = (((SWord16) s1202) << 8) | ((SWord16) s1209);-  const SWord8  s1211 = table3[s1191];-  const SWord8  s1212 = table4[s1193];-  const SWord8  s1213 = table1[s1196];-  const SWord8  s1214 = table2[s1198];-  const SWord8  s1215 = s1213 ^ s1214;-  const SWord8  s1216 = s1212 ^ s1215;-  const SWord8  s1217 = s1211 ^ s1216;-  const SWord8  s1218 = table2[s1191];-  const SWord8  s1219 = table3[s1193];-  const SWord8  s1220 = table4[s1196];-  const SWord8  s1221 = table1[s1198];-  const SWord8  s1222 = s1220 ^ s1221;-  const SWord8  s1223 = s1219 ^ s1222;-  const SWord8  s1224 = s1218 ^ s1223;-  const SWord16 s1225 = (((SWord16) s1217) << 8) | ((SWord16) s1224);-  const SWord32 s1226 = (((SWord32) s1210) << 16) | ((SWord32) s1225);-  const SWord16 s1227 = (SWord16) (s333 >> 16);-  const SWord8  s1228 = (SWord8) (s1227 >> 8);-  const SWord8  s1229 = table1[s1228];-  const SWord8  s1230 = (SWord8) s1227;-  const SWord8  s1231 = table2[s1230];-  const SWord16 s1232 = (SWord16) s333;-  const SWord8  s1233 = (SWord8) (s1232 >> 8);-  const SWord8  s1234 = table3[s1233];-  const SWord8  s1235 = (SWord8) s1232;-  const SWord8  s1236 = table4[s1235];-  const SWord8  s1237 = s1234 ^ s1236;-  const SWord8  s1238 = s1231 ^ s1237;-  const SWord8  s1239 = s1229 ^ s1238;-  const SWord8  s1240 = table4[s1228];-  const SWord8  s1241 = table1[s1230];-  const SWord8  s1242 = table2[s1233];-  const SWord8  s1243 = table3[s1235];-  const SWord8  s1244 = s1242 ^ s1243;-  const SWord8  s1245 = s1241 ^ s1244;-  const SWord8  s1246 = s1240 ^ s1245;-  const SWord16 s1247 = (((SWord16) s1239) << 8) | ((SWord16) s1246);-  const SWord8  s1248 = table3[s1228];-  const SWord8  s1249 = table4[s1230];-  const SWord8  s1250 = table1[s1233];-  const SWord8  s1251 = table2[s1235];-  const SWord8  s1252 = s1250 ^ s1251;-  const SWord8  s1253 = s1249 ^ s1252;-  const SWord8  s1254 = s1248 ^ s1253;-  const SWord8  s1255 = table2[s1228];-  const SWord8  s1256 = table3[s1230];-  const SWord8  s1257 = table4[s1233];-  const SWord8  s1258 = table1[s1235];-  const SWord8  s1259 = s1257 ^ s1258;-  const SWord8  s1260 = s1256 ^ s1259;-  const SWord8  s1261 = s1255 ^ s1260;-  const SWord16 s1262 = (((SWord16) s1254) << 8) | ((SWord16) s1261);-  const SWord32 s1263 = (((SWord32) s1247) << 16) | ((SWord32) s1262);-  const SWord16 s1264 = (SWord16) (s334 >> 16);-  const SWord8  s1265 = (SWord8) (s1264 >> 8);-  const SWord8  s1266 = table1[s1265];-  const SWord8  s1267 = (SWord8) s1264;-  const SWord8  s1268 = table2[s1267];-  const SWord16 s1269 = (SWord16) s334;-  const SWord8  s1270 = (SWord8) (s1269 >> 8);-  const SWord8  s1271 = table3[s1270];-  const SWord8  s1272 = (SWord8) s1269;-  const SWord8  s1273 = table4[s1272];-  const SWord8  s1274 = s1271 ^ s1273;-  const SWord8  s1275 = s1268 ^ s1274;-  const SWord8  s1276 = s1266 ^ s1275;-  const SWord8  s1277 = table4[s1265];-  const SWord8  s1278 = table1[s1267];-  const SWord8  s1279 = table2[s1270];-  const SWord8  s1280 = table3[s1272];-  const SWord8  s1281 = s1279 ^ s1280;-  const SWord8  s1282 = s1278 ^ s1281;-  const SWord8  s1283 = s1277 ^ s1282;-  const SWord16 s1284 = (((SWord16) s1276) << 8) | ((SWord16) s1283);-  const SWord8  s1285 = table3[s1265];-  const SWord8  s1286 = table4[s1267];-  const SWord8  s1287 = table1[s1270];-  const SWord8  s1288 = table2[s1272];-  const SWord8  s1289 = s1287 ^ s1288;-  const SWord8  s1290 = s1286 ^ s1289;-  const SWord8  s1291 = s1285 ^ s1290;-  const SWord8  s1292 = table2[s1265];-  const SWord8  s1293 = table3[s1267];-  const SWord8  s1294 = table4[s1270];-  const SWord8  s1295 = table1[s1272];-  const SWord8  s1296 = s1294 ^ s1295;-  const SWord8  s1297 = s1293 ^ s1296;-  const SWord8  s1298 = s1292 ^ s1297;-  const SWord16 s1299 = (((SWord16) s1291) << 8) | ((SWord16) s1298);-  const SWord32 s1300 = (((SWord32) s1284) << 16) | ((SWord32) s1299);-  const SWord16 s1301 = (SWord16) (s335 >> 16);-  const SWord8  s1302 = (SWord8) (s1301 >> 8);-  const SWord8  s1303 = table1[s1302];-  const SWord8  s1304 = (SWord8) s1301;-  const SWord8  s1305 = table2[s1304];-  const SWord16 s1306 = (SWord16) s335;-  const SWord8  s1307 = (SWord8) (s1306 >> 8);-  const SWord8  s1308 = table3[s1307];-  const SWord8  s1309 = (SWord8) s1306;-  const SWord8  s1310 = table4[s1309];-  const SWord8  s1311 = s1308 ^ s1310;-  const SWord8  s1312 = s1305 ^ s1311;-  const SWord8  s1313 = s1303 ^ s1312;-  const SWord8  s1314 = table4[s1302];-  const SWord8  s1315 = table1[s1304];-  const SWord8  s1316 = table2[s1307];-  const SWord8  s1317 = table3[s1309];-  const SWord8  s1318 = s1316 ^ s1317;-  const SWord8  s1319 = s1315 ^ s1318;-  const SWord8  s1320 = s1314 ^ s1319;-  const SWord16 s1321 = (((SWord16) s1313) << 8) | ((SWord16) s1320);-  const SWord8  s1322 = table3[s1302];-  const SWord8  s1323 = table4[s1304];-  const SWord8  s1324 = table1[s1307];-  const SWord8  s1325 = table2[s1309];-  const SWord8  s1326 = s1324 ^ s1325;-  const SWord8  s1327 = s1323 ^ s1326;-  const SWord8  s1328 = s1322 ^ s1327;-  const SWord8  s1329 = table2[s1302];-  const SWord8  s1330 = table3[s1304];-  const SWord8  s1331 = table4[s1307];-  const SWord8  s1332 = table1[s1309];-  const SWord8  s1333 = s1331 ^ s1332;-  const SWord8  s1334 = s1330 ^ s1333;-  const SWord8  s1335 = s1329 ^ s1334;-  const SWord16 s1336 = (((SWord16) s1328) << 8) | ((SWord16) s1335);-  const SWord32 s1337 = (((SWord32) s1321) << 16) | ((SWord32) s1336);-  const SWord16 s1338 = (SWord16) (s313 >> 16);-  const SWord8  s1339 = (SWord8) (s1338 >> 8);-  const SWord8  s1340 = table1[s1339];-  const SWord8  s1341 = (SWord8) s1338;-  const SWord8  s1342 = table2[s1341];-  const SWord16 s1343 = (SWord16) s313;-  const SWord8  s1344 = (SWord8) (s1343 >> 8);-  const SWord8  s1345 = table3[s1344];-  const SWord8  s1346 = (SWord8) s1343;-  const SWord8  s1347 = table4[s1346];-  const SWord8  s1348 = s1345 ^ s1347;-  const SWord8  s1349 = s1342 ^ s1348;-  const SWord8  s1350 = s1340 ^ s1349;-  const SWord8  s1351 = table4[s1339];-  const SWord8  s1352 = table1[s1341];-  const SWord8  s1353 = table2[s1344];-  const SWord8  s1354 = table3[s1346];-  const SWord8  s1355 = s1353 ^ s1354;-  const SWord8  s1356 = s1352 ^ s1355;-  const SWord8  s1357 = s1351 ^ s1356;-  const SWord16 s1358 = (((SWord16) s1350) << 8) | ((SWord16) s1357);-  const SWord8  s1359 = table3[s1339];-  const SWord8  s1360 = table4[s1341];-  const SWord8  s1361 = table1[s1344];-  const SWord8  s1362 = table2[s1346];-  const SWord8  s1363 = s1361 ^ s1362;-  const SWord8  s1364 = s1360 ^ s1363;-  const SWord8  s1365 = s1359 ^ s1364;-  const SWord8  s1366 = table2[s1339];-  const SWord8  s1367 = table3[s1341];-  const SWord8  s1368 = table4[s1344];-  const SWord8  s1369 = table1[s1346];-  const SWord8  s1370 = s1368 ^ s1369;-  const SWord8  s1371 = s1367 ^ s1370;-  const SWord8  s1372 = s1366 ^ s1371;-  const SWord16 s1373 = (((SWord16) s1365) << 8) | ((SWord16) s1372);-  const SWord32 s1374 = (((SWord32) s1358) << 16) | ((SWord32) s1373);-  const SWord16 s1375 = (SWord16) (s314 >> 16);-  const SWord8  s1376 = (SWord8) (s1375 >> 8);-  const SWord8  s1377 = table1[s1376];-  const SWord8  s1378 = (SWord8) s1375;-  const SWord8  s1379 = table2[s1378];-  const SWord16 s1380 = (SWord16) s314;-  const SWord8  s1381 = (SWord8) (s1380 >> 8);-  const SWord8  s1382 = table3[s1381];-  const SWord8  s1383 = (SWord8) s1380;-  const SWord8  s1384 = table4[s1383];-  const SWord8  s1385 = s1382 ^ s1384;-  const SWord8  s1386 = s1379 ^ s1385;-  const SWord8  s1387 = s1377 ^ s1386;-  const SWord8  s1388 = table4[s1376];-  const SWord8  s1389 = table1[s1378];-  const SWord8  s1390 = table2[s1381];-  const SWord8  s1391 = table3[s1383];-  const SWord8  s1392 = s1390 ^ s1391;-  const SWord8  s1393 = s1389 ^ s1392;-  const SWord8  s1394 = s1388 ^ s1393;-  const SWord16 s1395 = (((SWord16) s1387) << 8) | ((SWord16) s1394);-  const SWord8  s1396 = table3[s1376];-  const SWord8  s1397 = table4[s1378];-  const SWord8  s1398 = table1[s1381];-  const SWord8  s1399 = table2[s1383];-  const SWord8  s1400 = s1398 ^ s1399;-  const SWord8  s1401 = s1397 ^ s1400;-  const SWord8  s1402 = s1396 ^ s1401;-  const SWord8  s1403 = table2[s1376];-  const SWord8  s1404 = table3[s1378];-  const SWord8  s1405 = table4[s1381];-  const SWord8  s1406 = table1[s1383];-  const SWord8  s1407 = s1405 ^ s1406;-  const SWord8  s1408 = s1404 ^ s1407;-  const SWord8  s1409 = s1403 ^ s1408;-  const SWord16 s1410 = (((SWord16) s1402) << 8) | ((SWord16) s1409);-  const SWord32 s1411 = (((SWord32) s1395) << 16) | ((SWord32) s1410);-  const SWord16 s1412 = (SWord16) (s315 >> 16);-  const SWord8  s1413 = (SWord8) (s1412 >> 8);-  const SWord8  s1414 = table1[s1413];-  const SWord8  s1415 = (SWord8) s1412;-  const SWord8  s1416 = table2[s1415];-  const SWord16 s1417 = (SWord16) s315;-  const SWord8  s1418 = (SWord8) (s1417 >> 8);-  const SWord8  s1419 = table3[s1418];-  const SWord8  s1420 = (SWord8) s1417;-  const SWord8  s1421 = table4[s1420];-  const SWord8  s1422 = s1419 ^ s1421;-  const SWord8  s1423 = s1416 ^ s1422;-  const SWord8  s1424 = s1414 ^ s1423;-  const SWord8  s1425 = table4[s1413];-  const SWord8  s1426 = table1[s1415];-  const SWord8  s1427 = table2[s1418];-  const SWord8  s1428 = table3[s1420];-  const SWord8  s1429 = s1427 ^ s1428;-  const SWord8  s1430 = s1426 ^ s1429;-  const SWord8  s1431 = s1425 ^ s1430;-  const SWord16 s1432 = (((SWord16) s1424) << 8) | ((SWord16) s1431);-  const SWord8  s1433 = table3[s1413];-  const SWord8  s1434 = table4[s1415];-  const SWord8  s1435 = table1[s1418];-  const SWord8  s1436 = table2[s1420];-  const SWord8  s1437 = s1435 ^ s1436;-  const SWord8  s1438 = s1434 ^ s1437;-  const SWord8  s1439 = s1433 ^ s1438;-  const SWord8  s1440 = table2[s1413];-  const SWord8  s1441 = table3[s1415];-  const SWord8  s1442 = table4[s1418];-  const SWord8  s1443 = table1[s1420];-  const SWord8  s1444 = s1442 ^ s1443;-  const SWord8  s1445 = s1441 ^ s1444;-  const SWord8  s1446 = s1440 ^ s1445;-  const SWord16 s1447 = (((SWord16) s1439) << 8) | ((SWord16) s1446);-  const SWord32 s1448 = (((SWord32) s1432) << 16) | ((SWord32) s1447);-  const SWord16 s1449 = (SWord16) (s316 >> 16);-  const SWord8  s1450 = (SWord8) (s1449 >> 8);-  const SWord8  s1451 = table1[s1450];-  const SWord8  s1452 = (SWord8) s1449;-  const SWord8  s1453 = table2[s1452];-  const SWord16 s1454 = (SWord16) s316;-  const SWord8  s1455 = (SWord8) (s1454 >> 8);-  const SWord8  s1456 = table3[s1455];-  const SWord8  s1457 = (SWord8) s1454;-  const SWord8  s1458 = table4[s1457];-  const SWord8  s1459 = s1456 ^ s1458;-  const SWord8  s1460 = s1453 ^ s1459;-  const SWord8  s1461 = s1451 ^ s1460;-  const SWord8  s1462 = table4[s1450];-  const SWord8  s1463 = table1[s1452];-  const SWord8  s1464 = table2[s1455];-  const SWord8  s1465 = table3[s1457];-  const SWord8  s1466 = s1464 ^ s1465;-  const SWord8  s1467 = s1463 ^ s1466;-  const SWord8  s1468 = s1462 ^ s1467;-  const SWord16 s1469 = (((SWord16) s1461) << 8) | ((SWord16) s1468);-  const SWord8  s1470 = table3[s1450];-  const SWord8  s1471 = table4[s1452];-  const SWord8  s1472 = table1[s1455];-  const SWord8  s1473 = table2[s1457];-  const SWord8  s1474 = s1472 ^ s1473;-  const SWord8  s1475 = s1471 ^ s1474;-  const SWord8  s1476 = s1470 ^ s1475;-  const SWord8  s1477 = table2[s1450];-  const SWord8  s1478 = table3[s1452];-  const SWord8  s1479 = table4[s1455];-  const SWord8  s1480 = table1[s1457];-  const SWord8  s1481 = s1479 ^ s1480;-  const SWord8  s1482 = s1478 ^ s1481;-  const SWord8  s1483 = s1477 ^ s1482;-  const SWord16 s1484 = (((SWord16) s1476) << 8) | ((SWord16) s1483);-  const SWord32 s1485 = (((SWord32) s1469) << 16) | ((SWord32) s1484);-  const SWord16 s1486 = (SWord16) (s294 >> 16);-  const SWord8  s1487 = (SWord8) (s1486 >> 8);-  const SWord8  s1488 = table1[s1487];-  const SWord8  s1489 = (SWord8) s1486;-  const SWord8  s1490 = table2[s1489];-  const SWord16 s1491 = (SWord16) s294;-  const SWord8  s1492 = (SWord8) (s1491 >> 8);-  const SWord8  s1493 = table3[s1492];-  const SWord8  s1494 = (SWord8) s1491;-  const SWord8  s1495 = table4[s1494];-  const SWord8  s1496 = s1493 ^ s1495;-  const SWord8  s1497 = s1490 ^ s1496;-  const SWord8  s1498 = s1488 ^ s1497;-  const SWord8  s1499 = table4[s1487];-  const SWord8  s1500 = table1[s1489];-  const SWord8  s1501 = table2[s1492];-  const SWord8  s1502 = table3[s1494];-  const SWord8  s1503 = s1501 ^ s1502;-  const SWord8  s1504 = s1500 ^ s1503;-  const SWord8  s1505 = s1499 ^ s1504;-  const SWord16 s1506 = (((SWord16) s1498) << 8) | ((SWord16) s1505);-  const SWord8  s1507 = table3[s1487];-  const SWord8  s1508 = table4[s1489];-  const SWord8  s1509 = table1[s1492];-  const SWord8  s1510 = table2[s1494];-  const SWord8  s1511 = s1509 ^ s1510;-  const SWord8  s1512 = s1508 ^ s1511;-  const SWord8  s1513 = s1507 ^ s1512;-  const SWord8  s1514 = table2[s1487];-  const SWord8  s1515 = table3[s1489];-  const SWord8  s1516 = table4[s1492];-  const SWord8  s1517 = table1[s1494];-  const SWord8  s1518 = s1516 ^ s1517;-  const SWord8  s1519 = s1515 ^ s1518;-  const SWord8  s1520 = s1514 ^ s1519;-  const SWord16 s1521 = (((SWord16) s1513) << 8) | ((SWord16) s1520);-  const SWord32 s1522 = (((SWord32) s1506) << 16) | ((SWord32) s1521);-  const SWord16 s1523 = (SWord16) (s295 >> 16);-  const SWord8  s1524 = (SWord8) (s1523 >> 8);-  const SWord8  s1525 = table1[s1524];-  const SWord8  s1526 = (SWord8) s1523;-  const SWord8  s1527 = table2[s1526];-  const SWord16 s1528 = (SWord16) s295;-  const SWord8  s1529 = (SWord8) (s1528 >> 8);-  const SWord8  s1530 = table3[s1529];-  const SWord8  s1531 = (SWord8) s1528;-  const SWord8  s1532 = table4[s1531];-  const SWord8  s1533 = s1530 ^ s1532;-  const SWord8  s1534 = s1527 ^ s1533;-  const SWord8  s1535 = s1525 ^ s1534;-  const SWord8  s1536 = table4[s1524];-  const SWord8  s1537 = table1[s1526];-  const SWord8  s1538 = table2[s1529];-  const SWord8  s1539 = table3[s1531];-  const SWord8  s1540 = s1538 ^ s1539;-  const SWord8  s1541 = s1537 ^ s1540;-  const SWord8  s1542 = s1536 ^ s1541;-  const SWord16 s1543 = (((SWord16) s1535) << 8) | ((SWord16) s1542);-  const SWord8  s1544 = table3[s1524];-  const SWord8  s1545 = table4[s1526];-  const SWord8  s1546 = table1[s1529];-  const SWord8  s1547 = table2[s1531];-  const SWord8  s1548 = s1546 ^ s1547;-  const SWord8  s1549 = s1545 ^ s1548;-  const SWord8  s1550 = s1544 ^ s1549;-  const SWord8  s1551 = table2[s1524];-  const SWord8  s1552 = table3[s1526];-  const SWord8  s1553 = table4[s1529];-  const SWord8  s1554 = table1[s1531];-  const SWord8  s1555 = s1553 ^ s1554;-  const SWord8  s1556 = s1552 ^ s1555;-  const SWord8  s1557 = s1551 ^ s1556;-  const SWord16 s1558 = (((SWord16) s1550) << 8) | ((SWord16) s1557);-  const SWord32 s1559 = (((SWord32) s1543) << 16) | ((SWord32) s1558);-  const SWord16 s1560 = (SWord16) (s296 >> 16);-  const SWord8  s1561 = (SWord8) (s1560 >> 8);-  const SWord8  s1562 = table1[s1561];-  const SWord8  s1563 = (SWord8) s1560;-  const SWord8  s1564 = table2[s1563];-  const SWord16 s1565 = (SWord16) s296;-  const SWord8  s1566 = (SWord8) (s1565 >> 8);-  const SWord8  s1567 = table3[s1566];-  const SWord8  s1568 = (SWord8) s1565;-  const SWord8  s1569 = table4[s1568];-  const SWord8  s1570 = s1567 ^ s1569;-  const SWord8  s1571 = s1564 ^ s1570;-  const SWord8  s1572 = s1562 ^ s1571;-  const SWord8  s1573 = table4[s1561];-  const SWord8  s1574 = table1[s1563];-  const SWord8  s1575 = table2[s1566];-  const SWord8  s1576 = table3[s1568];-  const SWord8  s1577 = s1575 ^ s1576;-  const SWord8  s1578 = s1574 ^ s1577;-  const SWord8  s1579 = s1573 ^ s1578;-  const SWord16 s1580 = (((SWord16) s1572) << 8) | ((SWord16) s1579);-  const SWord8  s1581 = table3[s1561];-  const SWord8  s1582 = table4[s1563];-  const SWord8  s1583 = table1[s1566];-  const SWord8  s1584 = table2[s1568];-  const SWord8  s1585 = s1583 ^ s1584;-  const SWord8  s1586 = s1582 ^ s1585;-  const SWord8  s1587 = s1581 ^ s1586;-  const SWord8  s1588 = table2[s1561];-  const SWord8  s1589 = table3[s1563];-  const SWord8  s1590 = table4[s1566];-  const SWord8  s1591 = table1[s1568];-  const SWord8  s1592 = s1590 ^ s1591;-  const SWord8  s1593 = s1589 ^ s1592;-  const SWord8  s1594 = s1588 ^ s1593;-  const SWord16 s1595 = (((SWord16) s1587) << 8) | ((SWord16) s1594);-  const SWord32 s1596 = (((SWord32) s1580) << 16) | ((SWord32) s1595);-  const SWord16 s1597 = (SWord16) (s297 >> 16);-  const SWord8  s1598 = (SWord8) (s1597 >> 8);-  const SWord8  s1599 = table1[s1598];-  const SWord8  s1600 = (SWord8) s1597;-  const SWord8  s1601 = table2[s1600];-  const SWord16 s1602 = (SWord16) s297;-  const SWord8  s1603 = (SWord8) (s1602 >> 8);-  const SWord8  s1604 = table3[s1603];-  const SWord8  s1605 = (SWord8) s1602;-  const SWord8  s1606 = table4[s1605];-  const SWord8  s1607 = s1604 ^ s1606;-  const SWord8  s1608 = s1601 ^ s1607;-  const SWord8  s1609 = s1599 ^ s1608;-  const SWord8  s1610 = table4[s1598];-  const SWord8  s1611 = table1[s1600];-  const SWord8  s1612 = table2[s1603];-  const SWord8  s1613 = table3[s1605];-  const SWord8  s1614 = s1612 ^ s1613;-  const SWord8  s1615 = s1611 ^ s1614;-  const SWord8  s1616 = s1610 ^ s1615;-  const SWord16 s1617 = (((SWord16) s1609) << 8) | ((SWord16) s1616);-  const SWord8  s1618 = table3[s1598];-  const SWord8  s1619 = table4[s1600];-  const SWord8  s1620 = table1[s1603];-  const SWord8  s1621 = table2[s1605];-  const SWord8  s1622 = s1620 ^ s1621;-  const SWord8  s1623 = s1619 ^ s1622;-  const SWord8  s1624 = s1618 ^ s1623;-  const SWord8  s1625 = table2[s1598];-  const SWord8  s1626 = table3[s1600];-  const SWord8  s1627 = table4[s1603];-  const SWord8  s1628 = table1[s1605];-  const SWord8  s1629 = s1627 ^ s1628;-  const SWord8  s1630 = s1626 ^ s1629;-  const SWord8  s1631 = s1625 ^ s1630;-  const SWord16 s1632 = (((SWord16) s1624) << 8) | ((SWord16) s1631);-  const SWord32 s1633 = (((SWord32) s1617) << 16) | ((SWord32) s1632);-  const SWord16 s1634 = (SWord16) (s275 >> 16);-  const SWord8  s1635 = (SWord8) (s1634 >> 8);-  const SWord8  s1636 = table1[s1635];-  const SWord8  s1637 = (SWord8) s1634;-  const SWord8  s1638 = table2[s1637];-  const SWord16 s1639 = (SWord16) s275;-  const SWord8  s1640 = (SWord8) (s1639 >> 8);-  const SWord8  s1641 = table3[s1640];-  const SWord8  s1642 = (SWord8) s1639;-  const SWord8  s1643 = table4[s1642];-  const SWord8  s1644 = s1641 ^ s1643;-  const SWord8  s1645 = s1638 ^ s1644;-  const SWord8  s1646 = s1636 ^ s1645;-  const SWord8  s1647 = table4[s1635];-  const SWord8  s1648 = table1[s1637];-  const SWord8  s1649 = table2[s1640];-  const SWord8  s1650 = table3[s1642];-  const SWord8  s1651 = s1649 ^ s1650;-  const SWord8  s1652 = s1648 ^ s1651;-  const SWord8  s1653 = s1647 ^ s1652;-  const SWord16 s1654 = (((SWord16) s1646) << 8) | ((SWord16) s1653);-  const SWord8  s1655 = table3[s1635];-  const SWord8  s1656 = table4[s1637];-  const SWord8  s1657 = table1[s1640];-  const SWord8  s1658 = table2[s1642];-  const SWord8  s1659 = s1657 ^ s1658;-  const SWord8  s1660 = s1656 ^ s1659;-  const SWord8  s1661 = s1655 ^ s1660;-  const SWord8  s1662 = table2[s1635];-  const SWord8  s1663 = table3[s1637];-  const SWord8  s1664 = table4[s1640];-  const SWord8  s1665 = table1[s1642];-  const SWord8  s1666 = s1664 ^ s1665;-  const SWord8  s1667 = s1663 ^ s1666;-  const SWord8  s1668 = s1662 ^ s1667;-  const SWord16 s1669 = (((SWord16) s1661) << 8) | ((SWord16) s1668);-  const SWord32 s1670 = (((SWord32) s1654) << 16) | ((SWord32) s1669);-  const SWord16 s1671 = (SWord16) (s276 >> 16);-  const SWord8  s1672 = (SWord8) (s1671 >> 8);-  const SWord8  s1673 = table1[s1672];-  const SWord8  s1674 = (SWord8) s1671;-  const SWord8  s1675 = table2[s1674];-  const SWord16 s1676 = (SWord16) s276;-  const SWord8  s1677 = (SWord8) (s1676 >> 8);-  const SWord8  s1678 = table3[s1677];-  const SWord8  s1679 = (SWord8) s1676;-  const SWord8  s1680 = table4[s1679];-  const SWord8  s1681 = s1678 ^ s1680;-  const SWord8  s1682 = s1675 ^ s1681;-  const SWord8  s1683 = s1673 ^ s1682;-  const SWord8  s1684 = table4[s1672];-  const SWord8  s1685 = table1[s1674];-  const SWord8  s1686 = table2[s1677];-  const SWord8  s1687 = table3[s1679];-  const SWord8  s1688 = s1686 ^ s1687;-  const SWord8  s1689 = s1685 ^ s1688;-  const SWord8  s1690 = s1684 ^ s1689;-  const SWord16 s1691 = (((SWord16) s1683) << 8) | ((SWord16) s1690);-  const SWord8  s1692 = table3[s1672];-  const SWord8  s1693 = table4[s1674];-  const SWord8  s1694 = table1[s1677];-  const SWord8  s1695 = table2[s1679];-  const SWord8  s1696 = s1694 ^ s1695;-  const SWord8  s1697 = s1693 ^ s1696;-  const SWord8  s1698 = s1692 ^ s1697;-  const SWord8  s1699 = table2[s1672];-  const SWord8  s1700 = table3[s1674];-  const SWord8  s1701 = table4[s1677];-  const SWord8  s1702 = table1[s1679];-  const SWord8  s1703 = s1701 ^ s1702;-  const SWord8  s1704 = s1700 ^ s1703;-  const SWord8  s1705 = s1699 ^ s1704;-  const SWord16 s1706 = (((SWord16) s1698) << 8) | ((SWord16) s1705);-  const SWord32 s1707 = (((SWord32) s1691) << 16) | ((SWord32) s1706);-  const SWord16 s1708 = (SWord16) (s277 >> 16);-  const SWord8  s1709 = (SWord8) (s1708 >> 8);-  const SWord8  s1710 = table1[s1709];-  const SWord8  s1711 = (SWord8) s1708;-  const SWord8  s1712 = table2[s1711];-  const SWord16 s1713 = (SWord16) s277;-  const SWord8  s1714 = (SWord8) (s1713 >> 8);-  const SWord8  s1715 = table3[s1714];-  const SWord8  s1716 = (SWord8) s1713;-  const SWord8  s1717 = table4[s1716];-  const SWord8  s1718 = s1715 ^ s1717;-  const SWord8  s1719 = s1712 ^ s1718;-  const SWord8  s1720 = s1710 ^ s1719;-  const SWord8  s1721 = table4[s1709];-  const SWord8  s1722 = table1[s1711];-  const SWord8  s1723 = table2[s1714];-  const SWord8  s1724 = table3[s1716];-  const SWord8  s1725 = s1723 ^ s1724;-  const SWord8  s1726 = s1722 ^ s1725;-  const SWord8  s1727 = s1721 ^ s1726;-  const SWord16 s1728 = (((SWord16) s1720) << 8) | ((SWord16) s1727);-  const SWord8  s1729 = table3[s1709];-  const SWord8  s1730 = table4[s1711];-  const SWord8  s1731 = table1[s1714];-  const SWord8  s1732 = table2[s1716];-  const SWord8  s1733 = s1731 ^ s1732;-  const SWord8  s1734 = s1730 ^ s1733;-  const SWord8  s1735 = s1729 ^ s1734;-  const SWord8  s1736 = table2[s1709];-  const SWord8  s1737 = table3[s1711];-  const SWord8  s1738 = table4[s1714];-  const SWord8  s1739 = table1[s1716];-  const SWord8  s1740 = s1738 ^ s1739;-  const SWord8  s1741 = s1737 ^ s1740;-  const SWord8  s1742 = s1736 ^ s1741;-  const SWord16 s1743 = (((SWord16) s1735) << 8) | ((SWord16) s1742);-  const SWord32 s1744 = (((SWord32) s1728) << 16) | ((SWord32) s1743);-  const SWord16 s1745 = (SWord16) (s278 >> 16);-  const SWord8  s1746 = (SWord8) (s1745 >> 8);-  const SWord8  s1747 = table1[s1746];-  const SWord8  s1748 = (SWord8) s1745;-  const SWord8  s1749 = table2[s1748];-  const SWord16 s1750 = (SWord16) s278;-  const SWord8  s1751 = (SWord8) (s1750 >> 8);-  const SWord8  s1752 = table3[s1751];-  const SWord8  s1753 = (SWord8) s1750;-  const SWord8  s1754 = table4[s1753];-  const SWord8  s1755 = s1752 ^ s1754;-  const SWord8  s1756 = s1749 ^ s1755;-  const SWord8  s1757 = s1747 ^ s1756;-  const SWord8  s1758 = table4[s1746];-  const SWord8  s1759 = table1[s1748];-  const SWord8  s1760 = table2[s1751];-  const SWord8  s1761 = table3[s1753];-  const SWord8  s1762 = s1760 ^ s1761;-  const SWord8  s1763 = s1759 ^ s1762;-  const SWord8  s1764 = s1758 ^ s1763;-  const SWord16 s1765 = (((SWord16) s1757) << 8) | ((SWord16) s1764);-  const SWord8  s1766 = table3[s1746];-  const SWord8  s1767 = table4[s1748];-  const SWord8  s1768 = table1[s1751];-  const SWord8  s1769 = table2[s1753];-  const SWord8  s1770 = s1768 ^ s1769;-  const SWord8  s1771 = s1767 ^ s1770;-  const SWord8  s1772 = s1766 ^ s1771;-  const SWord8  s1773 = table2[s1746];-  const SWord8  s1774 = table3[s1748];-  const SWord8  s1775 = table4[s1751];-  const SWord8  s1776 = table1[s1753];-  const SWord8  s1777 = s1775 ^ s1776;-  const SWord8  s1778 = s1774 ^ s1777;-  const SWord8  s1779 = s1773 ^ s1778;-  const SWord16 s1780 = (((SWord16) s1772) << 8) | ((SWord16) s1779);-  const SWord32 s1781 = (((SWord32) s1765) << 16) | ((SWord32) s1780);--  encKS[0] = s0;-  encKS[1] = s1;-  encKS[2] = s2;-  encKS[3] = s3;-  encKS[4] = s275;-  encKS[5] = s276;-  encKS[6] = s277;-  encKS[7] = s278;-  encKS[8] = s294;-  encKS[9] = s295;-  encKS[10] = s296;-  encKS[11] = s297;-  encKS[12] = s313;-  encKS[13] = s314;-  encKS[14] = s315;-  encKS[15] = s316;-  encKS[16] = s332;-  encKS[17] = s333;-  encKS[18] = s334;-  encKS[19] = s335;-  encKS[20] = s351;-  encKS[21] = s352;-  encKS[22] = s353;-  encKS[23] = s354;-  encKS[24] = s370;-  encKS[25] = s371;-  encKS[26] = s372;-  encKS[27] = s373;-  encKS[28] = s389;-  encKS[29] = s390;-  encKS[30] = s391;-  encKS[31] = s392;-  encKS[32] = s408;-  encKS[33] = s409;-  encKS[34] = s410;-  encKS[35] = s411;-  encKS[36] = s427;-  encKS[37] = s428;-  encKS[38] = s429;-  encKS[39] = s430;-  encKS[40] = s446;-  encKS[41] = s447;-  encKS[42] = s448;-  encKS[43] = s449;-  decKS[0] = s446;-  decKS[1] = s447;-  decKS[2] = s448;-  decKS[3] = s449;-  decKS[4] = s486;-  decKS[5] = s523;-  decKS[6] = s560;-  decKS[7] = s597;-  decKS[8] = s634;-  decKS[9] = s671;-  decKS[10] = s708;-  decKS[11] = s745;-  decKS[12] = s782;-  decKS[13] = s819;-  decKS[14] = s856;-  decKS[15] = s893;-  decKS[16] = s930;-  decKS[17] = s967;-  decKS[18] = s1004;-  decKS[19] = s1041;-  decKS[20] = s1078;-  decKS[21] = s1115;-  decKS[22] = s1152;-  decKS[23] = s1189;-  decKS[24] = s1226;-  decKS[25] = s1263;-  decKS[26] = s1300;-  decKS[27] = s1337;-  decKS[28] = s1374;-  decKS[29] = s1411;-  decKS[30] = s1448;-  decKS[31] = s1485;-  decKS[32] = s1522;-  decKS[33] = s1559;-  decKS[34] = s1596;-  decKS[35] = s1633;-  decKS[36] = s1670;-  decKS[37] = s1707;-  decKS[38] = s1744;-  decKS[39] = s1781;-  decKS[40] = s0;-  decKS[41] = s1;-  decKS[42] = s2;-  decKS[43] = s3;-}-== END: "aes128KeySchedule.c" ==================-== BEGIN: "aes128BlockEncrypt.c" ================-/* File: "aes128BlockEncrypt.c". Automatically generated by SBV. Do not edit! */--#include "aes128Lib.h"--void aes128BlockEncrypt(const SWord32 *pt, const SWord32 *xkey,-                        SWord32 *ct)-{-  const SWord32 s0 = pt[0];-  const SWord32 s1 = pt[1];-  const SWord32 s2 = pt[2];-  const SWord32 s3 = pt[3];-  const SWord32 s4 = xkey[0];-  const SWord32 s5 = xkey[1];-  const SWord32 s6 = xkey[2];-  const SWord32 s7 = xkey[3];-  const SWord32 s8 = xkey[4];-  const SWord32 s9 = xkey[5];-  const SWord32 s10 = xkey[6];-  const SWord32 s11 = xkey[7];-  const SWord32 s12 = xkey[8];-  const SWord32 s13 = xkey[9];-  const SWord32 s14 = xkey[10];-  const SWord32 s15 = xkey[11];-  const SWord32 s16 = xkey[12];-  const SWord32 s17 = xkey[13];-  const SWord32 s18 = xkey[14];-  const SWord32 s19 = xkey[15];-  const SWord32 s20 = xkey[16];-  const SWord32 s21 = xkey[17];-  const SWord32 s22 = xkey[18];-  const SWord32 s23 = xkey[19];-  const SWord32 s24 = xkey[20];-  const SWord32 s25 = xkey[21];-  const SWord32 s26 = xkey[22];-  const SWord32 s27 = xkey[23];-  const SWord32 s28 = xkey[24];-  const SWord32 s29 = xkey[25];-  const SWord32 s30 = xkey[26];-  const SWord32 s31 = xkey[27];-  const SWord32 s32 = xkey[28];-  const SWord32 s33 = xkey[29];-  const SWord32 s34 = xkey[30];-  const SWord32 s35 = xkey[31];-  const SWord32 s36 = xkey[32];-  const SWord32 s37 = xkey[33];-  const SWord32 s38 = xkey[34];-  const SWord32 s39 = xkey[35];-  const SWord32 s40 = xkey[36];-  const SWord32 s41 = xkey[37];-  const SWord32 s42 = xkey[38];-  const SWord32 s43 = xkey[39];-  const SWord32 s44 = xkey[40];-  const SWord32 s45 = xkey[41];-  const SWord32 s46 = xkey[42];-  const SWord32 s47 = xkey[43];-  static const SWord8 table0[] = {-       99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254,-      215, 171, 118, 202, 130, 201, 125, 250,  89,  71, 240, 173, 212,-      162, 175, 156, 164, 114, 192, 183, 253, 147,  38,  54,  63, 247,-      204,  52, 165, 229, 241, 113, 216,  49,  21,   4, 199,  35, 195,-       24, 150,   5, 154,   7,  18, 128, 226, 235,  39, 178, 117,   9,-      131,  44,  26,  27, 110,  90, 160,  82,  59, 214, 179,  41, 227,-       47, 132,  83, 209,   0, 237,  32, 252, 177,  91, 106, 203, 190,-       57,  74,  76,  88, 207, 208, 239, 170, 251,  67,  77,  51, 133,-       69, 249,   2, 127,  80,  60, 159, 168,  81, 163,  64, 143, 146,-      157,  56, 245, 188, 182, 218,  33,  16, 255, 243, 210, 205,  12,-       19, 236,  95, 151,  68,  23, 196, 167, 126,  61, 100,  93,  25,-      115,  96, 129,  79, 220,  34,  42, 144, 136,  70, 238, 184,  20,-      222,  94,  11, 219, 224,  50,  58,  10,  73,   6,  36,  92, 194,-      211, 172,  98, 145, 149, 228, 121, 231, 200,  55, 109, 141, 213,-       78, 169, 108,  86, 244, 234, 101, 122, 174,   8, 186, 120,  37,-       46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138,-      112,  62, 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134,-      193,  29, 158, 225, 248, 152,  17, 105, 217, 142, 148, 155,  30,-      135, 233, 206,  85,  40, 223, 140, 161, 137,  13, 191, 230,  66,-      104,  65, 153,  45,  15, 176,  84, 187,  22-  };-  static const SWord32 table1[] = {-      0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL,-      0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL,-      0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL,-      0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL,-      0x8fcaca45UL, 0x1f82829dUL, 0x89c9c940UL, 0xfa7d7d87UL,-      0xeffafa15UL, 0xb25959ebUL, 0x8e4747c9UL, 0xfbf0f00bUL,-      0x41adadecUL, 0xb3d4d467UL, 0x5fa2a2fdUL, 0x45afafeaUL,-      0x239c9cbfUL, 0x53a4a4f7UL, 0xe4727296UL, 0x9bc0c05bUL,-      0x75b7b7c2UL, 0xe1fdfd1cUL, 0x3d9393aeUL, 0x4c26266aUL,-      0x6c36365aUL, 0x7e3f3f41UL, 0xf5f7f702UL, 0x83cccc4fUL,-      0x6834345cUL, 0x51a5a5f4UL, 0xd1e5e534UL, 0xf9f1f108UL,-      0xe2717193UL, 0xabd8d873UL, 0x62313153UL, 0x2a15153fUL,-      0x0804040cUL, 0x95c7c752UL, 0x46232365UL, 0x9dc3c35eUL,-      0x30181828UL, 0x379696a1UL, 0x0a05050fUL, 0x2f9a9ab5UL,-      0x0e070709UL, 0x24121236UL, 0x1b80809bUL, 0xdfe2e23dUL,-      0xcdebeb26UL, 0x4e272769UL, 0x7fb2b2cdUL, 0xea75759fUL,-      0x1209091bUL, 0x1d83839eUL, 0x582c2c74UL, 0x341a1a2eUL,-      0x361b1b2dUL, 0xdc6e6eb2UL, 0xb45a5aeeUL, 0x5ba0a0fbUL,-      0xa45252f6UL, 0x763b3b4dUL, 0xb7d6d661UL, 0x7db3b3ceUL,-      0x5229297bUL, 0xdde3e33eUL, 0x5e2f2f71UL, 0x13848497UL,-      0xa65353f5UL, 0xb9d1d168UL, 0x00000000UL, 0xc1eded2cUL,-      0x40202060UL, 0xe3fcfc1fUL, 0x79b1b1c8UL, 0xb65b5bedUL,-      0xd46a6abeUL, 0x8dcbcb46UL, 0x67bebed9UL, 0x7239394bUL,-      0x944a4adeUL, 0x984c4cd4UL, 0xb05858e8UL, 0x85cfcf4aUL,-      0xbbd0d06bUL, 0xc5efef2aUL, 0x4faaaae5UL, 0xedfbfb16UL,-      0x864343c5UL, 0x9a4d4dd7UL, 0x66333355UL, 0x11858594UL,-      0x8a4545cfUL, 0xe9f9f910UL, 0x04020206UL, 0xfe7f7f81UL,-      0xa05050f0UL, 0x783c3c44UL, 0x259f9fbaUL, 0x4ba8a8e3UL,-      0xa25151f3UL, 0x5da3a3feUL, 0x804040c0UL, 0x058f8f8aUL,-      0x3f9292adUL, 0x219d9dbcUL, 0x70383848UL, 0xf1f5f504UL,-      0x63bcbcdfUL, 0x77b6b6c1UL, 0xafdada75UL, 0x42212163UL,-      0x20101030UL, 0xe5ffff1aUL, 0xfdf3f30eUL, 0xbfd2d26dUL,-      0x81cdcd4cUL, 0x180c0c14UL, 0x26131335UL, 0xc3ecec2fUL,-      0xbe5f5fe1UL, 0x359797a2UL, 0x884444ccUL, 0x2e171739UL,-      0x93c4c457UL, 0x55a7a7f2UL, 0xfc7e7e82UL, 0x7a3d3d47UL,-      0xc86464acUL, 0xba5d5de7UL, 0x3219192bUL, 0xe6737395UL,-      0xc06060a0UL, 0x19818198UL, 0x9e4f4fd1UL, 0xa3dcdc7fUL,-      0x44222266UL, 0x542a2a7eUL, 0x3b9090abUL, 0x0b888883UL,-      0x8c4646caUL, 0xc7eeee29UL, 0x6bb8b8d3UL, 0x2814143cUL,-      0xa7dede79UL, 0xbc5e5ee2UL, 0x160b0b1dUL, 0xaddbdb76UL,-      0xdbe0e03bUL, 0x64323256UL, 0x743a3a4eUL, 0x140a0a1eUL,-      0x924949dbUL, 0x0c06060aUL, 0x4824246cUL, 0xb85c5ce4UL,-      0x9fc2c25dUL, 0xbdd3d36eUL, 0x43acacefUL, 0xc46262a6UL,-      0x399191a8UL, 0x319595a4UL, 0xd3e4e437UL, 0xf279798bUL,-      0xd5e7e732UL, 0x8bc8c843UL, 0x6e373759UL, 0xda6d6db7UL,-      0x018d8d8cUL, 0xb1d5d564UL, 0x9c4e4ed2UL, 0x49a9a9e0UL,-      0xd86c6cb4UL, 0xac5656faUL, 0xf3f4f407UL, 0xcfeaea25UL,-      0xca6565afUL, 0xf47a7a8eUL, 0x47aeaee9UL, 0x10080818UL,-      0x6fbabad5UL, 0xf0787888UL, 0x4a25256fUL, 0x5c2e2e72UL,-      0x381c1c24UL, 0x57a6a6f1UL, 0x73b4b4c7UL, 0x97c6c651UL,-      0xcbe8e823UL, 0xa1dddd7cUL, 0xe874749cUL, 0x3e1f1f21UL,-      0x964b4bddUL, 0x61bdbddcUL, 0x0d8b8b86UL, 0x0f8a8a85UL,-      0xe0707090UL, 0x7c3e3e42UL, 0x71b5b5c4UL, 0xcc6666aaUL,-      0x904848d8UL, 0x06030305UL, 0xf7f6f601UL, 0x1c0e0e12UL,-      0xc26161a3UL, 0x6a35355fUL, 0xae5757f9UL, 0x69b9b9d0UL,-      0x17868691UL, 0x99c1c158UL, 0x3a1d1d27UL, 0x279e9eb9UL,-      0xd9e1e138UL, 0xebf8f813UL, 0x2b9898b3UL, 0x22111133UL,-      0xd26969bbUL, 0xa9d9d970UL, 0x078e8e89UL, 0x339494a7UL,-      0x2d9b9bb6UL, 0x3c1e1e22UL, 0x15878792UL, 0xc9e9e920UL,-      0x87cece49UL, 0xaa5555ffUL, 0x50282878UL, 0xa5dfdf7aUL,-      0x038c8c8fUL, 0x59a1a1f8UL, 0x09898980UL, 0x1a0d0d17UL,-      0x65bfbfdaUL, 0xd7e6e631UL, 0x844242c6UL, 0xd06868b8UL,-      0x824141c3UL, 0x299999b0UL, 0x5a2d2d77UL, 0x1e0f0f11UL,-      0x7bb0b0cbUL, 0xa85454fcUL, 0x6dbbbbd6UL, 0x2c16163aUL-  };-  static const SWord32 table2[] = {-      0xa5c66363UL, 0x84f87c7cUL, 0x99ee7777UL, 0x8df67b7bUL,-      0x0dfff2f2UL, 0xbdd66b6bUL, 0xb1de6f6fUL, 0x5491c5c5UL,-      0x50603030UL, 0x03020101UL, 0xa9ce6767UL, 0x7d562b2bUL,-      0x19e7fefeUL, 0x62b5d7d7UL, 0xe64dababUL, 0x9aec7676UL,-      0x458fcacaUL, 0x9d1f8282UL, 0x4089c9c9UL, 0x87fa7d7dUL,-      0x15effafaUL, 0xebb25959UL, 0xc98e4747UL, 0x0bfbf0f0UL,-      0xec41adadUL, 0x67b3d4d4UL, 0xfd5fa2a2UL, 0xea45afafUL,-      0xbf239c9cUL, 0xf753a4a4UL, 0x96e47272UL, 0x5b9bc0c0UL,-      0xc275b7b7UL, 0x1ce1fdfdUL, 0xae3d9393UL, 0x6a4c2626UL,-      0x5a6c3636UL, 0x417e3f3fUL, 0x02f5f7f7UL, 0x4f83ccccUL,-      0x5c683434UL, 0xf451a5a5UL, 0x34d1e5e5UL, 0x08f9f1f1UL,-      0x93e27171UL, 0x73abd8d8UL, 0x53623131UL, 0x3f2a1515UL,-      0x0c080404UL, 0x5295c7c7UL, 0x65462323UL, 0x5e9dc3c3UL,-      0x28301818UL, 0xa1379696UL, 0x0f0a0505UL, 0xb52f9a9aUL,-      0x090e0707UL, 0x36241212UL, 0x9b1b8080UL, 0x3ddfe2e2UL,-      0x26cdebebUL, 0x694e2727UL, 0xcd7fb2b2UL, 0x9fea7575UL,-      0x1b120909UL, 0x9e1d8383UL, 0x74582c2cUL, 0x2e341a1aUL,-      0x2d361b1bUL, 0xb2dc6e6eUL, 0xeeb45a5aUL, 0xfb5ba0a0UL,-      0xf6a45252UL, 0x4d763b3bUL, 0x61b7d6d6UL, 0xce7db3b3UL,-      0x7b522929UL, 0x3edde3e3UL, 0x715e2f2fUL, 0x97138484UL,-      0xf5a65353UL, 0x68b9d1d1UL, 0x00000000UL, 0x2cc1ededUL,-      0x60402020UL, 0x1fe3fcfcUL, 0xc879b1b1UL, 0xedb65b5bUL,-      0xbed46a6aUL, 0x468dcbcbUL, 0xd967bebeUL, 0x4b723939UL,-      0xde944a4aUL, 0xd4984c4cUL, 0xe8b05858UL, 0x4a85cfcfUL,-      0x6bbbd0d0UL, 0x2ac5efefUL, 0xe54faaaaUL, 0x16edfbfbUL,-      0xc5864343UL, 0xd79a4d4dUL, 0x55663333UL, 0x94118585UL,-      0xcf8a4545UL, 0x10e9f9f9UL, 0x06040202UL, 0x81fe7f7fUL,-      0xf0a05050UL, 0x44783c3cUL, 0xba259f9fUL, 0xe34ba8a8UL,-      0xf3a25151UL, 0xfe5da3a3UL, 0xc0804040UL, 0x8a058f8fUL,-      0xad3f9292UL, 0xbc219d9dUL, 0x48703838UL, 0x04f1f5f5UL,-      0xdf63bcbcUL, 0xc177b6b6UL, 0x75afdadaUL, 0x63422121UL,-      0x30201010UL, 0x1ae5ffffUL, 0x0efdf3f3UL, 0x6dbfd2d2UL,-      0x4c81cdcdUL, 0x14180c0cUL, 0x35261313UL, 0x2fc3ececUL,-      0xe1be5f5fUL, 0xa2359797UL, 0xcc884444UL, 0x392e1717UL,-      0x5793c4c4UL, 0xf255a7a7UL, 0x82fc7e7eUL, 0x477a3d3dUL,-      0xacc86464UL, 0xe7ba5d5dUL, 0x2b321919UL, 0x95e67373UL,-      0xa0c06060UL, 0x98198181UL, 0xd19e4f4fUL, 0x7fa3dcdcUL,-      0x66442222UL, 0x7e542a2aUL, 0xab3b9090UL, 0x830b8888UL,-      0xca8c4646UL, 0x29c7eeeeUL, 0xd36bb8b8UL, 0x3c281414UL,-      0x79a7dedeUL, 0xe2bc5e5eUL, 0x1d160b0bUL, 0x76addbdbUL,-      0x3bdbe0e0UL, 0x56643232UL, 0x4e743a3aUL, 0x1e140a0aUL,-      0xdb924949UL, 0x0a0c0606UL, 0x6c482424UL, 0xe4b85c5cUL,-      0x5d9fc2c2UL, 0x6ebdd3d3UL, 0xef43acacUL, 0xa6c46262UL,-      0xa8399191UL, 0xa4319595UL, 0x37d3e4e4UL, 0x8bf27979UL,-      0x32d5e7e7UL, 0x438bc8c8UL, 0x596e3737UL, 0xb7da6d6dUL,-      0x8c018d8dUL, 0x64b1d5d5UL, 0xd29c4e4eUL, 0xe049a9a9UL,-      0xb4d86c6cUL, 0xfaac5656UL, 0x07f3f4f4UL, 0x25cfeaeaUL,-      0xafca6565UL, 0x8ef47a7aUL, 0xe947aeaeUL, 0x18100808UL,-      0xd56fbabaUL, 0x88f07878UL, 0x6f4a2525UL, 0x725c2e2eUL,-      0x24381c1cUL, 0xf157a6a6UL, 0xc773b4b4UL, 0x5197c6c6UL,-      0x23cbe8e8UL, 0x7ca1ddddUL, 0x9ce87474UL, 0x213e1f1fUL,-      0xdd964b4bUL, 0xdc61bdbdUL, 0x860d8b8bUL, 0x850f8a8aUL,-      0x90e07070UL, 0x427c3e3eUL, 0xc471b5b5UL, 0xaacc6666UL,-      0xd8904848UL, 0x05060303UL, 0x01f7f6f6UL, 0x121c0e0eUL,-      0xa3c26161UL, 0x5f6a3535UL, 0xf9ae5757UL, 0xd069b9b9UL,-      0x91178686UL, 0x5899c1c1UL, 0x273a1d1dUL, 0xb9279e9eUL,-      0x38d9e1e1UL, 0x13ebf8f8UL, 0xb32b9898UL, 0x33221111UL,-      0xbbd26969UL, 0x70a9d9d9UL, 0x89078e8eUL, 0xa7339494UL,-      0xb62d9b9bUL, 0x223c1e1eUL, 0x92158787UL, 0x20c9e9e9UL,-      0x4987ceceUL, 0xffaa5555UL, 0x78502828UL, 0x7aa5dfdfUL,-      0x8f038c8cUL, 0xf859a1a1UL, 0x80098989UL, 0x171a0d0dUL,-      0xda65bfbfUL, 0x31d7e6e6UL, 0xc6844242UL, 0xb8d06868UL,-      0xc3824141UL, 0xb0299999UL, 0x775a2d2dUL, 0x111e0f0fUL,-      0xcb7bb0b0UL, 0xfca85454UL, 0xd66dbbbbUL, 0x3a2c1616UL-  };-  static const SWord32 table3[] = {-      0x63a5c663UL, 0x7c84f87cUL, 0x7799ee77UL, 0x7b8df67bUL,-      0xf20dfff2UL, 0x6bbdd66bUL, 0x6fb1de6fUL, 0xc55491c5UL,-      0x30506030UL, 0x01030201UL, 0x67a9ce67UL, 0x2b7d562bUL,-      0xfe19e7feUL, 0xd762b5d7UL, 0xabe64dabUL, 0x769aec76UL,-      0xca458fcaUL, 0x829d1f82UL, 0xc94089c9UL, 0x7d87fa7dUL,-      0xfa15effaUL, 0x59ebb259UL, 0x47c98e47UL, 0xf00bfbf0UL,-      0xadec41adUL, 0xd467b3d4UL, 0xa2fd5fa2UL, 0xafea45afUL,-      0x9cbf239cUL, 0xa4f753a4UL, 0x7296e472UL, 0xc05b9bc0UL,-      0xb7c275b7UL, 0xfd1ce1fdUL, 0x93ae3d93UL, 0x266a4c26UL,-      0x365a6c36UL, 0x3f417e3fUL, 0xf702f5f7UL, 0xcc4f83ccUL,-      0x345c6834UL, 0xa5f451a5UL, 0xe534d1e5UL, 0xf108f9f1UL,-      0x7193e271UL, 0xd873abd8UL, 0x31536231UL, 0x153f2a15UL,-      0x040c0804UL, 0xc75295c7UL, 0x23654623UL, 0xc35e9dc3UL,-      0x18283018UL, 0x96a13796UL, 0x050f0a05UL, 0x9ab52f9aUL,-      0x07090e07UL, 0x12362412UL, 0x809b1b80UL, 0xe23ddfe2UL,-      0xeb26cdebUL, 0x27694e27UL, 0xb2cd7fb2UL, 0x759fea75UL,-      0x091b1209UL, 0x839e1d83UL, 0x2c74582cUL, 0x1a2e341aUL,-      0x1b2d361bUL, 0x6eb2dc6eUL, 0x5aeeb45aUL, 0xa0fb5ba0UL,-      0x52f6a452UL, 0x3b4d763bUL, 0xd661b7d6UL, 0xb3ce7db3UL,-      0x297b5229UL, 0xe33edde3UL, 0x2f715e2fUL, 0x84971384UL,-      0x53f5a653UL, 0xd168b9d1UL, 0x00000000UL, 0xed2cc1edUL,-      0x20604020UL, 0xfc1fe3fcUL, 0xb1c879b1UL, 0x5bedb65bUL,-      0x6abed46aUL, 0xcb468dcbUL, 0xbed967beUL, 0x394b7239UL,-      0x4ade944aUL, 0x4cd4984cUL, 0x58e8b058UL, 0xcf4a85cfUL,-      0xd06bbbd0UL, 0xef2ac5efUL, 0xaae54faaUL, 0xfb16edfbUL,-      0x43c58643UL, 0x4dd79a4dUL, 0x33556633UL, 0x85941185UL,-      0x45cf8a45UL, 0xf910e9f9UL, 0x02060402UL, 0x7f81fe7fUL,-      0x50f0a050UL, 0x3c44783cUL, 0x9fba259fUL, 0xa8e34ba8UL,-      0x51f3a251UL, 0xa3fe5da3UL, 0x40c08040UL, 0x8f8a058fUL,-      0x92ad3f92UL, 0x9dbc219dUL, 0x38487038UL, 0xf504f1f5UL,-      0xbcdf63bcUL, 0xb6c177b6UL, 0xda75afdaUL, 0x21634221UL,-      0x10302010UL, 0xff1ae5ffUL, 0xf30efdf3UL, 0xd26dbfd2UL,-      0xcd4c81cdUL, 0x0c14180cUL, 0x13352613UL, 0xec2fc3ecUL,-      0x5fe1be5fUL, 0x97a23597UL, 0x44cc8844UL, 0x17392e17UL,-      0xc45793c4UL, 0xa7f255a7UL, 0x7e82fc7eUL, 0x3d477a3dUL,-      0x64acc864UL, 0x5de7ba5dUL, 0x192b3219UL, 0x7395e673UL,-      0x60a0c060UL, 0x81981981UL, 0x4fd19e4fUL, 0xdc7fa3dcUL,-      0x22664422UL, 0x2a7e542aUL, 0x90ab3b90UL, 0x88830b88UL,-      0x46ca8c46UL, 0xee29c7eeUL, 0xb8d36bb8UL, 0x143c2814UL,-      0xde79a7deUL, 0x5ee2bc5eUL, 0x0b1d160bUL, 0xdb76addbUL,-      0xe03bdbe0UL, 0x32566432UL, 0x3a4e743aUL, 0x0a1e140aUL,-      0x49db9249UL, 0x060a0c06UL, 0x246c4824UL, 0x5ce4b85cUL,-      0xc25d9fc2UL, 0xd36ebdd3UL, 0xacef43acUL, 0x62a6c462UL,-      0x91a83991UL, 0x95a43195UL, 0xe437d3e4UL, 0x798bf279UL,-      0xe732d5e7UL, 0xc8438bc8UL, 0x37596e37UL, 0x6db7da6dUL,-      0x8d8c018dUL, 0xd564b1d5UL, 0x4ed29c4eUL, 0xa9e049a9UL,-      0x6cb4d86cUL, 0x56faac56UL, 0xf407f3f4UL, 0xea25cfeaUL,-      0x65afca65UL, 0x7a8ef47aUL, 0xaee947aeUL, 0x08181008UL,-      0xbad56fbaUL, 0x7888f078UL, 0x256f4a25UL, 0x2e725c2eUL,-      0x1c24381cUL, 0xa6f157a6UL, 0xb4c773b4UL, 0xc65197c6UL,-      0xe823cbe8UL, 0xdd7ca1ddUL, 0x749ce874UL, 0x1f213e1fUL,-      0x4bdd964bUL, 0xbddc61bdUL, 0x8b860d8bUL, 0x8a850f8aUL,-      0x7090e070UL, 0x3e427c3eUL, 0xb5c471b5UL, 0x66aacc66UL,-      0x48d89048UL, 0x03050603UL, 0xf601f7f6UL, 0x0e121c0eUL,-      0x61a3c261UL, 0x355f6a35UL, 0x57f9ae57UL, 0xb9d069b9UL,-      0x86911786UL, 0xc15899c1UL, 0x1d273a1dUL, 0x9eb9279eUL,-      0xe138d9e1UL, 0xf813ebf8UL, 0x98b32b98UL, 0x11332211UL,-      0x69bbd269UL, 0xd970a9d9UL, 0x8e89078eUL, 0x94a73394UL,-      0x9bb62d9bUL, 0x1e223c1eUL, 0x87921587UL, 0xe920c9e9UL,-      0xce4987ceUL, 0x55ffaa55UL, 0x28785028UL, 0xdf7aa5dfUL,-      0x8c8f038cUL, 0xa1f859a1UL, 0x89800989UL, 0x0d171a0dUL,-      0xbfda65bfUL, 0xe631d7e6UL, 0x42c68442UL, 0x68b8d068UL,-      0x41c38241UL, 0x99b02999UL, 0x2d775a2dUL, 0x0f111e0fUL,-      0xb0cb7bb0UL, 0x54fca854UL, 0xbbd66dbbUL, 0x163a2c16UL-  };-  static const SWord32 table4[] = {-      0x6363a5c6UL, 0x7c7c84f8UL, 0x777799eeUL, 0x7b7b8df6UL,-      0xf2f20dffUL, 0x6b6bbdd6UL, 0x6f6fb1deUL, 0xc5c55491UL,-      0x30305060UL, 0x01010302UL, 0x6767a9ceUL, 0x2b2b7d56UL,-      0xfefe19e7UL, 0xd7d762b5UL, 0xababe64dUL, 0x76769aecUL,-      0xcaca458fUL, 0x82829d1fUL, 0xc9c94089UL, 0x7d7d87faUL,-      0xfafa15efUL, 0x5959ebb2UL, 0x4747c98eUL, 0xf0f00bfbUL,-      0xadadec41UL, 0xd4d467b3UL, 0xa2a2fd5fUL, 0xafafea45UL,-      0x9c9cbf23UL, 0xa4a4f753UL, 0x727296e4UL, 0xc0c05b9bUL,-      0xb7b7c275UL, 0xfdfd1ce1UL, 0x9393ae3dUL, 0x26266a4cUL,-      0x36365a6cUL, 0x3f3f417eUL, 0xf7f702f5UL, 0xcccc4f83UL,-      0x34345c68UL, 0xa5a5f451UL, 0xe5e534d1UL, 0xf1f108f9UL,-      0x717193e2UL, 0xd8d873abUL, 0x31315362UL, 0x15153f2aUL,-      0x04040c08UL, 0xc7c75295UL, 0x23236546UL, 0xc3c35e9dUL,-      0x18182830UL, 0x9696a137UL, 0x05050f0aUL, 0x9a9ab52fUL,-      0x0707090eUL, 0x12123624UL, 0x80809b1bUL, 0xe2e23ddfUL,-      0xebeb26cdUL, 0x2727694eUL, 0xb2b2cd7fUL, 0x75759feaUL,-      0x09091b12UL, 0x83839e1dUL, 0x2c2c7458UL, 0x1a1a2e34UL,-      0x1b1b2d36UL, 0x6e6eb2dcUL, 0x5a5aeeb4UL, 0xa0a0fb5bUL,-      0x5252f6a4UL, 0x3b3b4d76UL, 0xd6d661b7UL, 0xb3b3ce7dUL,-      0x29297b52UL, 0xe3e33eddUL, 0x2f2f715eUL, 0x84849713UL,-      0x5353f5a6UL, 0xd1d168b9UL, 0x00000000UL, 0xeded2cc1UL,-      0x20206040UL, 0xfcfc1fe3UL, 0xb1b1c879UL, 0x5b5bedb6UL,-      0x6a6abed4UL, 0xcbcb468dUL, 0xbebed967UL, 0x39394b72UL,-      0x4a4ade94UL, 0x4c4cd498UL, 0x5858e8b0UL, 0xcfcf4a85UL,-      0xd0d06bbbUL, 0xefef2ac5UL, 0xaaaae54fUL, 0xfbfb16edUL,-      0x4343c586UL, 0x4d4dd79aUL, 0x33335566UL, 0x85859411UL,-      0x4545cf8aUL, 0xf9f910e9UL, 0x02020604UL, 0x7f7f81feUL,-      0x5050f0a0UL, 0x3c3c4478UL, 0x9f9fba25UL, 0xa8a8e34bUL,-      0x5151f3a2UL, 0xa3a3fe5dUL, 0x4040c080UL, 0x8f8f8a05UL,-      0x9292ad3fUL, 0x9d9dbc21UL, 0x38384870UL, 0xf5f504f1UL,-      0xbcbcdf63UL, 0xb6b6c177UL, 0xdada75afUL, 0x21216342UL,-      0x10103020UL, 0xffff1ae5UL, 0xf3f30efdUL, 0xd2d26dbfUL,-      0xcdcd4c81UL, 0x0c0c1418UL, 0x13133526UL, 0xecec2fc3UL,-      0x5f5fe1beUL, 0x9797a235UL, 0x4444cc88UL, 0x1717392eUL,-      0xc4c45793UL, 0xa7a7f255UL, 0x7e7e82fcUL, 0x3d3d477aUL,-      0x6464acc8UL, 0x5d5de7baUL, 0x19192b32UL, 0x737395e6UL,-      0x6060a0c0UL, 0x81819819UL, 0x4f4fd19eUL, 0xdcdc7fa3UL,-      0x22226644UL, 0x2a2a7e54UL, 0x9090ab3bUL, 0x8888830bUL,-      0x4646ca8cUL, 0xeeee29c7UL, 0xb8b8d36bUL, 0x14143c28UL,-      0xdede79a7UL, 0x5e5ee2bcUL, 0x0b0b1d16UL, 0xdbdb76adUL,-      0xe0e03bdbUL, 0x32325664UL, 0x3a3a4e74UL, 0x0a0a1e14UL,-      0x4949db92UL, 0x06060a0cUL, 0x24246c48UL, 0x5c5ce4b8UL,-      0xc2c25d9fUL, 0xd3d36ebdUL, 0xacacef43UL, 0x6262a6c4UL,-      0x9191a839UL, 0x9595a431UL, 0xe4e437d3UL, 0x79798bf2UL,-      0xe7e732d5UL, 0xc8c8438bUL, 0x3737596eUL, 0x6d6db7daUL,-      0x8d8d8c01UL, 0xd5d564b1UL, 0x4e4ed29cUL, 0xa9a9e049UL,-      0x6c6cb4d8UL, 0x5656faacUL, 0xf4f407f3UL, 0xeaea25cfUL,-      0x6565afcaUL, 0x7a7a8ef4UL, 0xaeaee947UL, 0x08081810UL,-      0xbabad56fUL, 0x787888f0UL, 0x25256f4aUL, 0x2e2e725cUL,-      0x1c1c2438UL, 0xa6a6f157UL, 0xb4b4c773UL, 0xc6c65197UL,-      0xe8e823cbUL, 0xdddd7ca1UL, 0x74749ce8UL, 0x1f1f213eUL,-      0x4b4bdd96UL, 0xbdbddc61UL, 0x8b8b860dUL, 0x8a8a850fUL,-      0x707090e0UL, 0x3e3e427cUL, 0xb5b5c471UL, 0x6666aaccUL,-      0x4848d890UL, 0x03030506UL, 0xf6f601f7UL, 0x0e0e121cUL,-      0x6161a3c2UL, 0x35355f6aUL, 0x5757f9aeUL, 0xb9b9d069UL,-      0x86869117UL, 0xc1c15899UL, 0x1d1d273aUL, 0x9e9eb927UL,-      0xe1e138d9UL, 0xf8f813ebUL, 0x9898b32bUL, 0x11113322UL,-      0x6969bbd2UL, 0xd9d970a9UL, 0x8e8e8907UL, 0x9494a733UL,-      0x9b9bb62dUL, 0x1e1e223cUL, 0x87879215UL, 0xe9e920c9UL,-      0xcece4987UL, 0x5555ffaaUL, 0x28287850UL, 0xdfdf7aa5UL,-      0x8c8c8f03UL, 0xa1a1f859UL, 0x89898009UL, 0x0d0d171aUL,-      0xbfbfda65UL, 0xe6e631d7UL, 0x4242c684UL, 0x6868b8d0UL,-      0x4141c382UL, 0x9999b029UL, 0x2d2d775aUL, 0x0f0f111eUL,-      0xb0b0cb7bUL, 0x5454fca8UL, 0xbbbbd66dUL, 0x16163a2cUL-  };-  const SWord32 s560 = s0 ^ s4;-  const SWord16 s561 = (SWord16) (s560 >> 16);-  const SWord8  s562 = (SWord8) (s561 >> 8);-  const SWord32 s563 = table1[s562];-  const SWord32 s819 = s1 ^ s5;-  const SWord16 s820 = (SWord16) (s819 >> 16);-  const SWord8  s821 = (SWord8) s820;-  const SWord32 s822 = table2[s821];-  const SWord32 s823 = s563 ^ s822;-  const SWord32 s1079 = s2 ^ s6;-  const SWord16 s1080 = (SWord16) s1079;-  const SWord8  s1081 = (SWord8) (s1080 >> 8);-  const SWord32 s1082 = table3[s1081];-  const SWord32 s1083 = s823 ^ s1082;-  const SWord32 s1339 = s3 ^ s7;-  const SWord16 s1340 = (SWord16) s1339;-  const SWord8  s1341 = (SWord8) s1340;-  const SWord32 s1342 = table4[s1341];-  const SWord32 s1343 = s1083 ^ s1342;-  const SWord32 s1344 = s8 ^ s1343;-  const SWord16 s1345 = (SWord16) (s1344 >> 16);-  const SWord8  s1346 = (SWord8) (s1345 >> 8);-  const SWord32 s1347 = table1[s1346];-  const SWord8  s1348 = (SWord8) (s820 >> 8);-  const SWord32 s1349 = table1[s1348];-  const SWord16 s1350 = (SWord16) (s1079 >> 16);-  const SWord8  s1351 = (SWord8) s1350;-  const SWord32 s1352 = table2[s1351];-  const SWord32 s1353 = s1349 ^ s1352;-  const SWord8  s1354 = (SWord8) (s1340 >> 8);-  const SWord32 s1355 = table3[s1354];-  const SWord32 s1356 = s1353 ^ s1355;-  const SWord16 s1357 = (SWord16) s560;-  const SWord8  s1358 = (SWord8) s1357;-  const SWord32 s1359 = table4[s1358];-  const SWord32 s1360 = s1356 ^ s1359;-  const SWord32 s1361 = s9 ^ s1360;-  const SWord16 s1362 = (SWord16) (s1361 >> 16);-  const SWord8  s1363 = (SWord8) s1362;-  const SWord32 s1364 = table2[s1363];-  const SWord32 s1365 = s1347 ^ s1364;-  const SWord8  s1366 = (SWord8) (s1350 >> 8);-  const SWord32 s1367 = table1[s1366];-  const SWord16 s1368 = (SWord16) (s1339 >> 16);-  const SWord8  s1369 = (SWord8) s1368;-  const SWord32 s1370 = table2[s1369];-  const SWord32 s1371 = s1367 ^ s1370;-  const SWord8  s1372 = (SWord8) (s1357 >> 8);-  const SWord32 s1373 = table3[s1372];-  const SWord32 s1374 = s1371 ^ s1373;-  const SWord16 s1375 = (SWord16) s819;-  const SWord8  s1376 = (SWord8) s1375;-  const SWord32 s1377 = table4[s1376];-  const SWord32 s1378 = s1374 ^ s1377;-  const SWord32 s1379 = s10 ^ s1378;-  const SWord16 s1380 = (SWord16) s1379;-  const SWord8  s1381 = (SWord8) (s1380 >> 8);-  const SWord32 s1382 = table3[s1381];-  const SWord32 s1383 = s1365 ^ s1382;-  const SWord8  s1384 = (SWord8) (s1368 >> 8);-  const SWord32 s1385 = table1[s1384];-  const SWord8  s1386 = (SWord8) s561;-  const SWord32 s1387 = table2[s1386];-  const SWord32 s1388 = s1385 ^ s1387;-  const SWord8  s1389 = (SWord8) (s1375 >> 8);-  const SWord32 s1390 = table3[s1389];-  const SWord32 s1391 = s1388 ^ s1390;-  const SWord8  s1392 = (SWord8) s1080;-  const SWord32 s1393 = table4[s1392];-  const SWord32 s1394 = s1391 ^ s1393;-  const SWord32 s1395 = s11 ^ s1394;-  const SWord16 s1396 = (SWord16) s1395;-  const SWord8  s1397 = (SWord8) s1396;-  const SWord32 s1398 = table4[s1397];-  const SWord32 s1399 = s1383 ^ s1398;-  const SWord32 s1400 = s12 ^ s1399;-  const SWord16 s1401 = (SWord16) (s1400 >> 16);-  const SWord8  s1402 = (SWord8) (s1401 >> 8);-  const SWord32 s1403 = table1[s1402];-  const SWord8  s1404 = (SWord8) (s1362 >> 8);-  const SWord32 s1405 = table1[s1404];-  const SWord16 s1406 = (SWord16) (s1379 >> 16);-  const SWord8  s1407 = (SWord8) s1406;-  const SWord32 s1408 = table2[s1407];-  const SWord32 s1409 = s1405 ^ s1408;-  const SWord8  s1410 = (SWord8) (s1396 >> 8);-  const SWord32 s1411 = table3[s1410];-  const SWord32 s1412 = s1409 ^ s1411;-  const SWord16 s1413 = (SWord16) s1344;-  const SWord8  s1414 = (SWord8) s1413;-  const SWord32 s1415 = table4[s1414];-  const SWord32 s1416 = s1412 ^ s1415;-  const SWord32 s1417 = s13 ^ s1416;-  const SWord16 s1418 = (SWord16) (s1417 >> 16);-  const SWord8  s1419 = (SWord8) s1418;-  const SWord32 s1420 = table2[s1419];-  const SWord32 s1421 = s1403 ^ s1420;-  const SWord8  s1422 = (SWord8) (s1406 >> 8);-  const SWord32 s1423 = table1[s1422];-  const SWord16 s1424 = (SWord16) (s1395 >> 16);-  const SWord8  s1425 = (SWord8) s1424;-  const SWord32 s1426 = table2[s1425];-  const SWord32 s1427 = s1423 ^ s1426;-  const SWord8  s1428 = (SWord8) (s1413 >> 8);-  const SWord32 s1429 = table3[s1428];-  const SWord32 s1430 = s1427 ^ s1429;-  const SWord16 s1431 = (SWord16) s1361;-  const SWord8  s1432 = (SWord8) s1431;-  const SWord32 s1433 = table4[s1432];-  const SWord32 s1434 = s1430 ^ s1433;-  const SWord32 s1435 = s14 ^ s1434;-  const SWord16 s1436 = (SWord16) s1435;-  const SWord8  s1437 = (SWord8) (s1436 >> 8);-  const SWord32 s1438 = table3[s1437];-  const SWord32 s1439 = s1421 ^ s1438;-  const SWord8  s1440 = (SWord8) (s1424 >> 8);-  const SWord32 s1441 = table1[s1440];-  const SWord8  s1442 = (SWord8) s1345;-  const SWord32 s1443 = table2[s1442];-  const SWord32 s1444 = s1441 ^ s1443;-  const SWord8  s1445 = (SWord8) (s1431 >> 8);-  const SWord32 s1446 = table3[s1445];-  const SWord32 s1447 = s1444 ^ s1446;-  const SWord8  s1448 = (SWord8) s1380;-  const SWord32 s1449 = table4[s1448];-  const SWord32 s1450 = s1447 ^ s1449;-  const SWord32 s1451 = s15 ^ s1450;-  const SWord16 s1452 = (SWord16) s1451;-  const SWord8  s1453 = (SWord8) s1452;-  const SWord32 s1454 = table4[s1453];-  const SWord32 s1455 = s1439 ^ s1454;-  const SWord32 s1456 = s16 ^ s1455;-  const SWord16 s1457 = (SWord16) (s1456 >> 16);-  const SWord8  s1458 = (SWord8) (s1457 >> 8);-  const SWord32 s1459 = table1[s1458];-  const SWord8  s1460 = (SWord8) (s1418 >> 8);-  const SWord32 s1461 = table1[s1460];-  const SWord16 s1462 = (SWord16) (s1435 >> 16);-  const SWord8  s1463 = (SWord8) s1462;-  const SWord32 s1464 = table2[s1463];-  const SWord32 s1465 = s1461 ^ s1464;-  const SWord8  s1466 = (SWord8) (s1452 >> 8);-  const SWord32 s1467 = table3[s1466];-  const SWord32 s1468 = s1465 ^ s1467;-  const SWord16 s1469 = (SWord16) s1400;-  const SWord8  s1470 = (SWord8) s1469;-  const SWord32 s1471 = table4[s1470];-  const SWord32 s1472 = s1468 ^ s1471;-  const SWord32 s1473 = s17 ^ s1472;-  const SWord16 s1474 = (SWord16) (s1473 >> 16);-  const SWord8  s1475 = (SWord8) s1474;-  const SWord32 s1476 = table2[s1475];-  const SWord32 s1477 = s1459 ^ s1476;-  const SWord8  s1478 = (SWord8) (s1462 >> 8);-  const SWord32 s1479 = table1[s1478];-  const SWord16 s1480 = (SWord16) (s1451 >> 16);-  const SWord8  s1481 = (SWord8) s1480;-  const SWord32 s1482 = table2[s1481];-  const SWord32 s1483 = s1479 ^ s1482;-  const SWord8  s1484 = (SWord8) (s1469 >> 8);-  const SWord32 s1485 = table3[s1484];-  const SWord32 s1486 = s1483 ^ s1485;-  const SWord16 s1487 = (SWord16) s1417;-  const SWord8  s1488 = (SWord8) s1487;-  const SWord32 s1489 = table4[s1488];-  const SWord32 s1490 = s1486 ^ s1489;-  const SWord32 s1491 = s18 ^ s1490;-  const SWord16 s1492 = (SWord16) s1491;-  const SWord8  s1493 = (SWord8) (s1492 >> 8);-  const SWord32 s1494 = table3[s1493];-  const SWord32 s1495 = s1477 ^ s1494;-  const SWord8  s1496 = (SWord8) (s1480 >> 8);-  const SWord32 s1497 = table1[s1496];-  const SWord8  s1498 = (SWord8) s1401;-  const SWord32 s1499 = table2[s1498];-  const SWord32 s1500 = s1497 ^ s1499;-  const SWord8  s1501 = (SWord8) (s1487 >> 8);-  const SWord32 s1502 = table3[s1501];-  const SWord32 s1503 = s1500 ^ s1502;-  const SWord8  s1504 = (SWord8) s1436;-  const SWord32 s1505 = table4[s1504];-  const SWord32 s1506 = s1503 ^ s1505;-  const SWord32 s1507 = s19 ^ s1506;-  const SWord16 s1508 = (SWord16) s1507;-  const SWord8  s1509 = (SWord8) s1508;-  const SWord32 s1510 = table4[s1509];-  const SWord32 s1511 = s1495 ^ s1510;-  const SWord32 s1512 = s20 ^ s1511;-  const SWord16 s1513 = (SWord16) (s1512 >> 16);-  const SWord8  s1514 = (SWord8) (s1513 >> 8);-  const SWord32 s1515 = table1[s1514];-  const SWord8  s1516 = (SWord8) (s1474 >> 8);-  const SWord32 s1517 = table1[s1516];-  const SWord16 s1518 = (SWord16) (s1491 >> 16);-  const SWord8  s1519 = (SWord8) s1518;-  const SWord32 s1520 = table2[s1519];-  const SWord32 s1521 = s1517 ^ s1520;-  const SWord8  s1522 = (SWord8) (s1508 >> 8);-  const SWord32 s1523 = table3[s1522];-  const SWord32 s1524 = s1521 ^ s1523;-  const SWord16 s1525 = (SWord16) s1456;-  const SWord8  s1526 = (SWord8) s1525;-  const SWord32 s1527 = table4[s1526];-  const SWord32 s1528 = s1524 ^ s1527;-  const SWord32 s1529 = s21 ^ s1528;-  const SWord16 s1530 = (SWord16) (s1529 >> 16);-  const SWord8  s1531 = (SWord8) s1530;-  const SWord32 s1532 = table2[s1531];-  const SWord32 s1533 = s1515 ^ s1532;-  const SWord8  s1534 = (SWord8) (s1518 >> 8);-  const SWord32 s1535 = table1[s1534];-  const SWord16 s1536 = (SWord16) (s1507 >> 16);-  const SWord8  s1537 = (SWord8) s1536;-  const SWord32 s1538 = table2[s1537];-  const SWord32 s1539 = s1535 ^ s1538;-  const SWord8  s1540 = (SWord8) (s1525 >> 8);-  const SWord32 s1541 = table3[s1540];-  const SWord32 s1542 = s1539 ^ s1541;-  const SWord16 s1543 = (SWord16) s1473;-  const SWord8  s1544 = (SWord8) s1543;-  const SWord32 s1545 = table4[s1544];-  const SWord32 s1546 = s1542 ^ s1545;-  const SWord32 s1547 = s22 ^ s1546;-  const SWord16 s1548 = (SWord16) s1547;-  const SWord8  s1549 = (SWord8) (s1548 >> 8);-  const SWord32 s1550 = table3[s1549];-  const SWord32 s1551 = s1533 ^ s1550;-  const SWord8  s1552 = (SWord8) (s1536 >> 8);-  const SWord32 s1553 = table1[s1552];-  const SWord8  s1554 = (SWord8) s1457;-  const SWord32 s1555 = table2[s1554];-  const SWord32 s1556 = s1553 ^ s1555;-  const SWord8  s1557 = (SWord8) (s1543 >> 8);-  const SWord32 s1558 = table3[s1557];-  const SWord32 s1559 = s1556 ^ s1558;-  const SWord8  s1560 = (SWord8) s1492;-  const SWord32 s1561 = table4[s1560];-  const SWord32 s1562 = s1559 ^ s1561;-  const SWord32 s1563 = s23 ^ s1562;-  const SWord16 s1564 = (SWord16) s1563;-  const SWord8  s1565 = (SWord8) s1564;-  const SWord32 s1566 = table4[s1565];-  const SWord32 s1567 = s1551 ^ s1566;-  const SWord32 s1568 = s24 ^ s1567;-  const SWord16 s1569 = (SWord16) (s1568 >> 16);-  const SWord8  s1570 = (SWord8) (s1569 >> 8);-  const SWord32 s1571 = table1[s1570];-  const SWord8  s1572 = (SWord8) (s1530 >> 8);-  const SWord32 s1573 = table1[s1572];-  const SWord16 s1574 = (SWord16) (s1547 >> 16);-  const SWord8  s1575 = (SWord8) s1574;-  const SWord32 s1576 = table2[s1575];-  const SWord32 s1577 = s1573 ^ s1576;-  const SWord8  s1578 = (SWord8) (s1564 >> 8);-  const SWord32 s1579 = table3[s1578];-  const SWord32 s1580 = s1577 ^ s1579;-  const SWord16 s1581 = (SWord16) s1512;-  const SWord8  s1582 = (SWord8) s1581;-  const SWord32 s1583 = table4[s1582];-  const SWord32 s1584 = s1580 ^ s1583;-  const SWord32 s1585 = s25 ^ s1584;-  const SWord16 s1586 = (SWord16) (s1585 >> 16);-  const SWord8  s1587 = (SWord8) s1586;-  const SWord32 s1588 = table2[s1587];-  const SWord32 s1589 = s1571 ^ s1588;-  const SWord8  s1590 = (SWord8) (s1574 >> 8);-  const SWord32 s1591 = table1[s1590];-  const SWord16 s1592 = (SWord16) (s1563 >> 16);-  const SWord8  s1593 = (SWord8) s1592;-  const SWord32 s1594 = table2[s1593];-  const SWord32 s1595 = s1591 ^ s1594;-  const SWord8  s1596 = (SWord8) (s1581 >> 8);-  const SWord32 s1597 = table3[s1596];-  const SWord32 s1598 = s1595 ^ s1597;-  const SWord16 s1599 = (SWord16) s1529;-  const SWord8  s1600 = (SWord8) s1599;-  const SWord32 s1601 = table4[s1600];-  const SWord32 s1602 = s1598 ^ s1601;-  const SWord32 s1603 = s26 ^ s1602;-  const SWord16 s1604 = (SWord16) s1603;-  const SWord8  s1605 = (SWord8) (s1604 >> 8);-  const SWord32 s1606 = table3[s1605];-  const SWord32 s1607 = s1589 ^ s1606;-  const SWord8  s1608 = (SWord8) (s1592 >> 8);-  const SWord32 s1609 = table1[s1608];-  const SWord8  s1610 = (SWord8) s1513;-  const SWord32 s1611 = table2[s1610];-  const SWord32 s1612 = s1609 ^ s1611;-  const SWord8  s1613 = (SWord8) (s1599 >> 8);-  const SWord32 s1614 = table3[s1613];-  const SWord32 s1615 = s1612 ^ s1614;-  const SWord8  s1616 = (SWord8) s1548;-  const SWord32 s1617 = table4[s1616];-  const SWord32 s1618 = s1615 ^ s1617;-  const SWord32 s1619 = s27 ^ s1618;-  const SWord16 s1620 = (SWord16) s1619;-  const SWord8  s1621 = (SWord8) s1620;-  const SWord32 s1622 = table4[s1621];-  const SWord32 s1623 = s1607 ^ s1622;-  const SWord32 s1624 = s28 ^ s1623;-  const SWord16 s1625 = (SWord16) (s1624 >> 16);-  const SWord8  s1626 = (SWord8) (s1625 >> 8);-  const SWord32 s1627 = table1[s1626];-  const SWord8  s1628 = (SWord8) (s1586 >> 8);-  const SWord32 s1629 = table1[s1628];-  const SWord16 s1630 = (SWord16) (s1603 >> 16);-  const SWord8  s1631 = (SWord8) s1630;-  const SWord32 s1632 = table2[s1631];-  const SWord32 s1633 = s1629 ^ s1632;-  const SWord8  s1634 = (SWord8) (s1620 >> 8);-  const SWord32 s1635 = table3[s1634];-  const SWord32 s1636 = s1633 ^ s1635;-  const SWord16 s1637 = (SWord16) s1568;-  const SWord8  s1638 = (SWord8) s1637;-  const SWord32 s1639 = table4[s1638];-  const SWord32 s1640 = s1636 ^ s1639;-  const SWord32 s1641 = s29 ^ s1640;-  const SWord16 s1642 = (SWord16) (s1641 >> 16);-  const SWord8  s1643 = (SWord8) s1642;-  const SWord32 s1644 = table2[s1643];-  const SWord32 s1645 = s1627 ^ s1644;-  const SWord8  s1646 = (SWord8) (s1630 >> 8);-  const SWord32 s1647 = table1[s1646];-  const SWord16 s1648 = (SWord16) (s1619 >> 16);-  const SWord8  s1649 = (SWord8) s1648;-  const SWord32 s1650 = table2[s1649];-  const SWord32 s1651 = s1647 ^ s1650;-  const SWord8  s1652 = (SWord8) (s1637 >> 8);-  const SWord32 s1653 = table3[s1652];-  const SWord32 s1654 = s1651 ^ s1653;-  const SWord16 s1655 = (SWord16) s1585;-  const SWord8  s1656 = (SWord8) s1655;-  const SWord32 s1657 = table4[s1656];-  const SWord32 s1658 = s1654 ^ s1657;-  const SWord32 s1659 = s30 ^ s1658;-  const SWord16 s1660 = (SWord16) s1659;-  const SWord8  s1661 = (SWord8) (s1660 >> 8);-  const SWord32 s1662 = table3[s1661];-  const SWord32 s1663 = s1645 ^ s1662;-  const SWord8  s1664 = (SWord8) (s1648 >> 8);-  const SWord32 s1665 = table1[s1664];-  const SWord8  s1666 = (SWord8) s1569;-  const SWord32 s1667 = table2[s1666];-  const SWord32 s1668 = s1665 ^ s1667;-  const SWord8  s1669 = (SWord8) (s1655 >> 8);-  const SWord32 s1670 = table3[s1669];-  const SWord32 s1671 = s1668 ^ s1670;-  const SWord8  s1672 = (SWord8) s1604;-  const SWord32 s1673 = table4[s1672];-  const SWord32 s1674 = s1671 ^ s1673;-  const SWord32 s1675 = s31 ^ s1674;-  const SWord16 s1676 = (SWord16) s1675;-  const SWord8  s1677 = (SWord8) s1676;-  const SWord32 s1678 = table4[s1677];-  const SWord32 s1679 = s1663 ^ s1678;-  const SWord32 s1680 = s32 ^ s1679;-  const SWord16 s1681 = (SWord16) (s1680 >> 16);-  const SWord8  s1682 = (SWord8) (s1681 >> 8);-  const SWord32 s1683 = table1[s1682];-  const SWord8  s1684 = (SWord8) (s1642 >> 8);-  const SWord32 s1685 = table1[s1684];-  const SWord16 s1686 = (SWord16) (s1659 >> 16);-  const SWord8  s1687 = (SWord8) s1686;-  const SWord32 s1688 = table2[s1687];-  const SWord32 s1689 = s1685 ^ s1688;-  const SWord8  s1690 = (SWord8) (s1676 >> 8);-  const SWord32 s1691 = table3[s1690];-  const SWord32 s1692 = s1689 ^ s1691;-  const SWord16 s1693 = (SWord16) s1624;-  const SWord8  s1694 = (SWord8) s1693;-  const SWord32 s1695 = table4[s1694];-  const SWord32 s1696 = s1692 ^ s1695;-  const SWord32 s1697 = s33 ^ s1696;-  const SWord16 s1698 = (SWord16) (s1697 >> 16);-  const SWord8  s1699 = (SWord8) s1698;-  const SWord32 s1700 = table2[s1699];-  const SWord32 s1701 = s1683 ^ s1700;-  const SWord8  s1702 = (SWord8) (s1686 >> 8);-  const SWord32 s1703 = table1[s1702];-  const SWord16 s1704 = (SWord16) (s1675 >> 16);-  const SWord8  s1705 = (SWord8) s1704;-  const SWord32 s1706 = table2[s1705];-  const SWord32 s1707 = s1703 ^ s1706;-  const SWord8  s1708 = (SWord8) (s1693 >> 8);-  const SWord32 s1709 = table3[s1708];-  const SWord32 s1710 = s1707 ^ s1709;-  const SWord16 s1711 = (SWord16) s1641;-  const SWord8  s1712 = (SWord8) s1711;-  const SWord32 s1713 = table4[s1712];-  const SWord32 s1714 = s1710 ^ s1713;-  const SWord32 s1715 = s34 ^ s1714;-  const SWord16 s1716 = (SWord16) s1715;-  const SWord8  s1717 = (SWord8) (s1716 >> 8);-  const SWord32 s1718 = table3[s1717];-  const SWord32 s1719 = s1701 ^ s1718;-  const SWord8  s1720 = (SWord8) (s1704 >> 8);-  const SWord32 s1721 = table1[s1720];-  const SWord8  s1722 = (SWord8) s1625;-  const SWord32 s1723 = table2[s1722];-  const SWord32 s1724 = s1721 ^ s1723;-  const SWord8  s1725 = (SWord8) (s1711 >> 8);-  const SWord32 s1726 = table3[s1725];-  const SWord32 s1727 = s1724 ^ s1726;-  const SWord8  s1728 = (SWord8) s1660;-  const SWord32 s1729 = table4[s1728];-  const SWord32 s1730 = s1727 ^ s1729;-  const SWord32 s1731 = s35 ^ s1730;-  const SWord16 s1732 = (SWord16) s1731;-  const SWord8  s1733 = (SWord8) s1732;-  const SWord32 s1734 = table4[s1733];-  const SWord32 s1735 = s1719 ^ s1734;-  const SWord32 s1736 = s36 ^ s1735;-  const SWord16 s1737 = (SWord16) (s1736 >> 16);-  const SWord8  s1738 = (SWord8) (s1737 >> 8);-  const SWord32 s1739 = table1[s1738];-  const SWord8  s1740 = (SWord8) (s1698 >> 8);-  const SWord32 s1741 = table1[s1740];-  const SWord16 s1742 = (SWord16) (s1715 >> 16);-  const SWord8  s1743 = (SWord8) s1742;-  const SWord32 s1744 = table2[s1743];-  const SWord32 s1745 = s1741 ^ s1744;-  const SWord8  s1746 = (SWord8) (s1732 >> 8);-  const SWord32 s1747 = table3[s1746];-  const SWord32 s1748 = s1745 ^ s1747;-  const SWord16 s1749 = (SWord16) s1680;-  const SWord8  s1750 = (SWord8) s1749;-  const SWord32 s1751 = table4[s1750];-  const SWord32 s1752 = s1748 ^ s1751;-  const SWord32 s1753 = s37 ^ s1752;-  const SWord16 s1754 = (SWord16) (s1753 >> 16);-  const SWord8  s1755 = (SWord8) s1754;-  const SWord32 s1756 = table2[s1755];-  const SWord32 s1757 = s1739 ^ s1756;-  const SWord8  s1758 = (SWord8) (s1742 >> 8);-  const SWord32 s1759 = table1[s1758];-  const SWord16 s1760 = (SWord16) (s1731 >> 16);-  const SWord8  s1761 = (SWord8) s1760;-  const SWord32 s1762 = table2[s1761];-  const SWord32 s1763 = s1759 ^ s1762;-  const SWord8  s1764 = (SWord8) (s1749 >> 8);-  const SWord32 s1765 = table3[s1764];-  const SWord32 s1766 = s1763 ^ s1765;-  const SWord16 s1767 = (SWord16) s1697;-  const SWord8  s1768 = (SWord8) s1767;-  const SWord32 s1769 = table4[s1768];-  const SWord32 s1770 = s1766 ^ s1769;-  const SWord32 s1771 = s38 ^ s1770;-  const SWord16 s1772 = (SWord16) s1771;-  const SWord8  s1773 = (SWord8) (s1772 >> 8);-  const SWord32 s1774 = table3[s1773];-  const SWord32 s1775 = s1757 ^ s1774;-  const SWord8  s1776 = (SWord8) (s1760 >> 8);-  const SWord32 s1777 = table1[s1776];-  const SWord8  s1778 = (SWord8) s1681;-  const SWord32 s1779 = table2[s1778];-  const SWord32 s1780 = s1777 ^ s1779;-  const SWord8  s1781 = (SWord8) (s1767 >> 8);-  const SWord32 s1782 = table3[s1781];-  const SWord32 s1783 = s1780 ^ s1782;-  const SWord8  s1784 = (SWord8) s1716;-  const SWord32 s1785 = table4[s1784];-  const SWord32 s1786 = s1783 ^ s1785;-  const SWord32 s1787 = s39 ^ s1786;-  const SWord16 s1788 = (SWord16) s1787;-  const SWord8  s1789 = (SWord8) s1788;-  const SWord32 s1790 = table4[s1789];-  const SWord32 s1791 = s1775 ^ s1790;-  const SWord32 s1792 = s40 ^ s1791;-  const SWord16 s1793 = (SWord16) (s1792 >> 16);-  const SWord8  s1794 = (SWord8) (s1793 >> 8);-  const SWord8  s1795 = table0[s1794];-  const SWord8  s1796 = (SWord8) (s1754 >> 8);-  const SWord32 s1797 = table1[s1796];-  const SWord16 s1798 = (SWord16) (s1771 >> 16);-  const SWord8  s1799 = (SWord8) s1798;-  const SWord32 s1800 = table2[s1799];-  const SWord32 s1801 = s1797 ^ s1800;-  const SWord8  s1802 = (SWord8) (s1788 >> 8);-  const SWord32 s1803 = table3[s1802];-  const SWord32 s1804 = s1801 ^ s1803;-  const SWord16 s1805 = (SWord16) s1736;-  const SWord8  s1806 = (SWord8) s1805;-  const SWord32 s1807 = table4[s1806];-  const SWord32 s1808 = s1804 ^ s1807;-  const SWord32 s1809 = s41 ^ s1808;-  const SWord16 s1810 = (SWord16) (s1809 >> 16);-  const SWord8  s1811 = (SWord8) s1810;-  const SWord8  s1812 = table0[s1811];-  const SWord16 s1813 = (((SWord16) s1795) << 8) | ((SWord16) s1812);-  const SWord8  s1814 = (SWord8) (s1798 >> 8);-  const SWord32 s1815 = table1[s1814];-  const SWord16 s1816 = (SWord16) (s1787 >> 16);-  const SWord8  s1817 = (SWord8) s1816;-  const SWord32 s1818 = table2[s1817];-  const SWord32 s1819 = s1815 ^ s1818;-  const SWord8  s1820 = (SWord8) (s1805 >> 8);-  const SWord32 s1821 = table3[s1820];-  const SWord32 s1822 = s1819 ^ s1821;-  const SWord16 s1823 = (SWord16) s1753;-  const SWord8  s1824 = (SWord8) s1823;-  const SWord32 s1825 = table4[s1824];-  const SWord32 s1826 = s1822 ^ s1825;-  const SWord32 s1827 = s42 ^ s1826;-  const SWord16 s1828 = (SWord16) s1827;-  const SWord8  s1829 = (SWord8) (s1828 >> 8);-  const SWord8  s1830 = table0[s1829];-  const SWord8  s1831 = (SWord8) (s1816 >> 8);-  const SWord32 s1832 = table1[s1831];-  const SWord8  s1833 = (SWord8) s1737;-  const SWord32 s1834 = table2[s1833];-  const SWord32 s1835 = s1832 ^ s1834;-  const SWord8  s1836 = (SWord8) (s1823 >> 8);-  const SWord32 s1837 = table3[s1836];-  const SWord32 s1838 = s1835 ^ s1837;-  const SWord8  s1839 = (SWord8) s1772;-  const SWord32 s1840 = table4[s1839];-  const SWord32 s1841 = s1838 ^ s1840;-  const SWord32 s1842 = s43 ^ s1841;-  const SWord16 s1843 = (SWord16) s1842;-  const SWord8  s1844 = (SWord8) s1843;-  const SWord8  s1845 = table0[s1844];-  const SWord16 s1846 = (((SWord16) s1830) << 8) | ((SWord16) s1845);-  const SWord32 s1847 = (((SWord32) s1813) << 16) | ((SWord32) s1846);-  const SWord32 s1848 = s44 ^ s1847;-  const SWord8  s1849 = (SWord8) (s1810 >> 8);-  const SWord8  s1850 = table0[s1849];-  const SWord16 s1851 = (SWord16) (s1827 >> 16);-  const SWord8  s1852 = (SWord8) s1851;-  const SWord8  s1853 = table0[s1852];-  const SWord16 s1854 = (((SWord16) s1850) << 8) | ((SWord16) s1853);-  const SWord8  s1855 = (SWord8) (s1843 >> 8);-  const SWord8  s1856 = table0[s1855];-  const SWord16 s1857 = (SWord16) s1792;-  const SWord8  s1858 = (SWord8) s1857;-  const SWord8  s1859 = table0[s1858];-  const SWord16 s1860 = (((SWord16) s1856) << 8) | ((SWord16) s1859);-  const SWord32 s1861 = (((SWord32) s1854) << 16) | ((SWord32) s1860);-  const SWord32 s1862 = s45 ^ s1861;-  const SWord8  s1863 = (SWord8) (s1851 >> 8);-  const SWord8  s1864 = table0[s1863];-  const SWord16 s1865 = (SWord16) (s1842 >> 16);-  const SWord8  s1866 = (SWord8) s1865;-  const SWord8  s1867 = table0[s1866];-  const SWord16 s1868 = (((SWord16) s1864) << 8) | ((SWord16) s1867);-  const SWord8  s1869 = (SWord8) (s1857 >> 8);-  const SWord8  s1870 = table0[s1869];-  const SWord16 s1871 = (SWord16) s1809;-  const SWord8  s1872 = (SWord8) s1871;-  const SWord8  s1873 = table0[s1872];-  const SWord16 s1874 = (((SWord16) s1870) << 8) | ((SWord16) s1873);-  const SWord32 s1875 = (((SWord32) s1868) << 16) | ((SWord32) s1874);-  const SWord32 s1876 = s46 ^ s1875;-  const SWord8  s1877 = (SWord8) (s1865 >> 8);-  const SWord8  s1878 = table0[s1877];-  const SWord8  s1879 = (SWord8) s1793;-  const SWord8  s1880 = table0[s1879];-  const SWord16 s1881 = (((SWord16) s1878) << 8) | ((SWord16) s1880);-  const SWord8  s1882 = (SWord8) (s1871 >> 8);-  const SWord8  s1883 = table0[s1882];-  const SWord8  s1884 = (SWord8) s1828;-  const SWord8  s1885 = table0[s1884];-  const SWord16 s1886 = (((SWord16) s1883) << 8) | ((SWord16) s1885);-  const SWord32 s1887 = (((SWord32) s1881) << 16) | ((SWord32) s1886);-  const SWord32 s1888 = s47 ^ s1887;--  ct[0] = s1848;-  ct[1] = s1862;-  ct[2] = s1876;-  ct[3] = s1888;-}-== END: "aes128BlockEncrypt.c" ==================-== BEGIN: "aes128BlockDecrypt.c" ================-/* File: "aes128BlockDecrypt.c". Automatically generated by SBV. Do not edit! */--#include "aes128Lib.h"--void aes128BlockDecrypt(const SWord32 *ct, const SWord32 *xkey,-                        SWord32 *pt)-{-  const SWord32 s0 = ct[0];-  const SWord32 s1 = ct[1];-  const SWord32 s2 = ct[2];-  const SWord32 s3 = ct[3];-  const SWord32 s4 = xkey[0];-  const SWord32 s5 = xkey[1];-  const SWord32 s6 = xkey[2];-  const SWord32 s7 = xkey[3];-  const SWord32 s8 = xkey[4];-  const SWord32 s9 = xkey[5];-  const SWord32 s10 = xkey[6];-  const SWord32 s11 = xkey[7];-  const SWord32 s12 = xkey[8];-  const SWord32 s13 = xkey[9];-  const SWord32 s14 = xkey[10];-  const SWord32 s15 = xkey[11];-  const SWord32 s16 = xkey[12];-  const SWord32 s17 = xkey[13];-  const SWord32 s18 = xkey[14];-  const SWord32 s19 = xkey[15];-  const SWord32 s20 = xkey[16];-  const SWord32 s21 = xkey[17];-  const SWord32 s22 = xkey[18];-  const SWord32 s23 = xkey[19];-  const SWord32 s24 = xkey[20];-  const SWord32 s25 = xkey[21];-  const SWord32 s26 = xkey[22];-  const SWord32 s27 = xkey[23];-  const SWord32 s28 = xkey[24];-  const SWord32 s29 = xkey[25];-  const SWord32 s30 = xkey[26];-  const SWord32 s31 = xkey[27];-  const SWord32 s32 = xkey[28];-  const SWord32 s33 = xkey[29];-  const SWord32 s34 = xkey[30];-  const SWord32 s35 = xkey[31];-  const SWord32 s36 = xkey[32];-  const SWord32 s37 = xkey[33];-  const SWord32 s38 = xkey[34];-  const SWord32 s39 = xkey[35];-  const SWord32 s40 = xkey[36];-  const SWord32 s41 = xkey[37];-  const SWord32 s42 = xkey[38];-  const SWord32 s43 = xkey[39];-  const SWord32 s44 = xkey[40];-  const SWord32 s45 = xkey[41];-  const SWord32 s46 = xkey[42];-  const SWord32 s47 = xkey[43];-  static const SWord8 table0[] = {-       82,   9, 106, 213,  48,  54, 165,  56, 191,  64, 163, 158, 129,-      243, 215, 251, 124, 227,  57, 130, 155,  47, 255, 135,  52, 142,-       67,  68, 196, 222, 233, 203,  84, 123, 148,  50, 166, 194,  35,-       61, 238,  76, 149,  11,  66, 250, 195,  78,   8,  46, 161, 102,-       40, 217,  36, 178, 118,  91, 162,  73, 109, 139, 209,  37, 114,-      248, 246, 100, 134, 104, 152,  22, 212, 164,  92, 204,  93, 101,-      182, 146, 108, 112,  72,  80, 253, 237, 185, 218,  94,  21,  70,-       87, 167, 141, 157, 132, 144, 216, 171,   0, 140, 188, 211,  10,-      247, 228,  88,   5, 184, 179,  69,   6, 208,  44,  30, 143, 202,-       63,  15,   2, 193, 175, 189,   3,   1,  19, 138, 107,  58, 145,-       17,  65,  79, 103, 220, 234, 151, 242, 207, 206, 240, 180, 230,-      115, 150, 172, 116,  34, 231, 173,  53, 133, 226, 249,  55, 232,-       28, 117, 223, 110,  71, 241,  26, 113,  29,  41, 197, 137, 111,-      183,  98,  14, 170,  24, 190,  27, 252,  86,  62,  75, 198, 210,-      121,  32, 154, 219, 192, 254, 120, 205,  90, 244,  31, 221, 168,-       51, 136,   7, 199,  49, 177,  18,  16,  89,  39, 128, 236,  95,-       96,  81, 127, 169,  25, 181,  74,  13,  45, 229, 122, 159, 147,-      201, 156, 239, 160, 224,  59,  77, 174,  42, 245, 176, 200, 235,-      187,  60, 131,  83, 153,  97,  23,  43,   4, 126, 186, 119, 214,-       38, 225, 105,  20,  99,  85,  33,  12, 125-  };-  static const SWord32 table1[] = {-      0x51f4a750UL, 0x7e416553UL, 0x1a17a4c3UL, 0x3a275e96UL,-      0x3bab6bcbUL, 0x1f9d45f1UL, 0xacfa58abUL, 0x4be30393UL,-      0x2030fa55UL, 0xad766df6UL, 0x88cc7691UL, 0xf5024c25UL,-      0x4fe5d7fcUL, 0xc52acbd7UL, 0x26354480UL, 0xb562a38fUL,-      0xdeb15a49UL, 0x25ba1b67UL, 0x45ea0e98UL, 0x5dfec0e1UL,-      0xc32f7502UL, 0x814cf012UL, 0x8d4697a3UL, 0x6bd3f9c6UL,-      0x038f5fe7UL, 0x15929c95UL, 0xbf6d7aebUL, 0x955259daUL,-      0xd4be832dUL, 0x587421d3UL, 0x49e06929UL, 0x8ec9c844UL,-      0x75c2896aUL, 0xf48e7978UL, 0x99583e6bUL, 0x27b971ddUL,-      0xbee14fb6UL, 0xf088ad17UL, 0xc920ac66UL, 0x7dce3ab4UL,-      0x63df4a18UL, 0xe51a3182UL, 0x97513360UL, 0x62537f45UL,-      0xb16477e0UL, 0xbb6bae84UL, 0xfe81a01cUL, 0xf9082b94UL,-      0x70486858UL, 0x8f45fd19UL, 0x94de6c87UL, 0x527bf8b7UL,-      0xab73d323UL, 0x724b02e2UL, 0xe31f8f57UL, 0x6655ab2aUL,-      0xb2eb2807UL, 0x2fb5c203UL, 0x86c57b9aUL, 0xd33708a5UL,-      0x302887f2UL, 0x23bfa5b2UL, 0x02036abaUL, 0xed16825cUL,-      0x8acf1c2bUL, 0xa779b492UL, 0xf307f2f0UL, 0x4e69e2a1UL,-      0x65daf4cdUL, 0x0605bed5UL, 0xd134621fUL, 0xc4a6fe8aUL,-      0x342e539dUL, 0xa2f355a0UL, 0x058ae132UL, 0xa4f6eb75UL,-      0x0b83ec39UL, 0x4060efaaUL, 0x5e719f06UL, 0xbd6e1051UL,-      0x3e218af9UL, 0x96dd063dUL, 0xdd3e05aeUL, 0x4de6bd46UL,-      0x91548db5UL, 0x71c45d05UL, 0x0406d46fUL, 0x605015ffUL,-      0x1998fb24UL, 0xd6bde997UL, 0x894043ccUL, 0x67d99e77UL,-      0xb0e842bdUL, 0x07898b88UL, 0xe7195b38UL, 0x79c8eedbUL,-      0xa17c0a47UL, 0x7c420fe9UL, 0xf8841ec9UL, 0x00000000UL,-      0x09808683UL, 0x322bed48UL, 0x1e1170acUL, 0x6c5a724eUL,-      0xfd0efffbUL, 0x0f853856UL, 0x3daed51eUL, 0x362d3927UL,-      0x0a0fd964UL, 0x685ca621UL, 0x9b5b54d1UL, 0x24362e3aUL,-      0x0c0a67b1UL, 0x9357e70fUL, 0xb4ee96d2UL, 0x1b9b919eUL,-      0x80c0c54fUL, 0x61dc20a2UL, 0x5a774b69UL, 0x1c121a16UL,-      0xe293ba0aUL, 0xc0a02ae5UL, 0x3c22e043UL, 0x121b171dUL,-      0x0e090d0bUL, 0xf28bc7adUL, 0x2db6a8b9UL, 0x141ea9c8UL,-      0x57f11985UL, 0xaf75074cUL, 0xee99ddbbUL, 0xa37f60fdUL,-      0xf701269fUL, 0x5c72f5bcUL, 0x44663bc5UL, 0x5bfb7e34UL,-      0x8b432976UL, 0xcb23c6dcUL, 0xb6edfc68UL, 0xb8e4f163UL,-      0xd731dccaUL, 0x42638510UL, 0x13972240UL, 0x84c61120UL,-      0x854a247dUL, 0xd2bb3df8UL, 0xaef93211UL, 0xc729a16dUL,-      0x1d9e2f4bUL, 0xdcb230f3UL, 0x0d8652ecUL, 0x77c1e3d0UL,-      0x2bb3166cUL, 0xa970b999UL, 0x119448faUL, 0x47e96422UL,-      0xa8fc8cc4UL, 0xa0f03f1aUL, 0x567d2cd8UL, 0x223390efUL,-      0x87494ec7UL, 0xd938d1c1UL, 0x8ccaa2feUL, 0x98d40b36UL,-      0xa6f581cfUL, 0xa57ade28UL, 0xdab78e26UL, 0x3fadbfa4UL,-      0x2c3a9de4UL, 0x5078920dUL, 0x6a5fcc9bUL, 0x547e4662UL,-      0xf68d13c2UL, 0x90d8b8e8UL, 0x2e39f75eUL, 0x82c3aff5UL,-      0x9f5d80beUL, 0x69d0937cUL, 0x6fd52da9UL, 0xcf2512b3UL,-      0xc8ac993bUL, 0x10187da7UL, 0xe89c636eUL, 0xdb3bbb7bUL,-      0xcd267809UL, 0x6e5918f4UL, 0xec9ab701UL, 0x834f9aa8UL,-      0xe6956e65UL, 0xaaffe67eUL, 0x21bccf08UL, 0xef15e8e6UL,-      0xbae79bd9UL, 0x4a6f36ceUL, 0xea9f09d4UL, 0x29b07cd6UL,-      0x31a4b2afUL, 0x2a3f2331UL, 0xc6a59430UL, 0x35a266c0UL,-      0x744ebc37UL, 0xfc82caa6UL, 0xe090d0b0UL, 0x33a7d815UL,-      0xf104984aUL, 0x41ecdaf7UL, 0x7fcd500eUL, 0x1791f62fUL,-      0x764dd68dUL, 0x43efb04dUL, 0xccaa4d54UL, 0xe49604dfUL,-      0x9ed1b5e3UL, 0x4c6a881bUL, 0xc12c1fb8UL, 0x4665517fUL,-      0x9d5eea04UL, 0x018c355dUL, 0xfa877473UL, 0xfb0b412eUL,-      0xb3671d5aUL, 0x92dbd252UL, 0xe9105633UL, 0x6dd64713UL,-      0x9ad7618cUL, 0x37a10c7aUL, 0x59f8148eUL, 0xeb133c89UL,-      0xcea927eeUL, 0xb761c935UL, 0xe11ce5edUL, 0x7a47b13cUL,-      0x9cd2df59UL, 0x55f2733fUL, 0x1814ce79UL, 0x73c737bfUL,-      0x53f7cdeaUL, 0x5ffdaa5bUL, 0xdf3d6f14UL, 0x7844db86UL,-      0xcaaff381UL, 0xb968c43eUL, 0x3824342cUL, 0xc2a3405fUL,-      0x161dc372UL, 0xbce2250cUL, 0x283c498bUL, 0xff0d9541UL,-      0x39a80171UL, 0x080cb3deUL, 0xd8b4e49cUL, 0x6456c190UL,-      0x7bcb8461UL, 0xd532b670UL, 0x486c5c74UL, 0xd0b85742UL-  };-  static const SWord32 table2[] = {-      0x5051f4a7UL, 0x537e4165UL, 0xc31a17a4UL, 0x963a275eUL,-      0xcb3bab6bUL, 0xf11f9d45UL, 0xabacfa58UL, 0x934be303UL,-      0x552030faUL, 0xf6ad766dUL, 0x9188cc76UL, 0x25f5024cUL,-      0xfc4fe5d7UL, 0xd7c52acbUL, 0x80263544UL, 0x8fb562a3UL,-      0x49deb15aUL, 0x6725ba1bUL, 0x9845ea0eUL, 0xe15dfec0UL,-      0x02c32f75UL, 0x12814cf0UL, 0xa38d4697UL, 0xc66bd3f9UL,-      0xe7038f5fUL, 0x9515929cUL, 0xebbf6d7aUL, 0xda955259UL,-      0x2dd4be83UL, 0xd3587421UL, 0x2949e069UL, 0x448ec9c8UL,-      0x6a75c289UL, 0x78f48e79UL, 0x6b99583eUL, 0xdd27b971UL,-      0xb6bee14fUL, 0x17f088adUL, 0x66c920acUL, 0xb47dce3aUL,-      0x1863df4aUL, 0x82e51a31UL, 0x60975133UL, 0x4562537fUL,-      0xe0b16477UL, 0x84bb6baeUL, 0x1cfe81a0UL, 0x94f9082bUL,-      0x58704868UL, 0x198f45fdUL, 0x8794de6cUL, 0xb7527bf8UL,-      0x23ab73d3UL, 0xe2724b02UL, 0x57e31f8fUL, 0x2a6655abUL,-      0x07b2eb28UL, 0x032fb5c2UL, 0x9a86c57bUL, 0xa5d33708UL,-      0xf2302887UL, 0xb223bfa5UL, 0xba02036aUL, 0x5ced1682UL,-      0x2b8acf1cUL, 0x92a779b4UL, 0xf0f307f2UL, 0xa14e69e2UL,-      0xcd65daf4UL, 0xd50605beUL, 0x1fd13462UL, 0x8ac4a6feUL,-      0x9d342e53UL, 0xa0a2f355UL, 0x32058ae1UL, 0x75a4f6ebUL,-      0x390b83ecUL, 0xaa4060efUL, 0x065e719fUL, 0x51bd6e10UL,-      0xf93e218aUL, 0x3d96dd06UL, 0xaedd3e05UL, 0x464de6bdUL,-      0xb591548dUL, 0x0571c45dUL, 0x6f0406d4UL, 0xff605015UL,-      0x241998fbUL, 0x97d6bde9UL, 0xcc894043UL, 0x7767d99eUL,-      0xbdb0e842UL, 0x8807898bUL, 0x38e7195bUL, 0xdb79c8eeUL,-      0x47a17c0aUL, 0xe97c420fUL, 0xc9f8841eUL, 0x00000000UL,-      0x83098086UL, 0x48322bedUL, 0xac1e1170UL, 0x4e6c5a72UL,-      0xfbfd0effUL, 0x560f8538UL, 0x1e3daed5UL, 0x27362d39UL,-      0x640a0fd9UL, 0x21685ca6UL, 0xd19b5b54UL, 0x3a24362eUL,-      0xb10c0a67UL, 0x0f9357e7UL, 0xd2b4ee96UL, 0x9e1b9b91UL,-      0x4f80c0c5UL, 0xa261dc20UL, 0x695a774bUL, 0x161c121aUL,-      0x0ae293baUL, 0xe5c0a02aUL, 0x433c22e0UL, 0x1d121b17UL,-      0x0b0e090dUL, 0xadf28bc7UL, 0xb92db6a8UL, 0xc8141ea9UL,-      0x8557f119UL, 0x4caf7507UL, 0xbbee99ddUL, 0xfda37f60UL,-      0x9ff70126UL, 0xbc5c72f5UL, 0xc544663bUL, 0x345bfb7eUL,-      0x768b4329UL, 0xdccb23c6UL, 0x68b6edfcUL, 0x63b8e4f1UL,-      0xcad731dcUL, 0x10426385UL, 0x40139722UL, 0x2084c611UL,-      0x7d854a24UL, 0xf8d2bb3dUL, 0x11aef932UL, 0x6dc729a1UL,-      0x4b1d9e2fUL, 0xf3dcb230UL, 0xec0d8652UL, 0xd077c1e3UL,-      0x6c2bb316UL, 0x99a970b9UL, 0xfa119448UL, 0x2247e964UL,-      0xc4a8fc8cUL, 0x1aa0f03fUL, 0xd8567d2cUL, 0xef223390UL,-      0xc787494eUL, 0xc1d938d1UL, 0xfe8ccaa2UL, 0x3698d40bUL,-      0xcfa6f581UL, 0x28a57adeUL, 0x26dab78eUL, 0xa43fadbfUL,-      0xe42c3a9dUL, 0x0d507892UL, 0x9b6a5fccUL, 0x62547e46UL,-      0xc2f68d13UL, 0xe890d8b8UL, 0x5e2e39f7UL, 0xf582c3afUL,-      0xbe9f5d80UL, 0x7c69d093UL, 0xa96fd52dUL, 0xb3cf2512UL,-      0x3bc8ac99UL, 0xa710187dUL, 0x6ee89c63UL, 0x7bdb3bbbUL,-      0x09cd2678UL, 0xf46e5918UL, 0x01ec9ab7UL, 0xa8834f9aUL,-      0x65e6956eUL, 0x7eaaffe6UL, 0x0821bccfUL, 0xe6ef15e8UL,-      0xd9bae79bUL, 0xce4a6f36UL, 0xd4ea9f09UL, 0xd629b07cUL,-      0xaf31a4b2UL, 0x312a3f23UL, 0x30c6a594UL, 0xc035a266UL,-      0x37744ebcUL, 0xa6fc82caUL, 0xb0e090d0UL, 0x1533a7d8UL,-      0x4af10498UL, 0xf741ecdaUL, 0x0e7fcd50UL, 0x2f1791f6UL,-      0x8d764dd6UL, 0x4d43efb0UL, 0x54ccaa4dUL, 0xdfe49604UL,-      0xe39ed1b5UL, 0x1b4c6a88UL, 0xb8c12c1fUL, 0x7f466551UL,-      0x049d5eeaUL, 0x5d018c35UL, 0x73fa8774UL, 0x2efb0b41UL,-      0x5ab3671dUL, 0x5292dbd2UL, 0x33e91056UL, 0x136dd647UL,-      0x8c9ad761UL, 0x7a37a10cUL, 0x8e59f814UL, 0x89eb133cUL,-      0xeecea927UL, 0x35b761c9UL, 0xede11ce5UL, 0x3c7a47b1UL,-      0x599cd2dfUL, 0x3f55f273UL, 0x791814ceUL, 0xbf73c737UL,-      0xea53f7cdUL, 0x5b5ffdaaUL, 0x14df3d6fUL, 0x867844dbUL,-      0x81caaff3UL, 0x3eb968c4UL, 0x2c382434UL, 0x5fc2a340UL,-      0x72161dc3UL, 0x0cbce225UL, 0x8b283c49UL, 0x41ff0d95UL,-      0x7139a801UL, 0xde080cb3UL, 0x9cd8b4e4UL, 0x906456c1UL,-      0x617bcb84UL, 0x70d532b6UL, 0x74486c5cUL, 0x42d0b857UL-  };-  static const SWord32 table3[] = {-      0xa75051f4UL, 0x65537e41UL, 0xa4c31a17UL, 0x5e963a27UL,-      0x6bcb3babUL, 0x45f11f9dUL, 0x58abacfaUL, 0x03934be3UL,-      0xfa552030UL, 0x6df6ad76UL, 0x769188ccUL, 0x4c25f502UL,-      0xd7fc4fe5UL, 0xcbd7c52aUL, 0x44802635UL, 0xa38fb562UL,-      0x5a49deb1UL, 0x1b6725baUL, 0x0e9845eaUL, 0xc0e15dfeUL,-      0x7502c32fUL, 0xf012814cUL, 0x97a38d46UL, 0xf9c66bd3UL,-      0x5fe7038fUL, 0x9c951592UL, 0x7aebbf6dUL, 0x59da9552UL,-      0x832dd4beUL, 0x21d35874UL, 0x692949e0UL, 0xc8448ec9UL,-      0x896a75c2UL, 0x7978f48eUL, 0x3e6b9958UL, 0x71dd27b9UL,-      0x4fb6bee1UL, 0xad17f088UL, 0xac66c920UL, 0x3ab47dceUL,-      0x4a1863dfUL, 0x3182e51aUL, 0x33609751UL, 0x7f456253UL,-      0x77e0b164UL, 0xae84bb6bUL, 0xa01cfe81UL, 0x2b94f908UL,-      0x68587048UL, 0xfd198f45UL, 0x6c8794deUL, 0xf8b7527bUL,-      0xd323ab73UL, 0x02e2724bUL, 0x8f57e31fUL, 0xab2a6655UL,-      0x2807b2ebUL, 0xc2032fb5UL, 0x7b9a86c5UL, 0x08a5d337UL,-      0x87f23028UL, 0xa5b223bfUL, 0x6aba0203UL, 0x825ced16UL,-      0x1c2b8acfUL, 0xb492a779UL, 0xf2f0f307UL, 0xe2a14e69UL,-      0xf4cd65daUL, 0xbed50605UL, 0x621fd134UL, 0xfe8ac4a6UL,-      0x539d342eUL, 0x55a0a2f3UL, 0xe132058aUL, 0xeb75a4f6UL,-      0xec390b83UL, 0xefaa4060UL, 0x9f065e71UL, 0x1051bd6eUL,-      0x8af93e21UL, 0x063d96ddUL, 0x05aedd3eUL, 0xbd464de6UL,-      0x8db59154UL, 0x5d0571c4UL, 0xd46f0406UL, 0x15ff6050UL,-      0xfb241998UL, 0xe997d6bdUL, 0x43cc8940UL, 0x9e7767d9UL,-      0x42bdb0e8UL, 0x8b880789UL, 0x5b38e719UL, 0xeedb79c8UL,-      0x0a47a17cUL, 0x0fe97c42UL, 0x1ec9f884UL, 0x00000000UL,-      0x86830980UL, 0xed48322bUL, 0x70ac1e11UL, 0x724e6c5aUL,-      0xfffbfd0eUL, 0x38560f85UL, 0xd51e3daeUL, 0x3927362dUL,-      0xd9640a0fUL, 0xa621685cUL, 0x54d19b5bUL, 0x2e3a2436UL,-      0x67b10c0aUL, 0xe70f9357UL, 0x96d2b4eeUL, 0x919e1b9bUL,-      0xc54f80c0UL, 0x20a261dcUL, 0x4b695a77UL, 0x1a161c12UL,-      0xba0ae293UL, 0x2ae5c0a0UL, 0xe0433c22UL, 0x171d121bUL,-      0x0d0b0e09UL, 0xc7adf28bUL, 0xa8b92db6UL, 0xa9c8141eUL,-      0x198557f1UL, 0x074caf75UL, 0xddbbee99UL, 0x60fda37fUL,-      0x269ff701UL, 0xf5bc5c72UL, 0x3bc54466UL, 0x7e345bfbUL,-      0x29768b43UL, 0xc6dccb23UL, 0xfc68b6edUL, 0xf163b8e4UL,-      0xdccad731UL, 0x85104263UL, 0x22401397UL, 0x112084c6UL,-      0x247d854aUL, 0x3df8d2bbUL, 0x3211aef9UL, 0xa16dc729UL,-      0x2f4b1d9eUL, 0x30f3dcb2UL, 0x52ec0d86UL, 0xe3d077c1UL,-      0x166c2bb3UL, 0xb999a970UL, 0x48fa1194UL, 0x642247e9UL,-      0x8cc4a8fcUL, 0x3f1aa0f0UL, 0x2cd8567dUL, 0x90ef2233UL,-      0x4ec78749UL, 0xd1c1d938UL, 0xa2fe8ccaUL, 0x0b3698d4UL,-      0x81cfa6f5UL, 0xde28a57aUL, 0x8e26dab7UL, 0xbfa43fadUL,-      0x9de42c3aUL, 0x920d5078UL, 0xcc9b6a5fUL, 0x4662547eUL,-      0x13c2f68dUL, 0xb8e890d8UL, 0xf75e2e39UL, 0xaff582c3UL,-      0x80be9f5dUL, 0x937c69d0UL, 0x2da96fd5UL, 0x12b3cf25UL,-      0x993bc8acUL, 0x7da71018UL, 0x636ee89cUL, 0xbb7bdb3bUL,-      0x7809cd26UL, 0x18f46e59UL, 0xb701ec9aUL, 0x9aa8834fUL,-      0x6e65e695UL, 0xe67eaaffUL, 0xcf0821bcUL, 0xe8e6ef15UL,-      0x9bd9bae7UL, 0x36ce4a6fUL, 0x09d4ea9fUL, 0x7cd629b0UL,-      0xb2af31a4UL, 0x23312a3fUL, 0x9430c6a5UL, 0x66c035a2UL,-      0xbc37744eUL, 0xcaa6fc82UL, 0xd0b0e090UL, 0xd81533a7UL,-      0x984af104UL, 0xdaf741ecUL, 0x500e7fcdUL, 0xf62f1791UL,-      0xd68d764dUL, 0xb04d43efUL, 0x4d54ccaaUL, 0x04dfe496UL,-      0xb5e39ed1UL, 0x881b4c6aUL, 0x1fb8c12cUL, 0x517f4665UL,-      0xea049d5eUL, 0x355d018cUL, 0x7473fa87UL, 0x412efb0bUL,-      0x1d5ab367UL, 0xd25292dbUL, 0x5633e910UL, 0x47136dd6UL,-      0x618c9ad7UL, 0x0c7a37a1UL, 0x148e59f8UL, 0x3c89eb13UL,-      0x27eecea9UL, 0xc935b761UL, 0xe5ede11cUL, 0xb13c7a47UL,-      0xdf599cd2UL, 0x733f55f2UL, 0xce791814UL, 0x37bf73c7UL,-      0xcdea53f7UL, 0xaa5b5ffdUL, 0x6f14df3dUL, 0xdb867844UL,-      0xf381caafUL, 0xc43eb968UL, 0x342c3824UL, 0x405fc2a3UL,-      0xc372161dUL, 0x250cbce2UL, 0x498b283cUL, 0x9541ff0dUL,-      0x017139a8UL, 0xb3de080cUL, 0xe49cd8b4UL, 0xc1906456UL,-      0x84617bcbUL, 0xb670d532UL, 0x5c74486cUL, 0x5742d0b8UL-  };-  static const SWord32 table4[] = {-      0xf4a75051UL, 0x4165537eUL, 0x17a4c31aUL, 0x275e963aUL,-      0xab6bcb3bUL, 0x9d45f11fUL, 0xfa58abacUL, 0xe303934bUL,-      0x30fa5520UL, 0x766df6adUL, 0xcc769188UL, 0x024c25f5UL,-      0xe5d7fc4fUL, 0x2acbd7c5UL, 0x35448026UL, 0x62a38fb5UL,-      0xb15a49deUL, 0xba1b6725UL, 0xea0e9845UL, 0xfec0e15dUL,-      0x2f7502c3UL, 0x4cf01281UL, 0x4697a38dUL, 0xd3f9c66bUL,-      0x8f5fe703UL, 0x929c9515UL, 0x6d7aebbfUL, 0x5259da95UL,-      0xbe832dd4UL, 0x7421d358UL, 0xe0692949UL, 0xc9c8448eUL,-      0xc2896a75UL, 0x8e7978f4UL, 0x583e6b99UL, 0xb971dd27UL,-      0xe14fb6beUL, 0x88ad17f0UL, 0x20ac66c9UL, 0xce3ab47dUL,-      0xdf4a1863UL, 0x1a3182e5UL, 0x51336097UL, 0x537f4562UL,-      0x6477e0b1UL, 0x6bae84bbUL, 0x81a01cfeUL, 0x082b94f9UL,-      0x48685870UL, 0x45fd198fUL, 0xde6c8794UL, 0x7bf8b752UL,-      0x73d323abUL, 0x4b02e272UL, 0x1f8f57e3UL, 0x55ab2a66UL,-      0xeb2807b2UL, 0xb5c2032fUL, 0xc57b9a86UL, 0x3708a5d3UL,-      0x2887f230UL, 0xbfa5b223UL, 0x036aba02UL, 0x16825cedUL,-      0xcf1c2b8aUL, 0x79b492a7UL, 0x07f2f0f3UL, 0x69e2a14eUL,-      0xdaf4cd65UL, 0x05bed506UL, 0x34621fd1UL, 0xa6fe8ac4UL,-      0x2e539d34UL, 0xf355a0a2UL, 0x8ae13205UL, 0xf6eb75a4UL,-      0x83ec390bUL, 0x60efaa40UL, 0x719f065eUL, 0x6e1051bdUL,-      0x218af93eUL, 0xdd063d96UL, 0x3e05aeddUL, 0xe6bd464dUL,-      0x548db591UL, 0xc45d0571UL, 0x06d46f04UL, 0x5015ff60UL,-      0x98fb2419UL, 0xbde997d6UL, 0x4043cc89UL, 0xd99e7767UL,-      0xe842bdb0UL, 0x898b8807UL, 0x195b38e7UL, 0xc8eedb79UL,-      0x7c0a47a1UL, 0x420fe97cUL, 0x841ec9f8UL, 0x00000000UL,-      0x80868309UL, 0x2bed4832UL, 0x1170ac1eUL, 0x5a724e6cUL,-      0x0efffbfdUL, 0x8538560fUL, 0xaed51e3dUL, 0x2d392736UL,-      0x0fd9640aUL, 0x5ca62168UL, 0x5b54d19bUL, 0x362e3a24UL,-      0x0a67b10cUL, 0x57e70f93UL, 0xee96d2b4UL, 0x9b919e1bUL,-      0xc0c54f80UL, 0xdc20a261UL, 0x774b695aUL, 0x121a161cUL,-      0x93ba0ae2UL, 0xa02ae5c0UL, 0x22e0433cUL, 0x1b171d12UL,-      0x090d0b0eUL, 0x8bc7adf2UL, 0xb6a8b92dUL, 0x1ea9c814UL,-      0xf1198557UL, 0x75074cafUL, 0x99ddbbeeUL, 0x7f60fda3UL,-      0x01269ff7UL, 0x72f5bc5cUL, 0x663bc544UL, 0xfb7e345bUL,-      0x4329768bUL, 0x23c6dccbUL, 0xedfc68b6UL, 0xe4f163b8UL,-      0x31dccad7UL, 0x63851042UL, 0x97224013UL, 0xc6112084UL,-      0x4a247d85UL, 0xbb3df8d2UL, 0xf93211aeUL, 0x29a16dc7UL,-      0x9e2f4b1dUL, 0xb230f3dcUL, 0x8652ec0dUL, 0xc1e3d077UL,-      0xb3166c2bUL, 0x70b999a9UL, 0x9448fa11UL, 0xe9642247UL,-      0xfc8cc4a8UL, 0xf03f1aa0UL, 0x7d2cd856UL, 0x3390ef22UL,-      0x494ec787UL, 0x38d1c1d9UL, 0xcaa2fe8cUL, 0xd40b3698UL,-      0xf581cfa6UL, 0x7ade28a5UL, 0xb78e26daUL, 0xadbfa43fUL,-      0x3a9de42cUL, 0x78920d50UL, 0x5fcc9b6aUL, 0x7e466254UL,-      0x8d13c2f6UL, 0xd8b8e890UL, 0x39f75e2eUL, 0xc3aff582UL,-      0x5d80be9fUL, 0xd0937c69UL, 0xd52da96fUL, 0x2512b3cfUL,-      0xac993bc8UL, 0x187da710UL, 0x9c636ee8UL, 0x3bbb7bdbUL,-      0x267809cdUL, 0x5918f46eUL, 0x9ab701ecUL, 0x4f9aa883UL,-      0x956e65e6UL, 0xffe67eaaUL, 0xbccf0821UL, 0x15e8e6efUL,-      0xe79bd9baUL, 0x6f36ce4aUL, 0x9f09d4eaUL, 0xb07cd629UL,-      0xa4b2af31UL, 0x3f23312aUL, 0xa59430c6UL, 0xa266c035UL,-      0x4ebc3774UL, 0x82caa6fcUL, 0x90d0b0e0UL, 0xa7d81533UL,-      0x04984af1UL, 0xecdaf741UL, 0xcd500e7fUL, 0x91f62f17UL,-      0x4dd68d76UL, 0xefb04d43UL, 0xaa4d54ccUL, 0x9604dfe4UL,-      0xd1b5e39eUL, 0x6a881b4cUL, 0x2c1fb8c1UL, 0x65517f46UL,-      0x5eea049dUL, 0x8c355d01UL, 0x877473faUL, 0x0b412efbUL,-      0x671d5ab3UL, 0xdbd25292UL, 0x105633e9UL, 0xd647136dUL,-      0xd7618c9aUL, 0xa10c7a37UL, 0xf8148e59UL, 0x133c89ebUL,-      0xa927eeceUL, 0x61c935b7UL, 0x1ce5ede1UL, 0x47b13c7aUL,-      0xd2df599cUL, 0xf2733f55UL, 0x14ce7918UL, 0xc737bf73UL,-      0xf7cdea53UL, 0xfdaa5b5fUL, 0x3d6f14dfUL, 0x44db8678UL,-      0xaff381caUL, 0x68c43eb9UL, 0x24342c38UL, 0xa3405fc2UL,-      0x1dc37216UL, 0xe2250cbcUL, 0x3c498b28UL, 0x0d9541ffUL,-      0xa8017139UL, 0x0cb3de08UL, 0xb4e49cd8UL, 0x56c19064UL,-      0xcb84617bUL, 0x32b670d5UL, 0x6c5c7448UL, 0xb85742d0UL-  };-  const SWord32 s560 = s0 ^ s4;-  const SWord16 s561 = (SWord16) (s560 >> 16);-  const SWord8  s562 = (SWord8) (s561 >> 8);-  const SWord32 s563 = table1[s562];-  const SWord32 s819 = s3 ^ s7;-  const SWord16 s820 = (SWord16) (s819 >> 16);-  const SWord8  s821 = (SWord8) s820;-  const SWord32 s822 = table2[s821];-  const SWord32 s823 = s563 ^ s822;-  const SWord32 s1079 = s2 ^ s6;-  const SWord16 s1080 = (SWord16) s1079;-  const SWord8  s1081 = (SWord8) (s1080 >> 8);-  const SWord32 s1082 = table3[s1081];-  const SWord32 s1083 = s823 ^ s1082;-  const SWord32 s1339 = s1 ^ s5;-  const SWord16 s1340 = (SWord16) s1339;-  const SWord8  s1341 = (SWord8) s1340;-  const SWord32 s1342 = table4[s1341];-  const SWord32 s1343 = s1083 ^ s1342;-  const SWord32 s1344 = s8 ^ s1343;-  const SWord16 s1345 = (SWord16) (s1344 >> 16);-  const SWord8  s1346 = (SWord8) (s1345 >> 8);-  const SWord32 s1347 = table1[s1346];-  const SWord8  s1348 = (SWord8) (s820 >> 8);-  const SWord32 s1349 = table1[s1348];-  const SWord16 s1350 = (SWord16) (s1079 >> 16);-  const SWord8  s1351 = (SWord8) s1350;-  const SWord32 s1352 = table2[s1351];-  const SWord32 s1353 = s1349 ^ s1352;-  const SWord8  s1354 = (SWord8) (s1340 >> 8);-  const SWord32 s1355 = table3[s1354];-  const SWord32 s1356 = s1353 ^ s1355;-  const SWord16 s1357 = (SWord16) s560;-  const SWord8  s1358 = (SWord8) s1357;-  const SWord32 s1359 = table4[s1358];-  const SWord32 s1360 = s1356 ^ s1359;-  const SWord32 s1361 = s11 ^ s1360;-  const SWord16 s1362 = (SWord16) (s1361 >> 16);-  const SWord8  s1363 = (SWord8) s1362;-  const SWord32 s1364 = table2[s1363];-  const SWord32 s1365 = s1347 ^ s1364;-  const SWord8  s1366 = (SWord8) (s1350 >> 8);-  const SWord32 s1367 = table1[s1366];-  const SWord16 s1368 = (SWord16) (s1339 >> 16);-  const SWord8  s1369 = (SWord8) s1368;-  const SWord32 s1370 = table2[s1369];-  const SWord32 s1371 = s1367 ^ s1370;-  const SWord8  s1372 = (SWord8) (s1357 >> 8);-  const SWord32 s1373 = table3[s1372];-  const SWord32 s1374 = s1371 ^ s1373;-  const SWord16 s1375 = (SWord16) s819;-  const SWord8  s1376 = (SWord8) s1375;-  const SWord32 s1377 = table4[s1376];-  const SWord32 s1378 = s1374 ^ s1377;-  const SWord32 s1379 = s10 ^ s1378;-  const SWord16 s1380 = (SWord16) s1379;-  const SWord8  s1381 = (SWord8) (s1380 >> 8);-  const SWord32 s1382 = table3[s1381];-  const SWord32 s1383 = s1365 ^ s1382;-  const SWord8  s1384 = (SWord8) (s1368 >> 8);-  const SWord32 s1385 = table1[s1384];-  const SWord8  s1386 = (SWord8) s561;-  const SWord32 s1387 = table2[s1386];-  const SWord32 s1388 = s1385 ^ s1387;-  const SWord8  s1389 = (SWord8) (s1375 >> 8);-  const SWord32 s1390 = table3[s1389];-  const SWord32 s1391 = s1388 ^ s1390;-  const SWord8  s1392 = (SWord8) s1080;-  const SWord32 s1393 = table4[s1392];-  const SWord32 s1394 = s1391 ^ s1393;-  const SWord32 s1395 = s9 ^ s1394;-  const SWord16 s1396 = (SWord16) s1395;-  const SWord8  s1397 = (SWord8) s1396;-  const SWord32 s1398 = table4[s1397];-  const SWord32 s1399 = s1383 ^ s1398;-  const SWord32 s1400 = s12 ^ s1399;-  const SWord16 s1401 = (SWord16) (s1400 >> 16);-  const SWord8  s1402 = (SWord8) (s1401 >> 8);-  const SWord32 s1403 = table1[s1402];-  const SWord8  s1404 = (SWord8) (s1362 >> 8);-  const SWord32 s1405 = table1[s1404];-  const SWord16 s1406 = (SWord16) (s1379 >> 16);-  const SWord8  s1407 = (SWord8) s1406;-  const SWord32 s1408 = table2[s1407];-  const SWord32 s1409 = s1405 ^ s1408;-  const SWord8  s1410 = (SWord8) (s1396 >> 8);-  const SWord32 s1411 = table3[s1410];-  const SWord32 s1412 = s1409 ^ s1411;-  const SWord16 s1413 = (SWord16) s1344;-  const SWord8  s1414 = (SWord8) s1413;-  const SWord32 s1415 = table4[s1414];-  const SWord32 s1416 = s1412 ^ s1415;-  const SWord32 s1417 = s15 ^ s1416;-  const SWord16 s1418 = (SWord16) (s1417 >> 16);-  const SWord8  s1419 = (SWord8) s1418;-  const SWord32 s1420 = table2[s1419];-  const SWord32 s1421 = s1403 ^ s1420;-  const SWord8  s1422 = (SWord8) (s1406 >> 8);-  const SWord32 s1423 = table1[s1422];-  const SWord16 s1424 = (SWord16) (s1395 >> 16);-  const SWord8  s1425 = (SWord8) s1424;-  const SWord32 s1426 = table2[s1425];-  const SWord32 s1427 = s1423 ^ s1426;-  const SWord8  s1428 = (SWord8) (s1413 >> 8);-  const SWord32 s1429 = table3[s1428];-  const SWord32 s1430 = s1427 ^ s1429;-  const SWord16 s1431 = (SWord16) s1361;-  const SWord8  s1432 = (SWord8) s1431;-  const SWord32 s1433 = table4[s1432];-  const SWord32 s1434 = s1430 ^ s1433;-  const SWord32 s1435 = s14 ^ s1434;-  const SWord16 s1436 = (SWord16) s1435;-  const SWord8  s1437 = (SWord8) (s1436 >> 8);-  const SWord32 s1438 = table3[s1437];-  const SWord32 s1439 = s1421 ^ s1438;-  const SWord8  s1440 = (SWord8) (s1424 >> 8);-  const SWord32 s1441 = table1[s1440];-  const SWord8  s1442 = (SWord8) s1345;-  const SWord32 s1443 = table2[s1442];-  const SWord32 s1444 = s1441 ^ s1443;-  const SWord8  s1445 = (SWord8) (s1431 >> 8);-  const SWord32 s1446 = table3[s1445];-  const SWord32 s1447 = s1444 ^ s1446;-  const SWord8  s1448 = (SWord8) s1380;-  const SWord32 s1449 = table4[s1448];-  const SWord32 s1450 = s1447 ^ s1449;-  const SWord32 s1451 = s13 ^ s1450;-  const SWord16 s1452 = (SWord16) s1451;-  const SWord8  s1453 = (SWord8) s1452;-  const SWord32 s1454 = table4[s1453];-  const SWord32 s1455 = s1439 ^ s1454;-  const SWord32 s1456 = s16 ^ s1455;-  const SWord16 s1457 = (SWord16) (s1456 >> 16);-  const SWord8  s1458 = (SWord8) (s1457 >> 8);-  const SWord32 s1459 = table1[s1458];-  const SWord8  s1460 = (SWord8) (s1418 >> 8);-  const SWord32 s1461 = table1[s1460];-  const SWord16 s1462 = (SWord16) (s1435 >> 16);-  const SWord8  s1463 = (SWord8) s1462;-  const SWord32 s1464 = table2[s1463];-  const SWord32 s1465 = s1461 ^ s1464;-  const SWord8  s1466 = (SWord8) (s1452 >> 8);-  const SWord32 s1467 = table3[s1466];-  const SWord32 s1468 = s1465 ^ s1467;-  const SWord16 s1469 = (SWord16) s1400;-  const SWord8  s1470 = (SWord8) s1469;-  const SWord32 s1471 = table4[s1470];-  const SWord32 s1472 = s1468 ^ s1471;-  const SWord32 s1473 = s19 ^ s1472;-  const SWord16 s1474 = (SWord16) (s1473 >> 16);-  const SWord8  s1475 = (SWord8) s1474;-  const SWord32 s1476 = table2[s1475];-  const SWord32 s1477 = s1459 ^ s1476;-  const SWord8  s1478 = (SWord8) (s1462 >> 8);-  const SWord32 s1479 = table1[s1478];-  const SWord16 s1480 = (SWord16) (s1451 >> 16);-  const SWord8  s1481 = (SWord8) s1480;-  const SWord32 s1482 = table2[s1481];-  const SWord32 s1483 = s1479 ^ s1482;-  const SWord8  s1484 = (SWord8) (s1469 >> 8);-  const SWord32 s1485 = table3[s1484];-  const SWord32 s1486 = s1483 ^ s1485;-  const SWord16 s1487 = (SWord16) s1417;-  const SWord8  s1488 = (SWord8) s1487;-  const SWord32 s1489 = table4[s1488];-  const SWord32 s1490 = s1486 ^ s1489;-  const SWord32 s1491 = s18 ^ s1490;-  const SWord16 s1492 = (SWord16) s1491;-  const SWord8  s1493 = (SWord8) (s1492 >> 8);-  const SWord32 s1494 = table3[s1493];-  const SWord32 s1495 = s1477 ^ s1494;-  const SWord8  s1496 = (SWord8) (s1480 >> 8);-  const SWord32 s1497 = table1[s1496];-  const SWord8  s1498 = (SWord8) s1401;-  const SWord32 s1499 = table2[s1498];-  const SWord32 s1500 = s1497 ^ s1499;-  const SWord8  s1501 = (SWord8) (s1487 >> 8);-  const SWord32 s1502 = table3[s1501];-  const SWord32 s1503 = s1500 ^ s1502;-  const SWord8  s1504 = (SWord8) s1436;-  const SWord32 s1505 = table4[s1504];-  const SWord32 s1506 = s1503 ^ s1505;-  const SWord32 s1507 = s17 ^ s1506;-  const SWord16 s1508 = (SWord16) s1507;-  const SWord8  s1509 = (SWord8) s1508;-  const SWord32 s1510 = table4[s1509];-  const SWord32 s1511 = s1495 ^ s1510;-  const SWord32 s1512 = s20 ^ s1511;-  const SWord16 s1513 = (SWord16) (s1512 >> 16);-  const SWord8  s1514 = (SWord8) (s1513 >> 8);-  const SWord32 s1515 = table1[s1514];-  const SWord8  s1516 = (SWord8) (s1474 >> 8);-  const SWord32 s1517 = table1[s1516];-  const SWord16 s1518 = (SWord16) (s1491 >> 16);-  const SWord8  s1519 = (SWord8) s1518;-  const SWord32 s1520 = table2[s1519];-  const SWord32 s1521 = s1517 ^ s1520;-  const SWord8  s1522 = (SWord8) (s1508 >> 8);-  const SWord32 s1523 = table3[s1522];-  const SWord32 s1524 = s1521 ^ s1523;-  const SWord16 s1525 = (SWord16) s1456;-  const SWord8  s1526 = (SWord8) s1525;-  const SWord32 s1527 = table4[s1526];-  const SWord32 s1528 = s1524 ^ s1527;-  const SWord32 s1529 = s23 ^ s1528;-  const SWord16 s1530 = (SWord16) (s1529 >> 16);-  const SWord8  s1531 = (SWord8) s1530;-  const SWord32 s1532 = table2[s1531];-  const SWord32 s1533 = s1515 ^ s1532;-  const SWord8  s1534 = (SWord8) (s1518 >> 8);-  const SWord32 s1535 = table1[s1534];-  const SWord16 s1536 = (SWord16) (s1507 >> 16);-  const SWord8  s1537 = (SWord8) s1536;-  const SWord32 s1538 = table2[s1537];-  const SWord32 s1539 = s1535 ^ s1538;-  const SWord8  s1540 = (SWord8) (s1525 >> 8);-  const SWord32 s1541 = table3[s1540];-  const SWord32 s1542 = s1539 ^ s1541;-  const SWord16 s1543 = (SWord16) s1473;-  const SWord8  s1544 = (SWord8) s1543;-  const SWord32 s1545 = table4[s1544];-  const SWord32 s1546 = s1542 ^ s1545;-  const SWord32 s1547 = s22 ^ s1546;-  const SWord16 s1548 = (SWord16) s1547;-  const SWord8  s1549 = (SWord8) (s1548 >> 8);-  const SWord32 s1550 = table3[s1549];-  const SWord32 s1551 = s1533 ^ s1550;-  const SWord8  s1552 = (SWord8) (s1536 >> 8);-  const SWord32 s1553 = table1[s1552];-  const SWord8  s1554 = (SWord8) s1457;-  const SWord32 s1555 = table2[s1554];-  const SWord32 s1556 = s1553 ^ s1555;-  const SWord8  s1557 = (SWord8) (s1543 >> 8);-  const SWord32 s1558 = table3[s1557];-  const SWord32 s1559 = s1556 ^ s1558;-  const SWord8  s1560 = (SWord8) s1492;-  const SWord32 s1561 = table4[s1560];-  const SWord32 s1562 = s1559 ^ s1561;-  const SWord32 s1563 = s21 ^ s1562;-  const SWord16 s1564 = (SWord16) s1563;-  const SWord8  s1565 = (SWord8) s1564;-  const SWord32 s1566 = table4[s1565];-  const SWord32 s1567 = s1551 ^ s1566;-  const SWord32 s1568 = s24 ^ s1567;-  const SWord16 s1569 = (SWord16) (s1568 >> 16);-  const SWord8  s1570 = (SWord8) (s1569 >> 8);-  const SWord32 s1571 = table1[s1570];-  const SWord8  s1572 = (SWord8) (s1530 >> 8);-  const SWord32 s1573 = table1[s1572];-  const SWord16 s1574 = (SWord16) (s1547 >> 16);-  const SWord8  s1575 = (SWord8) s1574;-  const SWord32 s1576 = table2[s1575];-  const SWord32 s1577 = s1573 ^ s1576;-  const SWord8  s1578 = (SWord8) (s1564 >> 8);-  const SWord32 s1579 = table3[s1578];-  const SWord32 s1580 = s1577 ^ s1579;-  const SWord16 s1581 = (SWord16) s1512;-  const SWord8  s1582 = (SWord8) s1581;-  const SWord32 s1583 = table4[s1582];-  const SWord32 s1584 = s1580 ^ s1583;-  const SWord32 s1585 = s27 ^ s1584;-  const SWord16 s1586 = (SWord16) (s1585 >> 16);-  const SWord8  s1587 = (SWord8) s1586;-  const SWord32 s1588 = table2[s1587];-  const SWord32 s1589 = s1571 ^ s1588;-  const SWord8  s1590 = (SWord8) (s1574 >> 8);-  const SWord32 s1591 = table1[s1590];-  const SWord16 s1592 = (SWord16) (s1563 >> 16);-  const SWord8  s1593 = (SWord8) s1592;-  const SWord32 s1594 = table2[s1593];-  const SWord32 s1595 = s1591 ^ s1594;-  const SWord8  s1596 = (SWord8) (s1581 >> 8);-  const SWord32 s1597 = table3[s1596];-  const SWord32 s1598 = s1595 ^ s1597;-  const SWord16 s1599 = (SWord16) s1529;-  const SWord8  s1600 = (SWord8) s1599;-  const SWord32 s1601 = table4[s1600];-  const SWord32 s1602 = s1598 ^ s1601;-  const SWord32 s1603 = s26 ^ s1602;-  const SWord16 s1604 = (SWord16) s1603;-  const SWord8  s1605 = (SWord8) (s1604 >> 8);-  const SWord32 s1606 = table3[s1605];-  const SWord32 s1607 = s1589 ^ s1606;-  const SWord8  s1608 = (SWord8) (s1592 >> 8);-  const SWord32 s1609 = table1[s1608];-  const SWord8  s1610 = (SWord8) s1513;-  const SWord32 s1611 = table2[s1610];-  const SWord32 s1612 = s1609 ^ s1611;-  const SWord8  s1613 = (SWord8) (s1599 >> 8);-  const SWord32 s1614 = table3[s1613];-  const SWord32 s1615 = s1612 ^ s1614;-  const SWord8  s1616 = (SWord8) s1548;-  const SWord32 s1617 = table4[s1616];-  const SWord32 s1618 = s1615 ^ s1617;-  const SWord32 s1619 = s25 ^ s1618;-  const SWord16 s1620 = (SWord16) s1619;-  const SWord8  s1621 = (SWord8) s1620;-  const SWord32 s1622 = table4[s1621];-  const SWord32 s1623 = s1607 ^ s1622;-  const SWord32 s1624 = s28 ^ s1623;-  const SWord16 s1625 = (SWord16) (s1624 >> 16);-  const SWord8  s1626 = (SWord8) (s1625 >> 8);-  const SWord32 s1627 = table1[s1626];-  const SWord8  s1628 = (SWord8) (s1586 >> 8);-  const SWord32 s1629 = table1[s1628];-  const SWord16 s1630 = (SWord16) (s1603 >> 16);-  const SWord8  s1631 = (SWord8) s1630;-  const SWord32 s1632 = table2[s1631];-  const SWord32 s1633 = s1629 ^ s1632;-  const SWord8  s1634 = (SWord8) (s1620 >> 8);-  const SWord32 s1635 = table3[s1634];-  const SWord32 s1636 = s1633 ^ s1635;-  const SWord16 s1637 = (SWord16) s1568;-  const SWord8  s1638 = (SWord8) s1637;-  const SWord32 s1639 = table4[s1638];-  const SWord32 s1640 = s1636 ^ s1639;-  const SWord32 s1641 = s31 ^ s1640;-  const SWord16 s1642 = (SWord16) (s1641 >> 16);-  const SWord8  s1643 = (SWord8) s1642;-  const SWord32 s1644 = table2[s1643];-  const SWord32 s1645 = s1627 ^ s1644;-  const SWord8  s1646 = (SWord8) (s1630 >> 8);-  const SWord32 s1647 = table1[s1646];-  const SWord16 s1648 = (SWord16) (s1619 >> 16);-  const SWord8  s1649 = (SWord8) s1648;-  const SWord32 s1650 = table2[s1649];-  const SWord32 s1651 = s1647 ^ s1650;-  const SWord8  s1652 = (SWord8) (s1637 >> 8);-  const SWord32 s1653 = table3[s1652];-  const SWord32 s1654 = s1651 ^ s1653;-  const SWord16 s1655 = (SWord16) s1585;-  const SWord8  s1656 = (SWord8) s1655;-  const SWord32 s1657 = table4[s1656];-  const SWord32 s1658 = s1654 ^ s1657;-  const SWord32 s1659 = s30 ^ s1658;-  const SWord16 s1660 = (SWord16) s1659;-  const SWord8  s1661 = (SWord8) (s1660 >> 8);-  const SWord32 s1662 = table3[s1661];-  const SWord32 s1663 = s1645 ^ s1662;-  const SWord8  s1664 = (SWord8) (s1648 >> 8);-  const SWord32 s1665 = table1[s1664];-  const SWord8  s1666 = (SWord8) s1569;-  const SWord32 s1667 = table2[s1666];-  const SWord32 s1668 = s1665 ^ s1667;-  const SWord8  s1669 = (SWord8) (s1655 >> 8);-  const SWord32 s1670 = table3[s1669];-  const SWord32 s1671 = s1668 ^ s1670;-  const SWord8  s1672 = (SWord8) s1604;-  const SWord32 s1673 = table4[s1672];-  const SWord32 s1674 = s1671 ^ s1673;-  const SWord32 s1675 = s29 ^ s1674;-  const SWord16 s1676 = (SWord16) s1675;-  const SWord8  s1677 = (SWord8) s1676;-  const SWord32 s1678 = table4[s1677];-  const SWord32 s1679 = s1663 ^ s1678;-  const SWord32 s1680 = s32 ^ s1679;-  const SWord16 s1681 = (SWord16) (s1680 >> 16);-  const SWord8  s1682 = (SWord8) (s1681 >> 8);-  const SWord32 s1683 = table1[s1682];-  const SWord8  s1684 = (SWord8) (s1642 >> 8);-  const SWord32 s1685 = table1[s1684];-  const SWord16 s1686 = (SWord16) (s1659 >> 16);-  const SWord8  s1687 = (SWord8) s1686;-  const SWord32 s1688 = table2[s1687];-  const SWord32 s1689 = s1685 ^ s1688;-  const SWord8  s1690 = (SWord8) (s1676 >> 8);-  const SWord32 s1691 = table3[s1690];-  const SWord32 s1692 = s1689 ^ s1691;-  const SWord16 s1693 = (SWord16) s1624;-  const SWord8  s1694 = (SWord8) s1693;-  const SWord32 s1695 = table4[s1694];-  const SWord32 s1696 = s1692 ^ s1695;-  const SWord32 s1697 = s35 ^ s1696;-  const SWord16 s1698 = (SWord16) (s1697 >> 16);-  const SWord8  s1699 = (SWord8) s1698;-  const SWord32 s1700 = table2[s1699];-  const SWord32 s1701 = s1683 ^ s1700;-  const SWord8  s1702 = (SWord8) (s1686 >> 8);-  const SWord32 s1703 = table1[s1702];-  const SWord16 s1704 = (SWord16) (s1675 >> 16);-  const SWord8  s1705 = (SWord8) s1704;-  const SWord32 s1706 = table2[s1705];-  const SWord32 s1707 = s1703 ^ s1706;-  const SWord8  s1708 = (SWord8) (s1693 >> 8);-  const SWord32 s1709 = table3[s1708];-  const SWord32 s1710 = s1707 ^ s1709;-  const SWord16 s1711 = (SWord16) s1641;-  const SWord8  s1712 = (SWord8) s1711;-  const SWord32 s1713 = table4[s1712];-  const SWord32 s1714 = s1710 ^ s1713;-  const SWord32 s1715 = s34 ^ s1714;-  const SWord16 s1716 = (SWord16) s1715;-  const SWord8  s1717 = (SWord8) (s1716 >> 8);-  const SWord32 s1718 = table3[s1717];-  const SWord32 s1719 = s1701 ^ s1718;-  const SWord8  s1720 = (SWord8) (s1704 >> 8);-  const SWord32 s1721 = table1[s1720];-  const SWord8  s1722 = (SWord8) s1625;-  const SWord32 s1723 = table2[s1722];-  const SWord32 s1724 = s1721 ^ s1723;-  const SWord8  s1725 = (SWord8) (s1711 >> 8);-  const SWord32 s1726 = table3[s1725];-  const SWord32 s1727 = s1724 ^ s1726;-  const SWord8  s1728 = (SWord8) s1660;-  const SWord32 s1729 = table4[s1728];-  const SWord32 s1730 = s1727 ^ s1729;-  const SWord32 s1731 = s33 ^ s1730;-  const SWord16 s1732 = (SWord16) s1731;-  const SWord8  s1733 = (SWord8) s1732;-  const SWord32 s1734 = table4[s1733];-  const SWord32 s1735 = s1719 ^ s1734;-  const SWord32 s1736 = s36 ^ s1735;-  const SWord16 s1737 = (SWord16) (s1736 >> 16);-  const SWord8  s1738 = (SWord8) (s1737 >> 8);-  const SWord32 s1739 = table1[s1738];-  const SWord8  s1740 = (SWord8) (s1698 >> 8);-  const SWord32 s1741 = table1[s1740];-  const SWord16 s1742 = (SWord16) (s1715 >> 16);-  const SWord8  s1743 = (SWord8) s1742;-  const SWord32 s1744 = table2[s1743];-  const SWord32 s1745 = s1741 ^ s1744;-  const SWord8  s1746 = (SWord8) (s1732 >> 8);-  const SWord32 s1747 = table3[s1746];-  const SWord32 s1748 = s1745 ^ s1747;-  const SWord16 s1749 = (SWord16) s1680;-  const SWord8  s1750 = (SWord8) s1749;-  const SWord32 s1751 = table4[s1750];-  const SWord32 s1752 = s1748 ^ s1751;-  const SWord32 s1753 = s39 ^ s1752;-  const SWord16 s1754 = (SWord16) (s1753 >> 16);-  const SWord8  s1755 = (SWord8) s1754;-  const SWord32 s1756 = table2[s1755];-  const SWord32 s1757 = s1739 ^ s1756;-  const SWord8  s1758 = (SWord8) (s1742 >> 8);-  const SWord32 s1759 = table1[s1758];-  const SWord16 s1760 = (SWord16) (s1731 >> 16);-  const SWord8  s1761 = (SWord8) s1760;-  const SWord32 s1762 = table2[s1761];-  const SWord32 s1763 = s1759 ^ s1762;-  const SWord8  s1764 = (SWord8) (s1749 >> 8);-  const SWord32 s1765 = table3[s1764];-  const SWord32 s1766 = s1763 ^ s1765;-  const SWord16 s1767 = (SWord16) s1697;-  const SWord8  s1768 = (SWord8) s1767;-  const SWord32 s1769 = table4[s1768];-  const SWord32 s1770 = s1766 ^ s1769;-  const SWord32 s1771 = s38 ^ s1770;-  const SWord16 s1772 = (SWord16) s1771;-  const SWord8  s1773 = (SWord8) (s1772 >> 8);-  const SWord32 s1774 = table3[s1773];-  const SWord32 s1775 = s1757 ^ s1774;-  const SWord8  s1776 = (SWord8) (s1760 >> 8);-  const SWord32 s1777 = table1[s1776];-  const SWord8  s1778 = (SWord8) s1681;-  const SWord32 s1779 = table2[s1778];-  const SWord32 s1780 = s1777 ^ s1779;-  const SWord8  s1781 = (SWord8) (s1767 >> 8);-  const SWord32 s1782 = table3[s1781];-  const SWord32 s1783 = s1780 ^ s1782;-  const SWord8  s1784 = (SWord8) s1716;-  const SWord32 s1785 = table4[s1784];-  const SWord32 s1786 = s1783 ^ s1785;-  const SWord32 s1787 = s37 ^ s1786;-  const SWord16 s1788 = (SWord16) s1787;-  const SWord8  s1789 = (SWord8) s1788;-  const SWord32 s1790 = table4[s1789];-  const SWord32 s1791 = s1775 ^ s1790;-  const SWord32 s1792 = s40 ^ s1791;-  const SWord16 s1793 = (SWord16) (s1792 >> 16);-  const SWord8  s1794 = (SWord8) (s1793 >> 8);-  const SWord8  s1795 = table0[s1794];-  const SWord8  s1796 = (SWord8) (s1754 >> 8);-  const SWord32 s1797 = table1[s1796];-  const SWord16 s1798 = (SWord16) (s1771 >> 16);-  const SWord8  s1799 = (SWord8) s1798;-  const SWord32 s1800 = table2[s1799];-  const SWord32 s1801 = s1797 ^ s1800;-  const SWord8  s1802 = (SWord8) (s1788 >> 8);-  const SWord32 s1803 = table3[s1802];-  const SWord32 s1804 = s1801 ^ s1803;-  const SWord16 s1805 = (SWord16) s1736;-  const SWord8  s1806 = (SWord8) s1805;-  const SWord32 s1807 = table4[s1806];-  const SWord32 s1808 = s1804 ^ s1807;-  const SWord32 s1809 = s43 ^ s1808;-  const SWord16 s1810 = (SWord16) (s1809 >> 16);-  const SWord8  s1811 = (SWord8) s1810;-  const SWord8  s1812 = table0[s1811];-  const SWord16 s1813 = (((SWord16) s1795) << 8) | ((SWord16) s1812);-  const SWord8  s1814 = (SWord8) (s1798 >> 8);-  const SWord32 s1815 = table1[s1814];-  const SWord16 s1816 = (SWord16) (s1787 >> 16);-  const SWord8  s1817 = (SWord8) s1816;-  const SWord32 s1818 = table2[s1817];-  const SWord32 s1819 = s1815 ^ s1818;-  const SWord8  s1820 = (SWord8) (s1805 >> 8);-  const SWord32 s1821 = table3[s1820];-  const SWord32 s1822 = s1819 ^ s1821;-  const SWord16 s1823 = (SWord16) s1753;-  const SWord8  s1824 = (SWord8) s1823;-  const SWord32 s1825 = table4[s1824];-  const SWord32 s1826 = s1822 ^ s1825;-  const SWord32 s1827 = s42 ^ s1826;-  const SWord16 s1828 = (SWord16) s1827;-  const SWord8  s1829 = (SWord8) (s1828 >> 8);-  const SWord8  s1830 = table0[s1829];-  const SWord8  s1831 = (SWord8) (s1816 >> 8);-  const SWord32 s1832 = table1[s1831];-  const SWord8  s1833 = (SWord8) s1737;-  const SWord32 s1834 = table2[s1833];-  const SWord32 s1835 = s1832 ^ s1834;-  const SWord8  s1836 = (SWord8) (s1823 >> 8);-  const SWord32 s1837 = table3[s1836];-  const SWord32 s1838 = s1835 ^ s1837;-  const SWord8  s1839 = (SWord8) s1772;-  const SWord32 s1840 = table4[s1839];-  const SWord32 s1841 = s1838 ^ s1840;-  const SWord32 s1842 = s41 ^ s1841;-  const SWord16 s1843 = (SWord16) s1842;-  const SWord8  s1844 = (SWord8) s1843;-  const SWord8  s1845 = table0[s1844];-  const SWord16 s1846 = (((SWord16) s1830) << 8) | ((SWord16) s1845);-  const SWord32 s1847 = (((SWord32) s1813) << 16) | ((SWord32) s1846);-  const SWord32 s1848 = s44 ^ s1847;-  const SWord16 s1849 = (SWord16) (s1842 >> 16);-  const SWord8  s1850 = (SWord8) (s1849 >> 8);-  const SWord8  s1851 = table0[s1850];-  const SWord8  s1852 = (SWord8) s1793;-  const SWord8  s1853 = table0[s1852];-  const SWord16 s1854 = (((SWord16) s1851) << 8) | ((SWord16) s1853);-  const SWord16 s1855 = (SWord16) s1809;-  const SWord8  s1856 = (SWord8) (s1855 >> 8);-  const SWord8  s1857 = table0[s1856];-  const SWord8  s1858 = (SWord8) s1828;-  const SWord8  s1859 = table0[s1858];-  const SWord16 s1860 = (((SWord16) s1857) << 8) | ((SWord16) s1859);-  const SWord32 s1861 = (((SWord32) s1854) << 16) | ((SWord32) s1860);-  const SWord32 s1862 = s45 ^ s1861;-  const SWord16 s1863 = (SWord16) (s1827 >> 16);-  const SWord8  s1864 = (SWord8) (s1863 >> 8);-  const SWord8  s1865 = table0[s1864];-  const SWord8  s1866 = (SWord8) s1849;-  const SWord8  s1867 = table0[s1866];-  const SWord16 s1868 = (((SWord16) s1865) << 8) | ((SWord16) s1867);-  const SWord16 s1869 = (SWord16) s1792;-  const SWord8  s1870 = (SWord8) (s1869 >> 8);-  const SWord8  s1871 = table0[s1870];-  const SWord8  s1872 = (SWord8) s1855;-  const SWord8  s1873 = table0[s1872];-  const SWord16 s1874 = (((SWord16) s1871) << 8) | ((SWord16) s1873);-  const SWord32 s1875 = (((SWord32) s1868) << 16) | ((SWord32) s1874);-  const SWord32 s1876 = s46 ^ s1875;-  const SWord8  s1877 = (SWord8) (s1810 >> 8);-  const SWord8  s1878 = table0[s1877];-  const SWord8  s1879 = (SWord8) s1863;-  const SWord8  s1880 = table0[s1879];-  const SWord16 s1881 = (((SWord16) s1878) << 8) | ((SWord16) s1880);-  const SWord8  s1882 = (SWord8) (s1843 >> 8);-  const SWord8  s1883 = table0[s1882];-  const SWord8  s1884 = (SWord8) s1869;-  const SWord8  s1885 = table0[s1884];-  const SWord16 s1886 = (((SWord16) s1883) << 8) | ((SWord16) s1885);-  const SWord32 s1887 = (((SWord32) s1881) << 16) | ((SWord32) s1886);-  const SWord32 s1888 = s47 ^ s1887;--  pt[0] = s1848;-  pt[1] = s1862;-  pt[2] = s1876;-  pt[3] = s1888;-}-== END: "aes128BlockDecrypt.c" ==================-== BEGIN: "aes128Lib.h" ================-/* Header file for aes128Lib. Automatically generated by SBV. Do not edit! */--#ifndef __aes128Lib__HEADER_INCLUDED__-#define __aes128Lib__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototypes: */-void aes128KeySchedule(const SWord32 *key, SWord32 *encKS,-                       SWord32 *decKS);-void aes128BlockEncrypt(const SWord32 *pt, const SWord32 *xkey,-                        SWord32 *ct);-void aes128BlockDecrypt(const SWord32 *ct, const SWord32 *xkey,-                        SWord32 *pt);--#endif /* __aes128Lib__HEADER_INCLUDED__ */-== END: "aes128Lib.h" ==================-== BEGIN: "aes128Lib_driver.c" ================-/* Example driver program for aes128Lib. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "aes128Lib.h"--void aes128KeySchedule_driver(void)-{-  const SWord32 key[4] = {-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL-  };--  printf("Contents of input array key:\n");-  int key_ctr;-  for(key_ctr = 0; key_ctr < 4 ; ++key_ctr)-    printf("  key[%d] = 0x%08"PRIx32"UL\n", key_ctr ,key[key_ctr]);--  SWord32 encKS[44];-  SWord32 decKS[44];--  aes128KeySchedule(key, encKS, decKS);--  printf("aes128KeySchedule(key, encKS, decKS) ->\n");-  int encKS_ctr;-  for(encKS_ctr = 0; encKS_ctr < 44 ; ++encKS_ctr)-    printf("  encKS[%d] = 0x%08"PRIx32"UL\n", encKS_ctr ,encKS[encKS_ctr]);-  int decKS_ctr;-  for(decKS_ctr = 0; decKS_ctr < 44 ; ++decKS_ctr)-    printf("  decKS[%d] = 0x%08"PRIx32"UL\n", decKS_ctr ,decKS[decKS_ctr]);-}--void aes128BlockEncrypt_driver(void)-{-  const SWord32 pt[4] = {-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL-  };--  printf("Contents of input array pt:\n");-  int pt_ctr;-  for(pt_ctr = 0; pt_ctr < 4 ; ++pt_ctr)-    printf("  pt[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]);--  const SWord32 xkey[44] = {-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL-  };--  printf("Contents of input array xkey:\n");-  int xkey_ctr;-  for(xkey_ctr = 0; xkey_ctr < 44 ; ++xkey_ctr)-    printf("  xkey[%d] = 0x%08"PRIx32"UL\n", xkey_ctr ,xkey[xkey_ctr]);--  SWord32 ct[4];--  aes128BlockEncrypt(pt, xkey, ct);--  printf("aes128BlockEncrypt(pt, xkey, ct) ->\n");-  int ct_ctr;-  for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr)-    printf("  ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]);-}--void aes128BlockDecrypt_driver(void)-{-  const SWord32 ct[4] = {-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL-  };--  printf("Contents of input array ct:\n");-  int ct_ctr;-  for(ct_ctr = 0; ct_ctr < 4 ; ++ct_ctr)-    printf("  ct[%d] = 0x%08"PRIx32"UL\n", ct_ctr ,ct[ct_ctr]);--  const SWord32 xkey[44] = {-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL,-      0x00000000UL, 0x00000000UL, 0x00000000UL, 0x00000000UL-  };--  printf("Contents of input array xkey:\n");-  int xkey_ctr;-  for(xkey_ctr = 0; xkey_ctr < 44 ; ++xkey_ctr)-    printf("  xkey[%d] = 0x%08"PRIx32"UL\n", xkey_ctr ,xkey[xkey_ctr]);--  SWord32 pt[4];--  aes128BlockDecrypt(ct, xkey, pt);--  printf("aes128BlockDecrypt(ct, xkey, pt) ->\n");-  int pt_ctr;-  for(pt_ctr = 0; pt_ctr < 4 ; ++pt_ctr)-    printf("  pt[%d] = 0x%08"PRIx32"UL\n", pt_ctr ,pt[pt_ctr]);-}--int main(void)-{-  printf("====================================\n");-  printf("** Driver run for aes128KeySchedule:\n");-  printf("====================================\n");-  aes128KeySchedule_driver();--  printf("=====================================\n");-  printf("** Driver run for aes128BlockEncrypt:\n");-  printf("=====================================\n");-  aes128BlockEncrypt_driver();--  printf("=====================================\n");-  printf("** Driver run for aes128BlockDecrypt:\n");-  printf("=====================================\n");-  aes128BlockDecrypt_driver();--  return 0;-}-== END: "aes128Lib_driver.c" ==================-== BEGIN: "Makefile" ================-# Makefile for aes128Lib. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer-AR?=ar-ARFLAGS?=cr--all: aes128Lib.a aes128Lib_driver--aes128Lib.a: aes128KeySchedule.o aes128BlockEncrypt.o aes128BlockDecrypt.o-	${AR} ${ARFLAGS} $@ $^--aes128Lib_driver: aes128Lib_driver.c aes128Lib.h-	${CC} ${CCFLAGS} $< -o $@ aes128Lib.a--aes128KeySchedule.o: aes128KeySchedule.c aes128Lib.h-	${CC} ${CCFLAGS} -c $< -o $@--aes128BlockEncrypt.o: aes128BlockEncrypt.c aes128Lib.h-	${CC} ${CCFLAGS} -c $< -o $@--aes128BlockDecrypt.o: aes128BlockDecrypt.c aes128Lib.h-	${CC} ${CCFLAGS} -c $< -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f aes128Lib.a aes128Lib_driver-== END: "Makefile" ==================
− SBVUnitTest/GoldFiles/auf-1.gold 
@@ -1,35 +0,0 @@-INPUTS-  s0 :: SWord32, existential, aliasing "x"-  s1 :: SWord32, existential, aliasing "y"-  s2 :: SWord32, existential, aliasing "initVal"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s3 = 2 :: Word32-  s9 = 3 :: Word32-  s13 = 1 :: Word32-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-  [uninterpreted] f :: SWord32 -> SWord64-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s4 :: SWord32 = s0 + s3-  s5 :: SBool = s1 == s4-  s6 :: SBool = ~ s5-  s7 :: SWord32 = s1 - s3-  s8 :: SBool = s0 == s7-  s10 :: SWord32 = if s8 then s9 else s2-  s11 :: SWord64 = [uninterpreted] f s10-  s12 :: SWord32 = s1 - s0-  s14 :: SWord32 = s12 + s13-  s15 :: SWord64 = [uninterpreted] f s14-  s16 :: SBool = s11 == s15-  s17 :: SBool = s6 | s16-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s17
− SBVUnitTest/GoldFiles/basic-1_1.gold 
@@ -1,1 +0,0 @@-5 :: Word8
− SBVUnitTest/GoldFiles/basic-1_2.gold 
@@ -1,1 +0,0 @@-5 :: Word8
− SBVUnitTest/GoldFiles/basic-1_3.gold 
@@ -1,1 +0,0 @@-25 :: Word8
− SBVUnitTest/GoldFiles/basic-1_4.gold 
@@ -1,1 +0,0 @@-25 :: Word8
− SBVUnitTest/GoldFiles/basic-1_5.gold 
@@ -1,1 +0,0 @@-4 :: Word8
− SBVUnitTest/GoldFiles/basic-2_1.gold 
@@ -1,21 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "y"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s1 = 3 :: Word8-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 + s1-  s3 :: SWord8 = s1 - s0-  s4 :: SWord8 = s2 * s3-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s4
− SBVUnitTest/GoldFiles/basic-2_2.gold 
@@ -1,20 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "y"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s1 = 9 :: Word8-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 * s0-  s3 :: SWord8 = s1 - s2-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s3
− SBVUnitTest/GoldFiles/basic-2_3.gold 
@@ -1,20 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "y"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s1 = 3 :: Word8-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 + s1-  s3 :: SWord8 = s2 * s2-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s3
− SBVUnitTest/GoldFiles/basic-2_4.gold 
@@ -1,20 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "y"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s1 = 3 :: Word8-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 + s1-  s3 :: SWord8 = s2 * s2-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s3
− SBVUnitTest/GoldFiles/basic-2_5.gold 
@@ -1,1 +0,0 @@-4 :: Word8
− SBVUnitTest/GoldFiles/basic-3_1.gold 
@@ -1,21 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-  s1 :: SWord8, aliasing "y"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 + s1-  s3 :: SWord8 = s0 - s1-  s4 :: SWord8 = s2 * s3-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s4
− SBVUnitTest/GoldFiles/basic-3_2.gold 
@@ -1,21 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-  s1 :: SWord8, aliasing "y"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 * s0-  s3 :: SWord8 = s1 * s1-  s4 :: SWord8 = s2 - s3-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s4
− SBVUnitTest/GoldFiles/basic-3_3.gold 
@@ -1,20 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-  s1 :: SWord8, aliasing "y"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 + s1-  s3 :: SWord8 = s2 * s2-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s3
− SBVUnitTest/GoldFiles/basic-3_4.gold 
@@ -1,20 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-  s1 :: SWord8, aliasing "y"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 + s1-  s3 :: SWord8 = s2 * s2-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s3
− SBVUnitTest/GoldFiles/basic-3_5.gold 
@@ -1,20 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-  s1 :: SWord8, aliasing "y"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s2 = 1 :: Word8-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s3 :: SWord8 = s0 + s2-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s3
− SBVUnitTest/GoldFiles/basic-4_1.gold 
@@ -1,20 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s1 :: SWord8 = s0 + s0-  s2 :: SWord8 = s0 - s0-  s3 :: SWord8 = s1 * s2-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s3
− SBVUnitTest/GoldFiles/basic-4_2.gold 
@@ -1,19 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s1 :: SWord8 = s0 * s0-  s2 :: SWord8 = s1 - s1-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s2
− SBVUnitTest/GoldFiles/basic-4_3.gold 
@@ -1,19 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s1 :: SWord8 = s0 + s0-  s2 :: SWord8 = s1 * s1-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s2
− SBVUnitTest/GoldFiles/basic-4_4.gold 
@@ -1,19 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s1 :: SWord8 = s0 + s0-  s2 :: SWord8 = s1 * s1-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s2
− SBVUnitTest/GoldFiles/basic-4_5.gold 
@@ -1,19 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s1 = 1 :: Word8-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 + s1-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s2
− SBVUnitTest/GoldFiles/basic-5_1.gold 
@@ -1,22 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-  s1 :: SWord8, aliasing "q"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 + s0-  s3 :: SWord8 = s0 - s0-  s4 :: SWord8 = s2 * s3-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s1-  s4
− SBVUnitTest/GoldFiles/basic-5_2.gold 
@@ -1,21 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-  s1 :: SWord8, aliasing "q"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 * s0-  s3 :: SWord8 = s2 - s2-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s1-  s3
− SBVUnitTest/GoldFiles/basic-5_3.gold 
@@ -1,21 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-  s1 :: SWord8, aliasing "q"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 + s0-  s3 :: SWord8 = s2 * s2-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s1-  s3
− SBVUnitTest/GoldFiles/basic-5_4.gold 
@@ -1,21 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-  s1 :: SWord8, aliasing "q"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SWord8 = s0 + s0-  s3 :: SWord8 = s2 * s2-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s1-  s3
− SBVUnitTest/GoldFiles/basic-5_5.gold 
@@ -1,21 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-  s1 :: SWord8, aliasing "q"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s2 = 1 :: Word8-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s3 :: SWord8 = s0 + s2-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s1-  s3
− SBVUnitTest/GoldFiles/ccitt.gold 
@@ -1,1834 +0,0 @@-INPUTS-  s0 :: SWord32-  s1 :: SWord16-  s2 :: SWord32-  s3 :: SWord16-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s13 = 0 :: Word1-  s1686 = 0 :: Word8-  s1687 = 1 :: Word8-  s1815 = 3 :: Word8-  s9 = 0 :: Word16-  s525 = 1 :: Word64-  s526 = 0 :: Word64-  s528 = 2 :: Word64-  s531 = 4 :: Word64-  s534 = 8 :: Word64-  s537 = 16 :: Word64-  s540 = 32 :: Word64-  s543 = 64 :: Word64-  s546 = 128 :: Word64-  s549 = 256 :: Word64-  s552 = 512 :: Word64-  s555 = 1024 :: Word64-  s558 = 2048 :: Word64-  s561 = 4096 :: Word64-  s564 = 8192 :: Word64-  s567 = 16384 :: Word64-  s570 = 32768 :: Word64-  s573 = 65536 :: Word64-  s576 = 131072 :: Word64-  s579 = 262144 :: Word64-  s582 = 524288 :: Word64-  s585 = 1048576 :: Word64-  s588 = 2097152 :: Word64-  s591 = 4194304 :: Word64-  s594 = 8388608 :: Word64-  s597 = 16777216 :: Word64-  s600 = 33554432 :: Word64-  s603 = 67108864 :: Word64-  s606 = 134217728 :: Word64-  s609 = 268435456 :: Word64-  s612 = 536870912 :: Word64-  s615 = 1073741824 :: Word64-  s618 = 2147483648 :: Word64-  s621 = 4294967296 :: Word64-  s624 = 8589934592 :: Word64-  s627 = 17179869184 :: Word64-  s630 = 34359738368 :: Word64-  s633 = 68719476736 :: Word64-  s636 = 137438953472 :: Word64-  s639 = 274877906944 :: Word64-  s642 = 549755813888 :: Word64-  s645 = 1099511627776 :: Word64-  s648 = 2199023255552 :: Word64-  s651 = 4398046511104 :: Word64-  s654 = 8796093022208 :: Word64-  s657 = 17592186044416 :: Word64-  s660 = 35184372088832 :: Word64-  s663 = 70368744177664 :: Word64-  s666 = 140737488355328 :: Word64-  s669 = 281474976710656 :: Word64-  s672 = 562949953421312 :: Word64-  s675 = 1125899906842624 :: Word64-  s678 = 2251799813685248 :: Word64-  s681 = 4503599627370496 :: Word64-  s684 = 9007199254740992 :: Word64-  s687 = 18014398509481984 :: Word64-  s690 = 36028797018963968 :: Word64-  s693 = 72057594037927936 :: Word64-  s696 = 144115188075855872 :: Word64-  s699 = 288230376151711744 :: Word64-  s702 = 576460752303423488 :: Word64-  s705 = 1152921504606846976 :: Word64-  s708 = 2305843009213693952 :: Word64-  s711 = 4611686018427387904 :: Word64-  s714 = 9223372036854775808 :: Word64-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s4 :: SBool = s0 == s2-  s5 :: SBool = s1 == s3-  s6 :: SBool = s4 & s5-  s7 :: SBool = ~ s6-  s8 :: SBool = ~ s7-  s10 :: SWord32 = s1 # s9-  s11 :: SWord64 = s0 # s10-  s12 :: SWord1 = choose [63:63] s11-  s14 :: SBool = s12 /= s13-  s15 :: SWord1 = choose [62:62] s11-  s16 :: SBool = s13 /= s15-  s17 :: SWord1 = choose [61:61] s11-  s18 :: SBool = s13 /= s17-  s19 :: SWord1 = choose [60:60] s11-  s20 :: SBool = s13 /= s19-  s21 :: SWord1 = choose [59:59] s11-  s22 :: SBool = s13 /= s21-  s23 :: SBool = ~ s22-  s24 :: SBool = if s14 then s23 else s22-  s25 :: SWord1 = choose [58:58] s11-  s26 :: SBool = s13 /= s25-  s27 :: SBool = ~ s26-  s28 :: SBool = if s16 then s27 else s26-  s29 :: SWord1 = choose [57:57] s11-  s30 :: SBool = s13 /= s29-  s31 :: SBool = ~ s30-  s32 :: SBool = if s18 then s31 else s30-  s33 :: SWord1 = choose [56:56] s11-  s34 :: SBool = s13 /= s33-  s35 :: SBool = ~ s34-  s36 :: SBool = if s20 then s35 else s34-  s37 :: SWord1 = choose [55:55] s11-  s38 :: SBool = s13 /= s37-  s39 :: SBool = ~ s38-  s40 :: SBool = if s24 then s39 else s38-  s41 :: SWord1 = choose [54:54] s11-  s42 :: SBool = s13 /= s41-  s43 :: SBool = ~ s42-  s44 :: SBool = if s28 then s43 else s42-  s45 :: SWord1 = choose [53:53] s11-  s46 :: SBool = s13 /= s45-  s47 :: SBool = ~ s46-  s48 :: SBool = if s32 then s47 else s46-  s49 :: SWord1 = choose [52:52] s11-  s50 :: SBool = s13 /= s49-  s51 :: SBool = ~ s50-  s52 :: SBool = if s14 then s51 else s50-  s53 :: SBool = ~ s52-  s54 :: SBool = if s36 then s53 else s52-  s55 :: SWord1 = choose [51:51] s11-  s56 :: SBool = s13 /= s55-  s57 :: SBool = ~ s56-  s58 :: SBool = if s16 then s57 else s56-  s59 :: SBool = ~ s58-  s60 :: SBool = if s40 then s59 else s58-  s61 :: SWord1 = choose [50:50] s11-  s62 :: SBool = s13 /= s61-  s63 :: SBool = ~ s62-  s64 :: SBool = if s18 then s63 else s62-  s65 :: SBool = ~ s64-  s66 :: SBool = if s44 then s65 else s64-  s67 :: SWord1 = choose [49:49] s11-  s68 :: SBool = s13 /= s67-  s69 :: SBool = ~ s68-  s70 :: SBool = if s20 then s69 else s68-  s71 :: SBool = ~ s70-  s72 :: SBool = if s48 then s71 else s70-  s73 :: SWord1 = choose [48:48] s11-  s74 :: SBool = s13 /= s73-  s75 :: SBool = ~ s74-  s76 :: SBool = if s24 then s75 else s74-  s77 :: SBool = ~ s76-  s78 :: SBool = if s54 then s77 else s76-  s79 :: SWord1 = choose [47:47] s11-  s80 :: SBool = s13 /= s79-  s81 :: SBool = ~ s80-  s82 :: SBool = if s14 then s81 else s80-  s83 :: SBool = ~ s82-  s84 :: SBool = if s28 then s83 else s82-  s85 :: SBool = ~ s84-  s86 :: SBool = if s60 then s85 else s84-  s87 :: SWord1 = choose [46:46] s11-  s88 :: SBool = s13 /= s87-  s89 :: SBool = ~ s88-  s90 :: SBool = if s16 then s89 else s88-  s91 :: SBool = ~ s90-  s92 :: SBool = if s32 then s91 else s90-  s93 :: SBool = ~ s92-  s94 :: SBool = if s66 then s93 else s92-  s95 :: SWord1 = choose [45:45] s11-  s96 :: SBool = s13 /= s95-  s97 :: SBool = ~ s96-  s98 :: SBool = if s18 then s97 else s96-  s99 :: SBool = ~ s98-  s100 :: SBool = if s36 then s99 else s98-  s101 :: SBool = ~ s100-  s102 :: SBool = if s72 then s101 else s100-  s103 :: SWord1 = choose [44:44] s11-  s104 :: SBool = s13 /= s103-  s105 :: SBool = ~ s104-  s106 :: SBool = if s20 then s105 else s104-  s107 :: SBool = ~ s106-  s108 :: SBool = if s40 then s107 else s106-  s109 :: SBool = ~ s108-  s110 :: SBool = if s78 then s109 else s108-  s111 :: SWord1 = choose [43:43] s11-  s112 :: SBool = s13 /= s111-  s113 :: SBool = ~ s112-  s114 :: SBool = if s24 then s113 else s112-  s115 :: SBool = ~ s114-  s116 :: SBool = if s44 then s115 else s114-  s117 :: SBool = ~ s116-  s118 :: SBool = if s86 then s117 else s116-  s119 :: SWord1 = choose [42:42] s11-  s120 :: SBool = s13 /= s119-  s121 :: SBool = ~ s120-  s122 :: SBool = if s28 then s121 else s120-  s123 :: SBool = ~ s122-  s124 :: SBool = if s48 then s123 else s122-  s125 :: SBool = ~ s124-  s126 :: SBool = if s94 then s125 else s124-  s127 :: SWord1 = choose [41:41] s11-  s128 :: SBool = s13 /= s127-  s129 :: SBool = ~ s128-  s130 :: SBool = if s32 then s129 else s128-  s131 :: SBool = ~ s130-  s132 :: SBool = if s54 then s131 else s130-  s133 :: SBool = ~ s132-  s134 :: SBool = if s102 then s133 else s132-  s135 :: SWord1 = choose [40:40] s11-  s136 :: SBool = s13 /= s135-  s137 :: SBool = ~ s136-  s138 :: SBool = if s36 then s137 else s136-  s139 :: SBool = ~ s138-  s140 :: SBool = if s60 then s139 else s138-  s141 :: SBool = ~ s140-  s142 :: SBool = if s110 then s141 else s140-  s143 :: SWord1 = choose [39:39] s11-  s144 :: SBool = s13 /= s143-  s145 :: SBool = ~ s144-  s146 :: SBool = if s40 then s145 else s144-  s147 :: SBool = ~ s146-  s148 :: SBool = if s66 then s147 else s146-  s149 :: SBool = ~ s148-  s150 :: SBool = if s118 then s149 else s148-  s151 :: SWord1 = choose [38:38] s11-  s152 :: SBool = s13 /= s151-  s153 :: SBool = ~ s152-  s154 :: SBool = if s44 then s153 else s152-  s155 :: SBool = ~ s154-  s156 :: SBool = if s72 then s155 else s154-  s157 :: SBool = ~ s156-  s158 :: SBool = if s126 then s157 else s156-  s159 :: SWord1 = choose [37:37] s11-  s160 :: SBool = s13 /= s159-  s161 :: SBool = ~ s160-  s162 :: SBool = if s48 then s161 else s160-  s163 :: SBool = ~ s162-  s164 :: SBool = if s78 then s163 else s162-  s165 :: SBool = ~ s164-  s166 :: SBool = if s134 then s165 else s164-  s167 :: SWord1 = choose [36:36] s11-  s168 :: SBool = s13 /= s167-  s169 :: SBool = ~ s168-  s170 :: SBool = if s54 then s169 else s168-  s171 :: SBool = ~ s170-  s172 :: SBool = if s86 then s171 else s170-  s173 :: SBool = ~ s172-  s174 :: SBool = if s142 then s173 else s172-  s175 :: SWord1 = choose [35:35] s11-  s176 :: SBool = s13 /= s175-  s177 :: SBool = ~ s176-  s178 :: SBool = if s60 then s177 else s176-  s179 :: SBool = ~ s178-  s180 :: SBool = if s94 then s179 else s178-  s181 :: SBool = ~ s180-  s182 :: SBool = if s150 then s181 else s180-  s183 :: SWord1 = choose [34:34] s11-  s184 :: SBool = s13 /= s183-  s185 :: SBool = ~ s184-  s186 :: SBool = if s66 then s185 else s184-  s187 :: SBool = ~ s186-  s188 :: SBool = if s102 then s187 else s186-  s189 :: SBool = ~ s188-  s190 :: SBool = if s158 then s189 else s188-  s191 :: SWord1 = choose [33:33] s11-  s192 :: SBool = s13 /= s191-  s193 :: SBool = ~ s192-  s194 :: SBool = if s72 then s193 else s192-  s195 :: SBool = ~ s194-  s196 :: SBool = if s110 then s195 else s194-  s197 :: SBool = ~ s196-  s198 :: SBool = if s166 then s197 else s196-  s199 :: SWord1 = choose [32:32] s11-  s200 :: SBool = s13 /= s199-  s201 :: SBool = ~ s200-  s202 :: SBool = if s78 then s201 else s200-  s203 :: SBool = ~ s202-  s204 :: SBool = if s118 then s203 else s202-  s205 :: SBool = ~ s204-  s206 :: SBool = if s174 then s205 else s204-  s207 :: SWord1 = choose [31:31] s11-  s208 :: SBool = s13 /= s207-  s209 :: SBool = ~ s208-  s210 :: SBool = if s86 then s209 else s208-  s211 :: SBool = ~ s210-  s212 :: SBool = if s126 then s211 else s210-  s213 :: SBool = ~ s212-  s214 :: SBool = if s182 then s213 else s212-  s215 :: SWord1 = choose [30:30] s11-  s216 :: SBool = s13 /= s215-  s217 :: SBool = ~ s216-  s218 :: SBool = if s94 then s217 else s216-  s219 :: SBool = ~ s218-  s220 :: SBool = if s134 then s219 else s218-  s221 :: SBool = ~ s220-  s222 :: SBool = if s190 then s221 else s220-  s223 :: SWord1 = choose [29:29] s11-  s224 :: SBool = s13 /= s223-  s225 :: SBool = ~ s224-  s226 :: SBool = if s102 then s225 else s224-  s227 :: SBool = ~ s226-  s228 :: SBool = if s142 then s227 else s226-  s229 :: SBool = ~ s228-  s230 :: SBool = if s198 then s229 else s228-  s231 :: SWord1 = choose [28:28] s11-  s232 :: SBool = s13 /= s231-  s233 :: SBool = ~ s232-  s234 :: SBool = if s110 then s233 else s232-  s235 :: SBool = ~ s234-  s236 :: SBool = if s150 then s235 else s234-  s237 :: SBool = ~ s236-  s238 :: SBool = if s206 then s237 else s236-  s239 :: SWord1 = choose [27:27] s11-  s240 :: SBool = s13 /= s239-  s241 :: SBool = ~ s240-  s242 :: SBool = if s118 then s241 else s240-  s243 :: SBool = ~ s242-  s244 :: SBool = if s158 then s243 else s242-  s245 :: SBool = ~ s244-  s246 :: SBool = if s214 then s245 else s244-  s247 :: SWord1 = choose [26:26] s11-  s248 :: SBool = s13 /= s247-  s249 :: SBool = ~ s248-  s250 :: SBool = if s126 then s249 else s248-  s251 :: SBool = ~ s250-  s252 :: SBool = if s166 then s251 else s250-  s253 :: SBool = ~ s252-  s254 :: SBool = if s222 then s253 else s252-  s255 :: SWord1 = choose [25:25] s11-  s256 :: SBool = s13 /= s255-  s257 :: SBool = ~ s256-  s258 :: SBool = if s134 then s257 else s256-  s259 :: SBool = ~ s258-  s260 :: SBool = if s174 then s259 else s258-  s261 :: SBool = ~ s260-  s262 :: SBool = if s230 then s261 else s260-  s263 :: SWord1 = choose [24:24] s11-  s264 :: SBool = s13 /= s263-  s265 :: SBool = ~ s264-  s266 :: SBool = if s142 then s265 else s264-  s267 :: SBool = ~ s266-  s268 :: SBool = if s182 then s267 else s266-  s269 :: SBool = ~ s268-  s270 :: SBool = if s238 then s269 else s268-  s271 :: SWord1 = choose [23:23] s11-  s272 :: SBool = s13 /= s271-  s273 :: SBool = ~ s272-  s274 :: SBool = if s150 then s273 else s272-  s275 :: SBool = ~ s274-  s276 :: SBool = if s190 then s275 else s274-  s277 :: SBool = ~ s276-  s278 :: SBool = if s246 then s277 else s276-  s279 :: SWord1 = choose [22:22] s11-  s280 :: SBool = s13 /= s279-  s281 :: SBool = ~ s280-  s282 :: SBool = if s158 then s281 else s280-  s283 :: SBool = ~ s282-  s284 :: SBool = if s198 then s283 else s282-  s285 :: SBool = ~ s284-  s286 :: SBool = if s254 then s285 else s284-  s287 :: SWord1 = choose [21:21] s11-  s288 :: SBool = s13 /= s287-  s289 :: SBool = ~ s288-  s290 :: SBool = if s166 then s289 else s288-  s291 :: SBool = ~ s290-  s292 :: SBool = if s206 then s291 else s290-  s293 :: SBool = ~ s292-  s294 :: SBool = if s262 then s293 else s292-  s295 :: SWord1 = choose [20:20] s11-  s296 :: SBool = s13 /= s295-  s297 :: SBool = ~ s296-  s298 :: SBool = if s174 then s297 else s296-  s299 :: SBool = ~ s298-  s300 :: SBool = if s214 then s299 else s298-  s301 :: SBool = ~ s300-  s302 :: SBool = if s270 then s301 else s300-  s303 :: SWord1 = choose [19:19] s11-  s304 :: SBool = s13 /= s303-  s305 :: SBool = ~ s304-  s306 :: SBool = if s182 then s305 else s304-  s307 :: SBool = ~ s306-  s308 :: SBool = if s222 then s307 else s306-  s309 :: SBool = ~ s308-  s310 :: SBool = if s278 then s309 else s308-  s311 :: SWord1 = choose [18:18] s11-  s312 :: SBool = s13 /= s311-  s313 :: SBool = ~ s312-  s314 :: SBool = if s190 then s313 else s312-  s315 :: SBool = ~ s314-  s316 :: SBool = if s230 then s315 else s314-  s317 :: SBool = ~ s316-  s318 :: SBool = if s286 then s317 else s316-  s319 :: SWord1 = choose [17:17] s11-  s320 :: SBool = s13 /= s319-  s321 :: SBool = ~ s320-  s322 :: SBool = if s198 then s321 else s320-  s323 :: SBool = ~ s322-  s324 :: SBool = if s238 then s323 else s322-  s325 :: SBool = ~ s324-  s326 :: SBool = if s294 then s325 else s324-  s327 :: SWord1 = choose [16:16] s11-  s328 :: SBool = s13 /= s327-  s329 :: SBool = ~ s328-  s330 :: SBool = if s206 then s329 else s328-  s331 :: SBool = ~ s330-  s332 :: SBool = if s246 then s331 else s330-  s333 :: SBool = ~ s332-  s334 :: SBool = if s302 then s333 else s332-  s335 :: SBool = ~ s14-  s336 :: SBool = if s14 then s335 else s14-  s337 :: SBool = ~ s16-  s338 :: SBool = if s16 then s337 else s16-  s339 :: SBool = ~ s18-  s340 :: SBool = if s18 then s339 else s18-  s341 :: SBool = ~ s20-  s342 :: SBool = if s20 then s341 else s20-  s343 :: SBool = ~ s24-  s344 :: SBool = if s24 then s343 else s24-  s345 :: SBool = ~ s28-  s346 :: SBool = if s28 then s345 else s28-  s347 :: SBool = ~ s32-  s348 :: SBool = if s32 then s347 else s32-  s349 :: SBool = ~ s36-  s350 :: SBool = if s36 then s349 else s36-  s351 :: SBool = ~ s40-  s352 :: SBool = if s40 then s351 else s40-  s353 :: SBool = ~ s44-  s354 :: SBool = if s44 then s353 else s44-  s355 :: SBool = ~ s48-  s356 :: SBool = if s48 then s355 else s48-  s357 :: SBool = ~ s54-  s358 :: SBool = if s54 then s357 else s54-  s359 :: SBool = ~ s60-  s360 :: SBool = if s60 then s359 else s60-  s361 :: SBool = ~ s66-  s362 :: SBool = if s66 then s361 else s66-  s363 :: SBool = ~ s72-  s364 :: SBool = if s72 then s363 else s72-  s365 :: SBool = ~ s78-  s366 :: SBool = if s78 then s365 else s78-  s367 :: SBool = ~ s86-  s368 :: SBool = if s86 then s367 else s86-  s369 :: SBool = ~ s94-  s370 :: SBool = if s94 then s369 else s94-  s371 :: SBool = ~ s102-  s372 :: SBool = if s102 then s371 else s102-  s373 :: SBool = ~ s110-  s374 :: SBool = if s110 then s373 else s110-  s375 :: SBool = ~ s118-  s376 :: SBool = if s118 then s375 else s118-  s377 :: SBool = ~ s126-  s378 :: SBool = if s126 then s377 else s126-  s379 :: SBool = ~ s134-  s380 :: SBool = if s134 then s379 else s134-  s381 :: SBool = ~ s142-  s382 :: SBool = if s142 then s381 else s142-  s383 :: SBool = ~ s150-  s384 :: SBool = if s150 then s383 else s150-  s385 :: SBool = ~ s158-  s386 :: SBool = if s158 then s385 else s158-  s387 :: SBool = ~ s166-  s388 :: SBool = if s166 then s387 else s166-  s389 :: SBool = ~ s174-  s390 :: SBool = if s174 then s389 else s174-  s391 :: SBool = ~ s182-  s392 :: SBool = if s182 then s391 else s182-  s393 :: SBool = ~ s190-  s394 :: SBool = if s190 then s393 else s190-  s395 :: SBool = ~ s198-  s396 :: SBool = if s198 then s395 else s198-  s397 :: SBool = ~ s206-  s398 :: SBool = if s206 then s397 else s206-  s399 :: SBool = ~ s214-  s400 :: SBool = if s214 then s399 else s214-  s401 :: SBool = ~ s222-  s402 :: SBool = if s222 then s401 else s222-  s403 :: SBool = ~ s230-  s404 :: SBool = if s230 then s403 else s230-  s405 :: SBool = ~ s238-  s406 :: SBool = if s238 then s405 else s238-  s407 :: SBool = ~ s246-  s408 :: SBool = if s246 then s407 else s246-  s409 :: SBool = ~ s254-  s410 :: SBool = if s254 then s409 else s254-  s411 :: SBool = ~ s262-  s412 :: SBool = if s262 then s411 else s262-  s413 :: SBool = ~ s270-  s414 :: SBool = if s270 then s413 else s270-  s415 :: SBool = ~ s278-  s416 :: SBool = if s278 then s415 else s278-  s417 :: SBool = ~ s286-  s418 :: SBool = if s286 then s417 else s286-  s419 :: SBool = ~ s294-  s420 :: SBool = if s294 then s419 else s294-  s421 :: SBool = ~ s302-  s422 :: SBool = if s302 then s421 else s302-  s423 :: SBool = ~ s310-  s424 :: SBool = if s310 then s423 else s310-  s425 :: SBool = ~ s318-  s426 :: SBool = if s318 then s425 else s318-  s427 :: SBool = ~ s326-  s428 :: SBool = if s326 then s427 else s326-  s429 :: SBool = ~ s334-  s430 :: SBool = if s334 then s429 else s334-  s431 :: SWord1 = choose [15:15] s11-  s432 :: SBool = s13 /= s431-  s433 :: SBool = ~ s432-  s434 :: SBool = if s214 then s433 else s432-  s435 :: SBool = ~ s434-  s436 :: SBool = if s254 then s435 else s434-  s437 :: SBool = ~ s436-  s438 :: SBool = if s310 then s437 else s436-  s439 :: SWord1 = choose [14:14] s11-  s440 :: SBool = s13 /= s439-  s441 :: SBool = ~ s440-  s442 :: SBool = if s222 then s441 else s440-  s443 :: SBool = ~ s442-  s444 :: SBool = if s262 then s443 else s442-  s445 :: SBool = ~ s444-  s446 :: SBool = if s318 then s445 else s444-  s447 :: SWord1 = choose [13:13] s11-  s448 :: SBool = s13 /= s447-  s449 :: SBool = ~ s448-  s450 :: SBool = if s230 then s449 else s448-  s451 :: SBool = ~ s450-  s452 :: SBool = if s270 then s451 else s450-  s453 :: SBool = ~ s452-  s454 :: SBool = if s326 then s453 else s452-  s455 :: SWord1 = choose [12:12] s11-  s456 :: SBool = s13 /= s455-  s457 :: SBool = ~ s456-  s458 :: SBool = if s238 then s457 else s456-  s459 :: SBool = ~ s458-  s460 :: SBool = if s278 then s459 else s458-  s461 :: SBool = ~ s460-  s462 :: SBool = if s334 then s461 else s460-  s463 :: SWord1 = choose [11:11] s11-  s464 :: SBool = s13 /= s463-  s465 :: SBool = ~ s464-  s466 :: SBool = if s246 then s465 else s464-  s467 :: SBool = ~ s466-  s468 :: SBool = if s286 then s467 else s466-  s469 :: SWord1 = choose [10:10] s11-  s470 :: SBool = s13 /= s469-  s471 :: SBool = ~ s470-  s472 :: SBool = if s254 then s471 else s470-  s473 :: SBool = ~ s472-  s474 :: SBool = if s294 then s473 else s472-  s475 :: SWord1 = choose [9:9] s11-  s476 :: SBool = s13 /= s475-  s477 :: SBool = ~ s476-  s478 :: SBool = if s262 then s477 else s476-  s479 :: SBool = ~ s478-  s480 :: SBool = if s302 then s479 else s478-  s481 :: SWord1 = choose [8:8] s11-  s482 :: SBool = s13 /= s481-  s483 :: SBool = ~ s482-  s484 :: SBool = if s270 then s483 else s482-  s485 :: SBool = ~ s484-  s486 :: SBool = if s310 then s485 else s484-  s487 :: SWord1 = choose [7:7] s11-  s488 :: SBool = s13 /= s487-  s489 :: SBool = ~ s488-  s490 :: SBool = if s278 then s489 else s488-  s491 :: SBool = ~ s490-  s492 :: SBool = if s318 then s491 else s490-  s493 :: SWord1 = choose [6:6] s11-  s494 :: SBool = s13 /= s493-  s495 :: SBool = ~ s494-  s496 :: SBool = if s286 then s495 else s494-  s497 :: SBool = ~ s496-  s498 :: SBool = if s326 then s497 else s496-  s499 :: SWord1 = choose [5:5] s11-  s500 :: SBool = s13 /= s499-  s501 :: SBool = ~ s500-  s502 :: SBool = if s294 then s501 else s500-  s503 :: SBool = ~ s502-  s504 :: SBool = if s334 then s503 else s502-  s505 :: SWord1 = choose [4:4] s11-  s506 :: SBool = s13 /= s505-  s507 :: SBool = ~ s506-  s508 :: SBool = if s302 then s507 else s506-  s509 :: SWord1 = choose [3:3] s11-  s510 :: SBool = s13 /= s509-  s511 :: SBool = ~ s510-  s512 :: SBool = if s310 then s511 else s510-  s513 :: SWord1 = choose [2:2] s11-  s514 :: SBool = s13 /= s513-  s515 :: SBool = ~ s514-  s516 :: SBool = if s318 then s515 else s514-  s517 :: SWord1 = choose [1:1] s11-  s518 :: SBool = s13 /= s517-  s519 :: SBool = ~ s518-  s520 :: SBool = if s326 then s519 else s518-  s521 :: SWord1 = choose [0:0] s11-  s522 :: SBool = s13 /= s521-  s523 :: SBool = ~ s522-  s524 :: SBool = if s334 then s523 else s522-  s527 :: SWord64 = if s524 then s525 else s526-  s529 :: SWord64 = s527 | s528-  s530 :: SWord64 = if s520 then s529 else s527-  s532 :: SWord64 = s530 | s531-  s533 :: SWord64 = if s516 then s532 else s530-  s535 :: SWord64 = s533 | s534-  s536 :: SWord64 = if s512 then s535 else s533-  s538 :: SWord64 = s536 | s537-  s539 :: SWord64 = if s508 then s538 else s536-  s541 :: SWord64 = s539 | s540-  s542 :: SWord64 = if s504 then s541 else s539-  s544 :: SWord64 = s542 | s543-  s545 :: SWord64 = if s498 then s544 else s542-  s547 :: SWord64 = s545 | s546-  s548 :: SWord64 = if s492 then s547 else s545-  s550 :: SWord64 = s548 | s549-  s551 :: SWord64 = if s486 then s550 else s548-  s553 :: SWord64 = s551 | s552-  s554 :: SWord64 = if s480 then s553 else s551-  s556 :: SWord64 = s554 | s555-  s557 :: SWord64 = if s474 then s556 else s554-  s559 :: SWord64 = s557 | s558-  s560 :: SWord64 = if s468 then s559 else s557-  s562 :: SWord64 = s560 | s561-  s563 :: SWord64 = if s462 then s562 else s560-  s565 :: SWord64 = s563 | s564-  s566 :: SWord64 = if s454 then s565 else s563-  s568 :: SWord64 = s566 | s567-  s569 :: SWord64 = if s446 then s568 else s566-  s571 :: SWord64 = s569 | s570-  s572 :: SWord64 = if s438 then s571 else s569-  s574 :: SWord64 = s572 | s573-  s575 :: SWord64 = if s430 then s574 else s572-  s577 :: SWord64 = s575 | s576-  s578 :: SWord64 = if s428 then s577 else s575-  s580 :: SWord64 = s578 | s579-  s581 :: SWord64 = if s426 then s580 else s578-  s583 :: SWord64 = s581 | s582-  s584 :: SWord64 = if s424 then s583 else s581-  s586 :: SWord64 = s584 | s585-  s587 :: SWord64 = if s422 then s586 else s584-  s589 :: SWord64 = s587 | s588-  s590 :: SWord64 = if s420 then s589 else s587-  s592 :: SWord64 = s590 | s591-  s593 :: SWord64 = if s418 then s592 else s590-  s595 :: SWord64 = s593 | s594-  s596 :: SWord64 = if s416 then s595 else s593-  s598 :: SWord64 = s596 | s597-  s599 :: SWord64 = if s414 then s598 else s596-  s601 :: SWord64 = s599 | s600-  s602 :: SWord64 = if s412 then s601 else s599-  s604 :: SWord64 = s602 | s603-  s605 :: SWord64 = if s410 then s604 else s602-  s607 :: SWord64 = s605 | s606-  s608 :: SWord64 = if s408 then s607 else s605-  s610 :: SWord64 = s608 | s609-  s611 :: SWord64 = if s406 then s610 else s608-  s613 :: SWord64 = s611 | s612-  s614 :: SWord64 = if s404 then s613 else s611-  s616 :: SWord64 = s614 | s615-  s617 :: SWord64 = if s402 then s616 else s614-  s619 :: SWord64 = s617 | s618-  s620 :: SWord64 = if s400 then s619 else s617-  s622 :: SWord64 = s620 | s621-  s623 :: SWord64 = if s398 then s622 else s620-  s625 :: SWord64 = s623 | s624-  s626 :: SWord64 = if s396 then s625 else s623-  s628 :: SWord64 = s626 | s627-  s629 :: SWord64 = if s394 then s628 else s626-  s631 :: SWord64 = s629 | s630-  s632 :: SWord64 = if s392 then s631 else s629-  s634 :: SWord64 = s632 | s633-  s635 :: SWord64 = if s390 then s634 else s632-  s637 :: SWord64 = s635 | s636-  s638 :: SWord64 = if s388 then s637 else s635-  s640 :: SWord64 = s638 | s639-  s641 :: SWord64 = if s386 then s640 else s638-  s643 :: SWord64 = s641 | s642-  s644 :: SWord64 = if s384 then s643 else s641-  s646 :: SWord64 = s644 | s645-  s647 :: SWord64 = if s382 then s646 else s644-  s649 :: SWord64 = s647 | s648-  s650 :: SWord64 = if s380 then s649 else s647-  s652 :: SWord64 = s650 | s651-  s653 :: SWord64 = if s378 then s652 else s650-  s655 :: SWord64 = s653 | s654-  s656 :: SWord64 = if s376 then s655 else s653-  s658 :: SWord64 = s656 | s657-  s659 :: SWord64 = if s374 then s658 else s656-  s661 :: SWord64 = s659 | s660-  s662 :: SWord64 = if s372 then s661 else s659-  s664 :: SWord64 = s662 | s663-  s665 :: SWord64 = if s370 then s664 else s662-  s667 :: SWord64 = s665 | s666-  s668 :: SWord64 = if s368 then s667 else s665-  s670 :: SWord64 = s668 | s669-  s671 :: SWord64 = if s366 then s670 else s668-  s673 :: SWord64 = s671 | s672-  s674 :: SWord64 = if s364 then s673 else s671-  s676 :: SWord64 = s674 | s675-  s677 :: SWord64 = if s362 then s676 else s674-  s679 :: SWord64 = s677 | s678-  s680 :: SWord64 = if s360 then s679 else s677-  s682 :: SWord64 = s680 | s681-  s683 :: SWord64 = if s358 then s682 else s680-  s685 :: SWord64 = s683 | s684-  s686 :: SWord64 = if s356 then s685 else s683-  s688 :: SWord64 = s686 | s687-  s689 :: SWord64 = if s354 then s688 else s686-  s691 :: SWord64 = s689 | s690-  s692 :: SWord64 = if s352 then s691 else s689-  s694 :: SWord64 = s692 | s693-  s695 :: SWord64 = if s350 then s694 else s692-  s697 :: SWord64 = s695 | s696-  s698 :: SWord64 = if s348 then s697 else s695-  s700 :: SWord64 = s698 | s699-  s701 :: SWord64 = if s346 then s700 else s698-  s703 :: SWord64 = s701 | s702-  s704 :: SWord64 = if s344 then s703 else s701-  s706 :: SWord64 = s704 | s705-  s707 :: SWord64 = if s342 then s706 else s704-  s709 :: SWord64 = s707 | s708-  s710 :: SWord64 = if s340 then s709 else s707-  s712 :: SWord64 = s710 | s711-  s713 :: SWord64 = if s338 then s712 else s710-  s715 :: SWord64 = s713 | s714-  s716 :: SWord64 = if s336 then s715 else s713-  s717 :: SWord32 = choose [31:0] s716-  s718 :: SWord16 = choose [15:0] s717-  s719 :: SWord32 = s1 # s718-  s720 :: SWord64 = s0 # s719-  s721 :: SWord1 = choose [0:0] s720-  s722 :: SBool = s13 /= s721-  s723 :: SWord32 = s3 # s9-  s724 :: SWord64 = s2 # s723-  s725 :: SWord1 = choose [63:63] s724-  s726 :: SBool = s13 /= s725-  s727 :: SWord1 = choose [62:62] s724-  s728 :: SBool = s13 /= s727-  s729 :: SWord1 = choose [61:61] s724-  s730 :: SBool = s13 /= s729-  s731 :: SWord1 = choose [60:60] s724-  s732 :: SBool = s13 /= s731-  s733 :: SWord1 = choose [59:59] s724-  s734 :: SBool = s13 /= s733-  s735 :: SBool = ~ s734-  s736 :: SBool = if s726 then s735 else s734-  s737 :: SWord1 = choose [58:58] s724-  s738 :: SBool = s13 /= s737-  s739 :: SBool = ~ s738-  s740 :: SBool = if s728 then s739 else s738-  s741 :: SWord1 = choose [57:57] s724-  s742 :: SBool = s13 /= s741-  s743 :: SBool = ~ s742-  s744 :: SBool = if s730 then s743 else s742-  s745 :: SWord1 = choose [56:56] s724-  s746 :: SBool = s13 /= s745-  s747 :: SBool = ~ s746-  s748 :: SBool = if s732 then s747 else s746-  s749 :: SWord1 = choose [55:55] s724-  s750 :: SBool = s13 /= s749-  s751 :: SBool = ~ s750-  s752 :: SBool = if s736 then s751 else s750-  s753 :: SWord1 = choose [54:54] s724-  s754 :: SBool = s13 /= s753-  s755 :: SBool = ~ s754-  s756 :: SBool = if s740 then s755 else s754-  s757 :: SWord1 = choose [53:53] s724-  s758 :: SBool = s13 /= s757-  s759 :: SBool = ~ s758-  s760 :: SBool = if s744 then s759 else s758-  s761 :: SWord1 = choose [52:52] s724-  s762 :: SBool = s13 /= s761-  s763 :: SBool = ~ s762-  s764 :: SBool = if s726 then s763 else s762-  s765 :: SBool = ~ s764-  s766 :: SBool = if s748 then s765 else s764-  s767 :: SWord1 = choose [51:51] s724-  s768 :: SBool = s13 /= s767-  s769 :: SBool = ~ s768-  s770 :: SBool = if s728 then s769 else s768-  s771 :: SBool = ~ s770-  s772 :: SBool = if s752 then s771 else s770-  s773 :: SWord1 = choose [50:50] s724-  s774 :: SBool = s13 /= s773-  s775 :: SBool = ~ s774-  s776 :: SBool = if s730 then s775 else s774-  s777 :: SBool = ~ s776-  s778 :: SBool = if s756 then s777 else s776-  s779 :: SWord1 = choose [49:49] s724-  s780 :: SBool = s13 /= s779-  s781 :: SBool = ~ s780-  s782 :: SBool = if s732 then s781 else s780-  s783 :: SBool = ~ s782-  s784 :: SBool = if s760 then s783 else s782-  s785 :: SWord1 = choose [48:48] s724-  s786 :: SBool = s13 /= s785-  s787 :: SBool = ~ s786-  s788 :: SBool = if s736 then s787 else s786-  s789 :: SBool = ~ s788-  s790 :: SBool = if s766 then s789 else s788-  s791 :: SWord1 = choose [47:47] s724-  s792 :: SBool = s13 /= s791-  s793 :: SBool = ~ s792-  s794 :: SBool = if s726 then s793 else s792-  s795 :: SBool = ~ s794-  s796 :: SBool = if s740 then s795 else s794-  s797 :: SBool = ~ s796-  s798 :: SBool = if s772 then s797 else s796-  s799 :: SWord1 = choose [46:46] s724-  s800 :: SBool = s13 /= s799-  s801 :: SBool = ~ s800-  s802 :: SBool = if s728 then s801 else s800-  s803 :: SBool = ~ s802-  s804 :: SBool = if s744 then s803 else s802-  s805 :: SBool = ~ s804-  s806 :: SBool = if s778 then s805 else s804-  s807 :: SWord1 = choose [45:45] s724-  s808 :: SBool = s13 /= s807-  s809 :: SBool = ~ s808-  s810 :: SBool = if s730 then s809 else s808-  s811 :: SBool = ~ s810-  s812 :: SBool = if s748 then s811 else s810-  s813 :: SBool = ~ s812-  s814 :: SBool = if s784 then s813 else s812-  s815 :: SWord1 = choose [44:44] s724-  s816 :: SBool = s13 /= s815-  s817 :: SBool = ~ s816-  s818 :: SBool = if s732 then s817 else s816-  s819 :: SBool = ~ s818-  s820 :: SBool = if s752 then s819 else s818-  s821 :: SBool = ~ s820-  s822 :: SBool = if s790 then s821 else s820-  s823 :: SWord1 = choose [43:43] s724-  s824 :: SBool = s13 /= s823-  s825 :: SBool = ~ s824-  s826 :: SBool = if s736 then s825 else s824-  s827 :: SBool = ~ s826-  s828 :: SBool = if s756 then s827 else s826-  s829 :: SBool = ~ s828-  s830 :: SBool = if s798 then s829 else s828-  s831 :: SWord1 = choose [42:42] s724-  s832 :: SBool = s13 /= s831-  s833 :: SBool = ~ s832-  s834 :: SBool = if s740 then s833 else s832-  s835 :: SBool = ~ s834-  s836 :: SBool = if s760 then s835 else s834-  s837 :: SBool = ~ s836-  s838 :: SBool = if s806 then s837 else s836-  s839 :: SWord1 = choose [41:41] s724-  s840 :: SBool = s13 /= s839-  s841 :: SBool = ~ s840-  s842 :: SBool = if s744 then s841 else s840-  s843 :: SBool = ~ s842-  s844 :: SBool = if s766 then s843 else s842-  s845 :: SBool = ~ s844-  s846 :: SBool = if s814 then s845 else s844-  s847 :: SWord1 = choose [40:40] s724-  s848 :: SBool = s13 /= s847-  s849 :: SBool = ~ s848-  s850 :: SBool = if s748 then s849 else s848-  s851 :: SBool = ~ s850-  s852 :: SBool = if s772 then s851 else s850-  s853 :: SBool = ~ s852-  s854 :: SBool = if s822 then s853 else s852-  s855 :: SWord1 = choose [39:39] s724-  s856 :: SBool = s13 /= s855-  s857 :: SBool = ~ s856-  s858 :: SBool = if s752 then s857 else s856-  s859 :: SBool = ~ s858-  s860 :: SBool = if s778 then s859 else s858-  s861 :: SBool = ~ s860-  s862 :: SBool = if s830 then s861 else s860-  s863 :: SWord1 = choose [38:38] s724-  s864 :: SBool = s13 /= s863-  s865 :: SBool = ~ s864-  s866 :: SBool = if s756 then s865 else s864-  s867 :: SBool = ~ s866-  s868 :: SBool = if s784 then s867 else s866-  s869 :: SBool = ~ s868-  s870 :: SBool = if s838 then s869 else s868-  s871 :: SWord1 = choose [37:37] s724-  s872 :: SBool = s13 /= s871-  s873 :: SBool = ~ s872-  s874 :: SBool = if s760 then s873 else s872-  s875 :: SBool = ~ s874-  s876 :: SBool = if s790 then s875 else s874-  s877 :: SBool = ~ s876-  s878 :: SBool = if s846 then s877 else s876-  s879 :: SWord1 = choose [36:36] s724-  s880 :: SBool = s13 /= s879-  s881 :: SBool = ~ s880-  s882 :: SBool = if s766 then s881 else s880-  s883 :: SBool = ~ s882-  s884 :: SBool = if s798 then s883 else s882-  s885 :: SBool = ~ s884-  s886 :: SBool = if s854 then s885 else s884-  s887 :: SWord1 = choose [35:35] s724-  s888 :: SBool = s13 /= s887-  s889 :: SBool = ~ s888-  s890 :: SBool = if s772 then s889 else s888-  s891 :: SBool = ~ s890-  s892 :: SBool = if s806 then s891 else s890-  s893 :: SBool = ~ s892-  s894 :: SBool = if s862 then s893 else s892-  s895 :: SWord1 = choose [34:34] s724-  s896 :: SBool = s13 /= s895-  s897 :: SBool = ~ s896-  s898 :: SBool = if s778 then s897 else s896-  s899 :: SBool = ~ s898-  s900 :: SBool = if s814 then s899 else s898-  s901 :: SBool = ~ s900-  s902 :: SBool = if s870 then s901 else s900-  s903 :: SWord1 = choose [33:33] s724-  s904 :: SBool = s13 /= s903-  s905 :: SBool = ~ s904-  s906 :: SBool = if s784 then s905 else s904-  s907 :: SBool = ~ s906-  s908 :: SBool = if s822 then s907 else s906-  s909 :: SBool = ~ s908-  s910 :: SBool = if s878 then s909 else s908-  s911 :: SWord1 = choose [32:32] s724-  s912 :: SBool = s13 /= s911-  s913 :: SBool = ~ s912-  s914 :: SBool = if s790 then s913 else s912-  s915 :: SBool = ~ s914-  s916 :: SBool = if s830 then s915 else s914-  s917 :: SBool = ~ s916-  s918 :: SBool = if s886 then s917 else s916-  s919 :: SWord1 = choose [31:31] s724-  s920 :: SBool = s13 /= s919-  s921 :: SBool = ~ s920-  s922 :: SBool = if s798 then s921 else s920-  s923 :: SBool = ~ s922-  s924 :: SBool = if s838 then s923 else s922-  s925 :: SBool = ~ s924-  s926 :: SBool = if s894 then s925 else s924-  s927 :: SWord1 = choose [30:30] s724-  s928 :: SBool = s13 /= s927-  s929 :: SBool = ~ s928-  s930 :: SBool = if s806 then s929 else s928-  s931 :: SBool = ~ s930-  s932 :: SBool = if s846 then s931 else s930-  s933 :: SBool = ~ s932-  s934 :: SBool = if s902 then s933 else s932-  s935 :: SWord1 = choose [29:29] s724-  s936 :: SBool = s13 /= s935-  s937 :: SBool = ~ s936-  s938 :: SBool = if s814 then s937 else s936-  s939 :: SBool = ~ s938-  s940 :: SBool = if s854 then s939 else s938-  s941 :: SBool = ~ s940-  s942 :: SBool = if s910 then s941 else s940-  s943 :: SWord1 = choose [28:28] s724-  s944 :: SBool = s13 /= s943-  s945 :: SBool = ~ s944-  s946 :: SBool = if s822 then s945 else s944-  s947 :: SBool = ~ s946-  s948 :: SBool = if s862 then s947 else s946-  s949 :: SBool = ~ s948-  s950 :: SBool = if s918 then s949 else s948-  s951 :: SWord1 = choose [27:27] s724-  s952 :: SBool = s13 /= s951-  s953 :: SBool = ~ s952-  s954 :: SBool = if s830 then s953 else s952-  s955 :: SBool = ~ s954-  s956 :: SBool = if s870 then s955 else s954-  s957 :: SBool = ~ s956-  s958 :: SBool = if s926 then s957 else s956-  s959 :: SWord1 = choose [26:26] s724-  s960 :: SBool = s13 /= s959-  s961 :: SBool = ~ s960-  s962 :: SBool = if s838 then s961 else s960-  s963 :: SBool = ~ s962-  s964 :: SBool = if s878 then s963 else s962-  s965 :: SBool = ~ s964-  s966 :: SBool = if s934 then s965 else s964-  s967 :: SWord1 = choose [25:25] s724-  s968 :: SBool = s13 /= s967-  s969 :: SBool = ~ s968-  s970 :: SBool = if s846 then s969 else s968-  s971 :: SBool = ~ s970-  s972 :: SBool = if s886 then s971 else s970-  s973 :: SBool = ~ s972-  s974 :: SBool = if s942 then s973 else s972-  s975 :: SWord1 = choose [24:24] s724-  s976 :: SBool = s13 /= s975-  s977 :: SBool = ~ s976-  s978 :: SBool = if s854 then s977 else s976-  s979 :: SBool = ~ s978-  s980 :: SBool = if s894 then s979 else s978-  s981 :: SBool = ~ s980-  s982 :: SBool = if s950 then s981 else s980-  s983 :: SWord1 = choose [23:23] s724-  s984 :: SBool = s13 /= s983-  s985 :: SBool = ~ s984-  s986 :: SBool = if s862 then s985 else s984-  s987 :: SBool = ~ s986-  s988 :: SBool = if s902 then s987 else s986-  s989 :: SBool = ~ s988-  s990 :: SBool = if s958 then s989 else s988-  s991 :: SWord1 = choose [22:22] s724-  s992 :: SBool = s13 /= s991-  s993 :: SBool = ~ s992-  s994 :: SBool = if s870 then s993 else s992-  s995 :: SBool = ~ s994-  s996 :: SBool = if s910 then s995 else s994-  s997 :: SBool = ~ s996-  s998 :: SBool = if s966 then s997 else s996-  s999 :: SWord1 = choose [21:21] s724-  s1000 :: SBool = s13 /= s999-  s1001 :: SBool = ~ s1000-  s1002 :: SBool = if s878 then s1001 else s1000-  s1003 :: SBool = ~ s1002-  s1004 :: SBool = if s918 then s1003 else s1002-  s1005 :: SBool = ~ s1004-  s1006 :: SBool = if s974 then s1005 else s1004-  s1007 :: SWord1 = choose [20:20] s724-  s1008 :: SBool = s13 /= s1007-  s1009 :: SBool = ~ s1008-  s1010 :: SBool = if s886 then s1009 else s1008-  s1011 :: SBool = ~ s1010-  s1012 :: SBool = if s926 then s1011 else s1010-  s1013 :: SBool = ~ s1012-  s1014 :: SBool = if s982 then s1013 else s1012-  s1015 :: SWord1 = choose [19:19] s724-  s1016 :: SBool = s13 /= s1015-  s1017 :: SBool = ~ s1016-  s1018 :: SBool = if s894 then s1017 else s1016-  s1019 :: SBool = ~ s1018-  s1020 :: SBool = if s934 then s1019 else s1018-  s1021 :: SBool = ~ s1020-  s1022 :: SBool = if s990 then s1021 else s1020-  s1023 :: SWord1 = choose [18:18] s724-  s1024 :: SBool = s13 /= s1023-  s1025 :: SBool = ~ s1024-  s1026 :: SBool = if s902 then s1025 else s1024-  s1027 :: SBool = ~ s1026-  s1028 :: SBool = if s942 then s1027 else s1026-  s1029 :: SBool = ~ s1028-  s1030 :: SBool = if s998 then s1029 else s1028-  s1031 :: SWord1 = choose [17:17] s724-  s1032 :: SBool = s13 /= s1031-  s1033 :: SBool = ~ s1032-  s1034 :: SBool = if s910 then s1033 else s1032-  s1035 :: SBool = ~ s1034-  s1036 :: SBool = if s950 then s1035 else s1034-  s1037 :: SBool = ~ s1036-  s1038 :: SBool = if s1006 then s1037 else s1036-  s1039 :: SWord1 = choose [16:16] s724-  s1040 :: SBool = s13 /= s1039-  s1041 :: SBool = ~ s1040-  s1042 :: SBool = if s918 then s1041 else s1040-  s1043 :: SBool = ~ s1042-  s1044 :: SBool = if s958 then s1043 else s1042-  s1045 :: SBool = ~ s1044-  s1046 :: SBool = if s1014 then s1045 else s1044-  s1047 :: SBool = ~ s726-  s1048 :: SBool = if s726 then s1047 else s726-  s1049 :: SBool = ~ s728-  s1050 :: SBool = if s728 then s1049 else s728-  s1051 :: SBool = ~ s730-  s1052 :: SBool = if s730 then s1051 else s730-  s1053 :: SBool = ~ s732-  s1054 :: SBool = if s732 then s1053 else s732-  s1055 :: SBool = ~ s736-  s1056 :: SBool = if s736 then s1055 else s736-  s1057 :: SBool = ~ s740-  s1058 :: SBool = if s740 then s1057 else s740-  s1059 :: SBool = ~ s744-  s1060 :: SBool = if s744 then s1059 else s744-  s1061 :: SBool = ~ s748-  s1062 :: SBool = if s748 then s1061 else s748-  s1063 :: SBool = ~ s752-  s1064 :: SBool = if s752 then s1063 else s752-  s1065 :: SBool = ~ s756-  s1066 :: SBool = if s756 then s1065 else s756-  s1067 :: SBool = ~ s760-  s1068 :: SBool = if s760 then s1067 else s760-  s1069 :: SBool = ~ s766-  s1070 :: SBool = if s766 then s1069 else s766-  s1071 :: SBool = ~ s772-  s1072 :: SBool = if s772 then s1071 else s772-  s1073 :: SBool = ~ s778-  s1074 :: SBool = if s778 then s1073 else s778-  s1075 :: SBool = ~ s784-  s1076 :: SBool = if s784 then s1075 else s784-  s1077 :: SBool = ~ s790-  s1078 :: SBool = if s790 then s1077 else s790-  s1079 :: SBool = ~ s798-  s1080 :: SBool = if s798 then s1079 else s798-  s1081 :: SBool = ~ s806-  s1082 :: SBool = if s806 then s1081 else s806-  s1083 :: SBool = ~ s814-  s1084 :: SBool = if s814 then s1083 else s814-  s1085 :: SBool = ~ s822-  s1086 :: SBool = if s822 then s1085 else s822-  s1087 :: SBool = ~ s830-  s1088 :: SBool = if s830 then s1087 else s830-  s1089 :: SBool = ~ s838-  s1090 :: SBool = if s838 then s1089 else s838-  s1091 :: SBool = ~ s846-  s1092 :: SBool = if s846 then s1091 else s846-  s1093 :: SBool = ~ s854-  s1094 :: SBool = if s854 then s1093 else s854-  s1095 :: SBool = ~ s862-  s1096 :: SBool = if s862 then s1095 else s862-  s1097 :: SBool = ~ s870-  s1098 :: SBool = if s870 then s1097 else s870-  s1099 :: SBool = ~ s878-  s1100 :: SBool = if s878 then s1099 else s878-  s1101 :: SBool = ~ s886-  s1102 :: SBool = if s886 then s1101 else s886-  s1103 :: SBool = ~ s894-  s1104 :: SBool = if s894 then s1103 else s894-  s1105 :: SBool = ~ s902-  s1106 :: SBool = if s902 then s1105 else s902-  s1107 :: SBool = ~ s910-  s1108 :: SBool = if s910 then s1107 else s910-  s1109 :: SBool = ~ s918-  s1110 :: SBool = if s918 then s1109 else s918-  s1111 :: SBool = ~ s926-  s1112 :: SBool = if s926 then s1111 else s926-  s1113 :: SBool = ~ s934-  s1114 :: SBool = if s934 then s1113 else s934-  s1115 :: SBool = ~ s942-  s1116 :: SBool = if s942 then s1115 else s942-  s1117 :: SBool = ~ s950-  s1118 :: SBool = if s950 then s1117 else s950-  s1119 :: SBool = ~ s958-  s1120 :: SBool = if s958 then s1119 else s958-  s1121 :: SBool = ~ s966-  s1122 :: SBool = if s966 then s1121 else s966-  s1123 :: SBool = ~ s974-  s1124 :: SBool = if s974 then s1123 else s974-  s1125 :: SBool = ~ s982-  s1126 :: SBool = if s982 then s1125 else s982-  s1127 :: SBool = ~ s990-  s1128 :: SBool = if s990 then s1127 else s990-  s1129 :: SBool = ~ s998-  s1130 :: SBool = if s998 then s1129 else s998-  s1131 :: SBool = ~ s1006-  s1132 :: SBool = if s1006 then s1131 else s1006-  s1133 :: SBool = ~ s1014-  s1134 :: SBool = if s1014 then s1133 else s1014-  s1135 :: SBool = ~ s1022-  s1136 :: SBool = if s1022 then s1135 else s1022-  s1137 :: SBool = ~ s1030-  s1138 :: SBool = if s1030 then s1137 else s1030-  s1139 :: SBool = ~ s1038-  s1140 :: SBool = if s1038 then s1139 else s1038-  s1141 :: SBool = ~ s1046-  s1142 :: SBool = if s1046 then s1141 else s1046-  s1143 :: SWord1 = choose [15:15] s724-  s1144 :: SBool = s13 /= s1143-  s1145 :: SBool = ~ s1144-  s1146 :: SBool = if s926 then s1145 else s1144-  s1147 :: SBool = ~ s1146-  s1148 :: SBool = if s966 then s1147 else s1146-  s1149 :: SBool = ~ s1148-  s1150 :: SBool = if s1022 then s1149 else s1148-  s1151 :: SWord1 = choose [14:14] s724-  s1152 :: SBool = s13 /= s1151-  s1153 :: SBool = ~ s1152-  s1154 :: SBool = if s934 then s1153 else s1152-  s1155 :: SBool = ~ s1154-  s1156 :: SBool = if s974 then s1155 else s1154-  s1157 :: SBool = ~ s1156-  s1158 :: SBool = if s1030 then s1157 else s1156-  s1159 :: SWord1 = choose [13:13] s724-  s1160 :: SBool = s13 /= s1159-  s1161 :: SBool = ~ s1160-  s1162 :: SBool = if s942 then s1161 else s1160-  s1163 :: SBool = ~ s1162-  s1164 :: SBool = if s982 then s1163 else s1162-  s1165 :: SBool = ~ s1164-  s1166 :: SBool = if s1038 then s1165 else s1164-  s1167 :: SWord1 = choose [12:12] s724-  s1168 :: SBool = s13 /= s1167-  s1169 :: SBool = ~ s1168-  s1170 :: SBool = if s950 then s1169 else s1168-  s1171 :: SBool = ~ s1170-  s1172 :: SBool = if s990 then s1171 else s1170-  s1173 :: SBool = ~ s1172-  s1174 :: SBool = if s1046 then s1173 else s1172-  s1175 :: SWord1 = choose [11:11] s724-  s1176 :: SBool = s13 /= s1175-  s1177 :: SBool = ~ s1176-  s1178 :: SBool = if s958 then s1177 else s1176-  s1179 :: SBool = ~ s1178-  s1180 :: SBool = if s998 then s1179 else s1178-  s1181 :: SWord1 = choose [10:10] s724-  s1182 :: SBool = s13 /= s1181-  s1183 :: SBool = ~ s1182-  s1184 :: SBool = if s966 then s1183 else s1182-  s1185 :: SBool = ~ s1184-  s1186 :: SBool = if s1006 then s1185 else s1184-  s1187 :: SWord1 = choose [9:9] s724-  s1188 :: SBool = s13 /= s1187-  s1189 :: SBool = ~ s1188-  s1190 :: SBool = if s974 then s1189 else s1188-  s1191 :: SBool = ~ s1190-  s1192 :: SBool = if s1014 then s1191 else s1190-  s1193 :: SWord1 = choose [8:8] s724-  s1194 :: SBool = s13 /= s1193-  s1195 :: SBool = ~ s1194-  s1196 :: SBool = if s982 then s1195 else s1194-  s1197 :: SBool = ~ s1196-  s1198 :: SBool = if s1022 then s1197 else s1196-  s1199 :: SWord1 = choose [7:7] s724-  s1200 :: SBool = s13 /= s1199-  s1201 :: SBool = ~ s1200-  s1202 :: SBool = if s990 then s1201 else s1200-  s1203 :: SBool = ~ s1202-  s1204 :: SBool = if s1030 then s1203 else s1202-  s1205 :: SWord1 = choose [6:6] s724-  s1206 :: SBool = s13 /= s1205-  s1207 :: SBool = ~ s1206-  s1208 :: SBool = if s998 then s1207 else s1206-  s1209 :: SBool = ~ s1208-  s1210 :: SBool = if s1038 then s1209 else s1208-  s1211 :: SWord1 = choose [5:5] s724-  s1212 :: SBool = s13 /= s1211-  s1213 :: SBool = ~ s1212-  s1214 :: SBool = if s1006 then s1213 else s1212-  s1215 :: SBool = ~ s1214-  s1216 :: SBool = if s1046 then s1215 else s1214-  s1217 :: SWord1 = choose [4:4] s724-  s1218 :: SBool = s13 /= s1217-  s1219 :: SBool = ~ s1218-  s1220 :: SBool = if s1014 then s1219 else s1218-  s1221 :: SWord1 = choose [3:3] s724-  s1222 :: SBool = s13 /= s1221-  s1223 :: SBool = ~ s1222-  s1224 :: SBool = if s1022 then s1223 else s1222-  s1225 :: SWord1 = choose [2:2] s724-  s1226 :: SBool = s13 /= s1225-  s1227 :: SBool = ~ s1226-  s1228 :: SBool = if s1030 then s1227 else s1226-  s1229 :: SWord1 = choose [1:1] s724-  s1230 :: SBool = s13 /= s1229-  s1231 :: SBool = ~ s1230-  s1232 :: SBool = if s1038 then s1231 else s1230-  s1233 :: SWord1 = choose [0:0] s724-  s1234 :: SBool = s13 /= s1233-  s1235 :: SBool = ~ s1234-  s1236 :: SBool = if s1046 then s1235 else s1234-  s1237 :: SWord64 = if s1236 then s525 else s526-  s1238 :: SWord64 = s528 | s1237-  s1239 :: SWord64 = if s1232 then s1238 else s1237-  s1240 :: SWord64 = s531 | s1239-  s1241 :: SWord64 = if s1228 then s1240 else s1239-  s1242 :: SWord64 = s534 | s1241-  s1243 :: SWord64 = if s1224 then s1242 else s1241-  s1244 :: SWord64 = s537 | s1243-  s1245 :: SWord64 = if s1220 then s1244 else s1243-  s1246 :: SWord64 = s540 | s1245-  s1247 :: SWord64 = if s1216 then s1246 else s1245-  s1248 :: SWord64 = s543 | s1247-  s1249 :: SWord64 = if s1210 then s1248 else s1247-  s1250 :: SWord64 = s546 | s1249-  s1251 :: SWord64 = if s1204 then s1250 else s1249-  s1252 :: SWord64 = s549 | s1251-  s1253 :: SWord64 = if s1198 then s1252 else s1251-  s1254 :: SWord64 = s552 | s1253-  s1255 :: SWord64 = if s1192 then s1254 else s1253-  s1256 :: SWord64 = s555 | s1255-  s1257 :: SWord64 = if s1186 then s1256 else s1255-  s1258 :: SWord64 = s558 | s1257-  s1259 :: SWord64 = if s1180 then s1258 else s1257-  s1260 :: SWord64 = s561 | s1259-  s1261 :: SWord64 = if s1174 then s1260 else s1259-  s1262 :: SWord64 = s564 | s1261-  s1263 :: SWord64 = if s1166 then s1262 else s1261-  s1264 :: SWord64 = s567 | s1263-  s1265 :: SWord64 = if s1158 then s1264 else s1263-  s1266 :: SWord64 = s570 | s1265-  s1267 :: SWord64 = if s1150 then s1266 else s1265-  s1268 :: SWord64 = s573 | s1267-  s1269 :: SWord64 = if s1142 then s1268 else s1267-  s1270 :: SWord64 = s576 | s1269-  s1271 :: SWord64 = if s1140 then s1270 else s1269-  s1272 :: SWord64 = s579 | s1271-  s1273 :: SWord64 = if s1138 then s1272 else s1271-  s1274 :: SWord64 = s582 | s1273-  s1275 :: SWord64 = if s1136 then s1274 else s1273-  s1276 :: SWord64 = s585 | s1275-  s1277 :: SWord64 = if s1134 then s1276 else s1275-  s1278 :: SWord64 = s588 | s1277-  s1279 :: SWord64 = if s1132 then s1278 else s1277-  s1280 :: SWord64 = s591 | s1279-  s1281 :: SWord64 = if s1130 then s1280 else s1279-  s1282 :: SWord64 = s594 | s1281-  s1283 :: SWord64 = if s1128 then s1282 else s1281-  s1284 :: SWord64 = s597 | s1283-  s1285 :: SWord64 = if s1126 then s1284 else s1283-  s1286 :: SWord64 = s600 | s1285-  s1287 :: SWord64 = if s1124 then s1286 else s1285-  s1288 :: SWord64 = s603 | s1287-  s1289 :: SWord64 = if s1122 then s1288 else s1287-  s1290 :: SWord64 = s606 | s1289-  s1291 :: SWord64 = if s1120 then s1290 else s1289-  s1292 :: SWord64 = s609 | s1291-  s1293 :: SWord64 = if s1118 then s1292 else s1291-  s1294 :: SWord64 = s612 | s1293-  s1295 :: SWord64 = if s1116 then s1294 else s1293-  s1296 :: SWord64 = s615 | s1295-  s1297 :: SWord64 = if s1114 then s1296 else s1295-  s1298 :: SWord64 = s618 | s1297-  s1299 :: SWord64 = if s1112 then s1298 else s1297-  s1300 :: SWord64 = s621 | s1299-  s1301 :: SWord64 = if s1110 then s1300 else s1299-  s1302 :: SWord64 = s624 | s1301-  s1303 :: SWord64 = if s1108 then s1302 else s1301-  s1304 :: SWord64 = s627 | s1303-  s1305 :: SWord64 = if s1106 then s1304 else s1303-  s1306 :: SWord64 = s630 | s1305-  s1307 :: SWord64 = if s1104 then s1306 else s1305-  s1308 :: SWord64 = s633 | s1307-  s1309 :: SWord64 = if s1102 then s1308 else s1307-  s1310 :: SWord64 = s636 | s1309-  s1311 :: SWord64 = if s1100 then s1310 else s1309-  s1312 :: SWord64 = s639 | s1311-  s1313 :: SWord64 = if s1098 then s1312 else s1311-  s1314 :: SWord64 = s642 | s1313-  s1315 :: SWord64 = if s1096 then s1314 else s1313-  s1316 :: SWord64 = s645 | s1315-  s1317 :: SWord64 = if s1094 then s1316 else s1315-  s1318 :: SWord64 = s648 | s1317-  s1319 :: SWord64 = if s1092 then s1318 else s1317-  s1320 :: SWord64 = s651 | s1319-  s1321 :: SWord64 = if s1090 then s1320 else s1319-  s1322 :: SWord64 = s654 | s1321-  s1323 :: SWord64 = if s1088 then s1322 else s1321-  s1324 :: SWord64 = s657 | s1323-  s1325 :: SWord64 = if s1086 then s1324 else s1323-  s1326 :: SWord64 = s660 | s1325-  s1327 :: SWord64 = if s1084 then s1326 else s1325-  s1328 :: SWord64 = s663 | s1327-  s1329 :: SWord64 = if s1082 then s1328 else s1327-  s1330 :: SWord64 = s666 | s1329-  s1331 :: SWord64 = if s1080 then s1330 else s1329-  s1332 :: SWord64 = s669 | s1331-  s1333 :: SWord64 = if s1078 then s1332 else s1331-  s1334 :: SWord64 = s672 | s1333-  s1335 :: SWord64 = if s1076 then s1334 else s1333-  s1336 :: SWord64 = s675 | s1335-  s1337 :: SWord64 = if s1074 then s1336 else s1335-  s1338 :: SWord64 = s678 | s1337-  s1339 :: SWord64 = if s1072 then s1338 else s1337-  s1340 :: SWord64 = s681 | s1339-  s1341 :: SWord64 = if s1070 then s1340 else s1339-  s1342 :: SWord64 = s684 | s1341-  s1343 :: SWord64 = if s1068 then s1342 else s1341-  s1344 :: SWord64 = s687 | s1343-  s1345 :: SWord64 = if s1066 then s1344 else s1343-  s1346 :: SWord64 = s690 | s1345-  s1347 :: SWord64 = if s1064 then s1346 else s1345-  s1348 :: SWord64 = s693 | s1347-  s1349 :: SWord64 = if s1062 then s1348 else s1347-  s1350 :: SWord64 = s696 | s1349-  s1351 :: SWord64 = if s1060 then s1350 else s1349-  s1352 :: SWord64 = s699 | s1351-  s1353 :: SWord64 = if s1058 then s1352 else s1351-  s1354 :: SWord64 = s702 | s1353-  s1355 :: SWord64 = if s1056 then s1354 else s1353-  s1356 :: SWord64 = s705 | s1355-  s1357 :: SWord64 = if s1054 then s1356 else s1355-  s1358 :: SWord64 = s708 | s1357-  s1359 :: SWord64 = if s1052 then s1358 else s1357-  s1360 :: SWord64 = s711 | s1359-  s1361 :: SWord64 = if s1050 then s1360 else s1359-  s1362 :: SWord64 = s714 | s1361-  s1363 :: SWord64 = if s1048 then s1362 else s1361-  s1364 :: SWord32 = choose [31:0] s1363-  s1365 :: SWord16 = choose [15:0] s1364-  s1366 :: SWord32 = s3 # s1365-  s1367 :: SWord64 = s2 # s1366-  s1368 :: SWord1 = choose [0:0] s1367-  s1369 :: SBool = s13 /= s1368-  s1370 :: SBool = s722 == s1369-  s1371 :: SWord1 = choose [1:1] s720-  s1372 :: SBool = s13 /= s1371-  s1373 :: SWord1 = choose [1:1] s1367-  s1374 :: SBool = s13 /= s1373-  s1375 :: SBool = s1372 == s1374-  s1376 :: SWord1 = choose [2:2] s720-  s1377 :: SBool = s13 /= s1376-  s1378 :: SWord1 = choose [2:2] s1367-  s1379 :: SBool = s13 /= s1378-  s1380 :: SBool = s1377 == s1379-  s1381 :: SWord1 = choose [3:3] s720-  s1382 :: SBool = s13 /= s1381-  s1383 :: SWord1 = choose [3:3] s1367-  s1384 :: SBool = s13 /= s1383-  s1385 :: SBool = s1382 == s1384-  s1386 :: SWord1 = choose [4:4] s720-  s1387 :: SBool = s13 /= s1386-  s1388 :: SWord1 = choose [4:4] s1367-  s1389 :: SBool = s13 /= s1388-  s1390 :: SBool = s1387 == s1389-  s1391 :: SWord1 = choose [5:5] s720-  s1392 :: SBool = s13 /= s1391-  s1393 :: SWord1 = choose [5:5] s1367-  s1394 :: SBool = s13 /= s1393-  s1395 :: SBool = s1392 == s1394-  s1396 :: SWord1 = choose [6:6] s720-  s1397 :: SBool = s13 /= s1396-  s1398 :: SWord1 = choose [6:6] s1367-  s1399 :: SBool = s13 /= s1398-  s1400 :: SBool = s1397 == s1399-  s1401 :: SWord1 = choose [7:7] s720-  s1402 :: SBool = s13 /= s1401-  s1403 :: SWord1 = choose [7:7] s1367-  s1404 :: SBool = s13 /= s1403-  s1405 :: SBool = s1402 == s1404-  s1406 :: SWord1 = choose [8:8] s720-  s1407 :: SBool = s13 /= s1406-  s1408 :: SWord1 = choose [8:8] s1367-  s1409 :: SBool = s13 /= s1408-  s1410 :: SBool = s1407 == s1409-  s1411 :: SWord1 = choose [9:9] s720-  s1412 :: SBool = s13 /= s1411-  s1413 :: SWord1 = choose [9:9] s1367-  s1414 :: SBool = s13 /= s1413-  s1415 :: SBool = s1412 == s1414-  s1416 :: SWord1 = choose [10:10] s720-  s1417 :: SBool = s13 /= s1416-  s1418 :: SWord1 = choose [10:10] s1367-  s1419 :: SBool = s13 /= s1418-  s1420 :: SBool = s1417 == s1419-  s1421 :: SWord1 = choose [11:11] s720-  s1422 :: SBool = s13 /= s1421-  s1423 :: SWord1 = choose [11:11] s1367-  s1424 :: SBool = s13 /= s1423-  s1425 :: SBool = s1422 == s1424-  s1426 :: SWord1 = choose [12:12] s720-  s1427 :: SBool = s13 /= s1426-  s1428 :: SWord1 = choose [12:12] s1367-  s1429 :: SBool = s13 /= s1428-  s1430 :: SBool = s1427 == s1429-  s1431 :: SWord1 = choose [13:13] s720-  s1432 :: SBool = s13 /= s1431-  s1433 :: SWord1 = choose [13:13] s1367-  s1434 :: SBool = s13 /= s1433-  s1435 :: SBool = s1432 == s1434-  s1436 :: SWord1 = choose [14:14] s720-  s1437 :: SBool = s13 /= s1436-  s1438 :: SWord1 = choose [14:14] s1367-  s1439 :: SBool = s13 /= s1438-  s1440 :: SBool = s1437 == s1439-  s1441 :: SWord1 = choose [15:15] s720-  s1442 :: SBool = s13 /= s1441-  s1443 :: SWord1 = choose [15:15] s1367-  s1444 :: SBool = s13 /= s1443-  s1445 :: SBool = s1442 == s1444-  s1446 :: SWord1 = choose [16:16] s720-  s1447 :: SBool = s13 /= s1446-  s1448 :: SWord1 = choose [16:16] s1367-  s1449 :: SBool = s13 /= s1448-  s1450 :: SBool = s1447 == s1449-  s1451 :: SWord1 = choose [17:17] s720-  s1452 :: SBool = s13 /= s1451-  s1453 :: SWord1 = choose [17:17] s1367-  s1454 :: SBool = s13 /= s1453-  s1455 :: SBool = s1452 == s1454-  s1456 :: SWord1 = choose [18:18] s720-  s1457 :: SBool = s13 /= s1456-  s1458 :: SWord1 = choose [18:18] s1367-  s1459 :: SBool = s13 /= s1458-  s1460 :: SBool = s1457 == s1459-  s1461 :: SWord1 = choose [19:19] s720-  s1462 :: SBool = s13 /= s1461-  s1463 :: SWord1 = choose [19:19] s1367-  s1464 :: SBool = s13 /= s1463-  s1465 :: SBool = s1462 == s1464-  s1466 :: SWord1 = choose [20:20] s720-  s1467 :: SBool = s13 /= s1466-  s1468 :: SWord1 = choose [20:20] s1367-  s1469 :: SBool = s13 /= s1468-  s1470 :: SBool = s1467 == s1469-  s1471 :: SWord1 = choose [21:21] s720-  s1472 :: SBool = s13 /= s1471-  s1473 :: SWord1 = choose [21:21] s1367-  s1474 :: SBool = s13 /= s1473-  s1475 :: SBool = s1472 == s1474-  s1476 :: SWord1 = choose [22:22] s720-  s1477 :: SBool = s13 /= s1476-  s1478 :: SWord1 = choose [22:22] s1367-  s1479 :: SBool = s13 /= s1478-  s1480 :: SBool = s1477 == s1479-  s1481 :: SWord1 = choose [23:23] s720-  s1482 :: SBool = s13 /= s1481-  s1483 :: SWord1 = choose [23:23] s1367-  s1484 :: SBool = s13 /= s1483-  s1485 :: SBool = s1482 == s1484-  s1486 :: SWord1 = choose [24:24] s720-  s1487 :: SBool = s13 /= s1486-  s1488 :: SWord1 = choose [24:24] s1367-  s1489 :: SBool = s13 /= s1488-  s1490 :: SBool = s1487 == s1489-  s1491 :: SWord1 = choose [25:25] s720-  s1492 :: SBool = s13 /= s1491-  s1493 :: SWord1 = choose [25:25] s1367-  s1494 :: SBool = s13 /= s1493-  s1495 :: SBool = s1492 == s1494-  s1496 :: SWord1 = choose [26:26] s720-  s1497 :: SBool = s13 /= s1496-  s1498 :: SWord1 = choose [26:26] s1367-  s1499 :: SBool = s13 /= s1498-  s1500 :: SBool = s1497 == s1499-  s1501 :: SWord1 = choose [27:27] s720-  s1502 :: SBool = s13 /= s1501-  s1503 :: SWord1 = choose [27:27] s1367-  s1504 :: SBool = s13 /= s1503-  s1505 :: SBool = s1502 == s1504-  s1506 :: SWord1 = choose [28:28] s720-  s1507 :: SBool = s13 /= s1506-  s1508 :: SWord1 = choose [28:28] s1367-  s1509 :: SBool = s13 /= s1508-  s1510 :: SBool = s1507 == s1509-  s1511 :: SWord1 = choose [29:29] s720-  s1512 :: SBool = s13 /= s1511-  s1513 :: SWord1 = choose [29:29] s1367-  s1514 :: SBool = s13 /= s1513-  s1515 :: SBool = s1512 == s1514-  s1516 :: SWord1 = choose [30:30] s720-  s1517 :: SBool = s13 /= s1516-  s1518 :: SWord1 = choose [30:30] s1367-  s1519 :: SBool = s13 /= s1518-  s1520 :: SBool = s1517 == s1519-  s1521 :: SWord1 = choose [31:31] s720-  s1522 :: SBool = s13 /= s1521-  s1523 :: SWord1 = choose [31:31] s1367-  s1524 :: SBool = s13 /= s1523-  s1525 :: SBool = s1522 == s1524-  s1526 :: SWord1 = choose [32:32] s720-  s1527 :: SBool = s13 /= s1526-  s1528 :: SWord1 = choose [32:32] s1367-  s1529 :: SBool = s13 /= s1528-  s1530 :: SBool = s1527 == s1529-  s1531 :: SWord1 = choose [33:33] s720-  s1532 :: SBool = s13 /= s1531-  s1533 :: SWord1 = choose [33:33] s1367-  s1534 :: SBool = s13 /= s1533-  s1535 :: SBool = s1532 == s1534-  s1536 :: SWord1 = choose [34:34] s720-  s1537 :: SBool = s13 /= s1536-  s1538 :: SWord1 = choose [34:34] s1367-  s1539 :: SBool = s13 /= s1538-  s1540 :: SBool = s1537 == s1539-  s1541 :: SWord1 = choose [35:35] s720-  s1542 :: SBool = s13 /= s1541-  s1543 :: SWord1 = choose [35:35] s1367-  s1544 :: SBool = s13 /= s1543-  s1545 :: SBool = s1542 == s1544-  s1546 :: SWord1 = choose [36:36] s720-  s1547 :: SBool = s13 /= s1546-  s1548 :: SWord1 = choose [36:36] s1367-  s1549 :: SBool = s13 /= s1548-  s1550 :: SBool = s1547 == s1549-  s1551 :: SWord1 = choose [37:37] s720-  s1552 :: SBool = s13 /= s1551-  s1553 :: SWord1 = choose [37:37] s1367-  s1554 :: SBool = s13 /= s1553-  s1555 :: SBool = s1552 == s1554-  s1556 :: SWord1 = choose [38:38] s720-  s1557 :: SBool = s13 /= s1556-  s1558 :: SWord1 = choose [38:38] s1367-  s1559 :: SBool = s13 /= s1558-  s1560 :: SBool = s1557 == s1559-  s1561 :: SWord1 = choose [39:39] s720-  s1562 :: SBool = s13 /= s1561-  s1563 :: SWord1 = choose [39:39] s1367-  s1564 :: SBool = s13 /= s1563-  s1565 :: SBool = s1562 == s1564-  s1566 :: SWord1 = choose [40:40] s720-  s1567 :: SBool = s13 /= s1566-  s1568 :: SWord1 = choose [40:40] s1367-  s1569 :: SBool = s13 /= s1568-  s1570 :: SBool = s1567 == s1569-  s1571 :: SWord1 = choose [41:41] s720-  s1572 :: SBool = s13 /= s1571-  s1573 :: SWord1 = choose [41:41] s1367-  s1574 :: SBool = s13 /= s1573-  s1575 :: SBool = s1572 == s1574-  s1576 :: SWord1 = choose [42:42] s720-  s1577 :: SBool = s13 /= s1576-  s1578 :: SWord1 = choose [42:42] s1367-  s1579 :: SBool = s13 /= s1578-  s1580 :: SBool = s1577 == s1579-  s1581 :: SWord1 = choose [43:43] s720-  s1582 :: SBool = s13 /= s1581-  s1583 :: SWord1 = choose [43:43] s1367-  s1584 :: SBool = s13 /= s1583-  s1585 :: SBool = s1582 == s1584-  s1586 :: SWord1 = choose [44:44] s720-  s1587 :: SBool = s13 /= s1586-  s1588 :: SWord1 = choose [44:44] s1367-  s1589 :: SBool = s13 /= s1588-  s1590 :: SBool = s1587 == s1589-  s1591 :: SWord1 = choose [45:45] s720-  s1592 :: SBool = s13 /= s1591-  s1593 :: SWord1 = choose [45:45] s1367-  s1594 :: SBool = s13 /= s1593-  s1595 :: SBool = s1592 == s1594-  s1596 :: SWord1 = choose [46:46] s720-  s1597 :: SBool = s13 /= s1596-  s1598 :: SWord1 = choose [46:46] s1367-  s1599 :: SBool = s13 /= s1598-  s1600 :: SBool = s1597 == s1599-  s1601 :: SWord1 = choose [47:47] s720-  s1602 :: SBool = s13 /= s1601-  s1603 :: SWord1 = choose [47:47] s1367-  s1604 :: SBool = s13 /= s1603-  s1605 :: SBool = s1602 == s1604-  s1606 :: SWord1 = choose [48:48] s720-  s1607 :: SBool = s13 /= s1606-  s1608 :: SWord1 = choose [48:48] s1367-  s1609 :: SBool = s13 /= s1608-  s1610 :: SBool = s1607 == s1609-  s1611 :: SWord1 = choose [49:49] s720-  s1612 :: SBool = s13 /= s1611-  s1613 :: SWord1 = choose [49:49] s1367-  s1614 :: SBool = s13 /= s1613-  s1615 :: SBool = s1612 == s1614-  s1616 :: SWord1 = choose [50:50] s720-  s1617 :: SBool = s13 /= s1616-  s1618 :: SWord1 = choose [50:50] s1367-  s1619 :: SBool = s13 /= s1618-  s1620 :: SBool = s1617 == s1619-  s1621 :: SWord1 = choose [51:51] s720-  s1622 :: SBool = s13 /= s1621-  s1623 :: SWord1 = choose [51:51] s1367-  s1624 :: SBool = s13 /= s1623-  s1625 :: SBool = s1622 == s1624-  s1626 :: SWord1 = choose [52:52] s720-  s1627 :: SBool = s13 /= s1626-  s1628 :: SWord1 = choose [52:52] s1367-  s1629 :: SBool = s13 /= s1628-  s1630 :: SBool = s1627 == s1629-  s1631 :: SWord1 = choose [53:53] s720-  s1632 :: SBool = s13 /= s1631-  s1633 :: SWord1 = choose [53:53] s1367-  s1634 :: SBool = s13 /= s1633-  s1635 :: SBool = s1632 == s1634-  s1636 :: SWord1 = choose [54:54] s720-  s1637 :: SBool = s13 /= s1636-  s1638 :: SWord1 = choose [54:54] s1367-  s1639 :: SBool = s13 /= s1638-  s1640 :: SBool = s1637 == s1639-  s1641 :: SWord1 = choose [55:55] s720-  s1642 :: SBool = s13 /= s1641-  s1643 :: SWord1 = choose [55:55] s1367-  s1644 :: SBool = s13 /= s1643-  s1645 :: SBool = s1642 == s1644-  s1646 :: SWord1 = choose [56:56] s720-  s1647 :: SBool = s13 /= s1646-  s1648 :: SWord1 = choose [56:56] s1367-  s1649 :: SBool = s13 /= s1648-  s1650 :: SBool = s1647 == s1649-  s1651 :: SWord1 = choose [57:57] s720-  s1652 :: SBool = s13 /= s1651-  s1653 :: SWord1 = choose [57:57] s1367-  s1654 :: SBool = s13 /= s1653-  s1655 :: SBool = s1652 == s1654-  s1656 :: SWord1 = choose [58:58] s720-  s1657 :: SBool = s13 /= s1656-  s1658 :: SWord1 = choose [58:58] s1367-  s1659 :: SBool = s13 /= s1658-  s1660 :: SBool = s1657 == s1659-  s1661 :: SWord1 = choose [59:59] s720-  s1662 :: SBool = s13 /= s1661-  s1663 :: SWord1 = choose [59:59] s1367-  s1664 :: SBool = s13 /= s1663-  s1665 :: SBool = s1662 == s1664-  s1666 :: SWord1 = choose [60:60] s720-  s1667 :: SBool = s13 /= s1666-  s1668 :: SWord1 = choose [60:60] s1367-  s1669 :: SBool = s13 /= s1668-  s1670 :: SBool = s1667 == s1669-  s1671 :: SWord1 = choose [61:61] s720-  s1672 :: SBool = s13 /= s1671-  s1673 :: SWord1 = choose [61:61] s1367-  s1674 :: SBool = s13 /= s1673-  s1675 :: SBool = s1672 == s1674-  s1676 :: SWord1 = choose [62:62] s720-  s1677 :: SBool = s13 /= s1676-  s1678 :: SWord1 = choose [62:62] s1367-  s1679 :: SBool = s13 /= s1678-  s1680 :: SBool = s1677 == s1679-  s1681 :: SWord1 = choose [63:63] s720-  s1682 :: SBool = s13 /= s1681-  s1683 :: SWord1 = choose [63:63] s1367-  s1684 :: SBool = s13 /= s1683-  s1685 :: SBool = s1682 == s1684-  s1688 :: SWord8 = if s1685 then s1686 else s1687-  s1689 :: SWord8 = s1687 + s1688-  s1690 :: SWord8 = if s1680 then s1688 else s1689-  s1691 :: SWord8 = s1687 + s1690-  s1692 :: SWord8 = if s1675 then s1690 else s1691-  s1693 :: SWord8 = s1687 + s1692-  s1694 :: SWord8 = if s1670 then s1692 else s1693-  s1695 :: SWord8 = s1687 + s1694-  s1696 :: SWord8 = if s1665 then s1694 else s1695-  s1697 :: SWord8 = s1687 + s1696-  s1698 :: SWord8 = if s1660 then s1696 else s1697-  s1699 :: SWord8 = s1687 + s1698-  s1700 :: SWord8 = if s1655 then s1698 else s1699-  s1701 :: SWord8 = s1687 + s1700-  s1702 :: SWord8 = if s1650 then s1700 else s1701-  s1703 :: SWord8 = s1687 + s1702-  s1704 :: SWord8 = if s1645 then s1702 else s1703-  s1705 :: SWord8 = s1687 + s1704-  s1706 :: SWord8 = if s1640 then s1704 else s1705-  s1707 :: SWord8 = s1687 + s1706-  s1708 :: SWord8 = if s1635 then s1706 else s1707-  s1709 :: SWord8 = s1687 + s1708-  s1710 :: SWord8 = if s1630 then s1708 else s1709-  s1711 :: SWord8 = s1687 + s1710-  s1712 :: SWord8 = if s1625 then s1710 else s1711-  s1713 :: SWord8 = s1687 + s1712-  s1714 :: SWord8 = if s1620 then s1712 else s1713-  s1715 :: SWord8 = s1687 + s1714-  s1716 :: SWord8 = if s1615 then s1714 else s1715-  s1717 :: SWord8 = s1687 + s1716-  s1718 :: SWord8 = if s1610 then s1716 else s1717-  s1719 :: SWord8 = s1687 + s1718-  s1720 :: SWord8 = if s1605 then s1718 else s1719-  s1721 :: SWord8 = s1687 + s1720-  s1722 :: SWord8 = if s1600 then s1720 else s1721-  s1723 :: SWord8 = s1687 + s1722-  s1724 :: SWord8 = if s1595 then s1722 else s1723-  s1725 :: SWord8 = s1687 + s1724-  s1726 :: SWord8 = if s1590 then s1724 else s1725-  s1727 :: SWord8 = s1687 + s1726-  s1728 :: SWord8 = if s1585 then s1726 else s1727-  s1729 :: SWord8 = s1687 + s1728-  s1730 :: SWord8 = if s1580 then s1728 else s1729-  s1731 :: SWord8 = s1687 + s1730-  s1732 :: SWord8 = if s1575 then s1730 else s1731-  s1733 :: SWord8 = s1687 + s1732-  s1734 :: SWord8 = if s1570 then s1732 else s1733-  s1735 :: SWord8 = s1687 + s1734-  s1736 :: SWord8 = if s1565 then s1734 else s1735-  s1737 :: SWord8 = s1687 + s1736-  s1738 :: SWord8 = if s1560 then s1736 else s1737-  s1739 :: SWord8 = s1687 + s1738-  s1740 :: SWord8 = if s1555 then s1738 else s1739-  s1741 :: SWord8 = s1687 + s1740-  s1742 :: SWord8 = if s1550 then s1740 else s1741-  s1743 :: SWord8 = s1687 + s1742-  s1744 :: SWord8 = if s1545 then s1742 else s1743-  s1745 :: SWord8 = s1687 + s1744-  s1746 :: SWord8 = if s1540 then s1744 else s1745-  s1747 :: SWord8 = s1687 + s1746-  s1748 :: SWord8 = if s1535 then s1746 else s1747-  s1749 :: SWord8 = s1687 + s1748-  s1750 :: SWord8 = if s1530 then s1748 else s1749-  s1751 :: SWord8 = s1687 + s1750-  s1752 :: SWord8 = if s1525 then s1750 else s1751-  s1753 :: SWord8 = s1687 + s1752-  s1754 :: SWord8 = if s1520 then s1752 else s1753-  s1755 :: SWord8 = s1687 + s1754-  s1756 :: SWord8 = if s1515 then s1754 else s1755-  s1757 :: SWord8 = s1687 + s1756-  s1758 :: SWord8 = if s1510 then s1756 else s1757-  s1759 :: SWord8 = s1687 + s1758-  s1760 :: SWord8 = if s1505 then s1758 else s1759-  s1761 :: SWord8 = s1687 + s1760-  s1762 :: SWord8 = if s1500 then s1760 else s1761-  s1763 :: SWord8 = s1687 + s1762-  s1764 :: SWord8 = if s1495 then s1762 else s1763-  s1765 :: SWord8 = s1687 + s1764-  s1766 :: SWord8 = if s1490 then s1764 else s1765-  s1767 :: SWord8 = s1687 + s1766-  s1768 :: SWord8 = if s1485 then s1766 else s1767-  s1769 :: SWord8 = s1687 + s1768-  s1770 :: SWord8 = if s1480 then s1768 else s1769-  s1771 :: SWord8 = s1687 + s1770-  s1772 :: SWord8 = if s1475 then s1770 else s1771-  s1773 :: SWord8 = s1687 + s1772-  s1774 :: SWord8 = if s1470 then s1772 else s1773-  s1775 :: SWord8 = s1687 + s1774-  s1776 :: SWord8 = if s1465 then s1774 else s1775-  s1777 :: SWord8 = s1687 + s1776-  s1778 :: SWord8 = if s1460 then s1776 else s1777-  s1779 :: SWord8 = s1687 + s1778-  s1780 :: SWord8 = if s1455 then s1778 else s1779-  s1781 :: SWord8 = s1687 + s1780-  s1782 :: SWord8 = if s1450 then s1780 else s1781-  s1783 :: SWord8 = s1687 + s1782-  s1784 :: SWord8 = if s1445 then s1782 else s1783-  s1785 :: SWord8 = s1687 + s1784-  s1786 :: SWord8 = if s1440 then s1784 else s1785-  s1787 :: SWord8 = s1687 + s1786-  s1788 :: SWord8 = if s1435 then s1786 else s1787-  s1789 :: SWord8 = s1687 + s1788-  s1790 :: SWord8 = if s1430 then s1788 else s1789-  s1791 :: SWord8 = s1687 + s1790-  s1792 :: SWord8 = if s1425 then s1790 else s1791-  s1793 :: SWord8 = s1687 + s1792-  s1794 :: SWord8 = if s1420 then s1792 else s1793-  s1795 :: SWord8 = s1687 + s1794-  s1796 :: SWord8 = if s1415 then s1794 else s1795-  s1797 :: SWord8 = s1687 + s1796-  s1798 :: SWord8 = if s1410 then s1796 else s1797-  s1799 :: SWord8 = s1687 + s1798-  s1800 :: SWord8 = if s1405 then s1798 else s1799-  s1801 :: SWord8 = s1687 + s1800-  s1802 :: SWord8 = if s1400 then s1800 else s1801-  s1803 :: SWord8 = s1687 + s1802-  s1804 :: SWord8 = if s1395 then s1802 else s1803-  s1805 :: SWord8 = s1687 + s1804-  s1806 :: SWord8 = if s1390 then s1804 else s1805-  s1807 :: SWord8 = s1687 + s1806-  s1808 :: SWord8 = if s1385 then s1806 else s1807-  s1809 :: SWord8 = s1687 + s1808-  s1810 :: SWord8 = if s1380 then s1808 else s1809-  s1811 :: SWord8 = s1687 + s1810-  s1812 :: SWord8 = if s1375 then s1810 else s1811-  s1813 :: SWord8 = s1687 + s1812-  s1814 :: SWord8 = if s1370 then s1812 else s1813-  s1816 :: SBool = s1814 > s1815-  s1817 :: SBool = s8 | s1816-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s1817
− SBVUnitTest/GoldFiles/cgUninterpret.gold 
@@ -1,114 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for tstShiftLeft. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: tstShiftLeft_driver--tstShiftLeft.o: tstShiftLeft.c tstShiftLeft.h-	${CC} ${CCFLAGS} -c $< -o $@--tstShiftLeft_driver.o: tstShiftLeft_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--tstShiftLeft_driver: tstShiftLeft.o tstShiftLeft_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f tstShiftLeft_driver-== END: "Makefile" ==================-== BEGIN: "tstShiftLeft.h" ================-/* Header file for tstShiftLeft. Automatically generated by SBV. Do not edit! */--#ifndef __tstShiftLeft__HEADER_INCLUDED__-#define __tstShiftLeft__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-SWord32 tstShiftLeft(const SWord32 *vs);--#endif /* __tstShiftLeft__HEADER_INCLUDED__ */-== END: "tstShiftLeft.h" ==================-== BEGIN: "tstShiftLeft_driver.c" ================-/* Example driver program for tstShiftLeft. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "tstShiftLeft.h"--int main(void)-{-  const SWord32 vs[3] = {-      0x00000001UL, 0x00000002UL, 0x00000003UL-  };--  printf("Contents of input array vs:\n");-  int vs_ctr;-  for(vs_ctr = 0; vs_ctr < 3 ; ++vs_ctr)-    printf("  vs[%d] = 0x%08"PRIx32"UL\n", vs_ctr ,vs[vs_ctr]);---  const SWord32 __result = tstShiftLeft(vs);--  printf("tstShiftLeft(vs) = 0x%08"PRIx32"UL\n", __result);--  return 0;-}-== END: "tstShiftLeft_driver.c" ==================-== BEGIN: "tstShiftLeft.c" ================-/* File: "tstShiftLeft.c". Automatically generated by SBV. Do not edit! */--#include "tstShiftLeft.h"--/* User specified custom code for "SBV_SHIFTLEFT" */-#define SBV_SHIFTLEFT(x, y) ((x) << (y))--SWord32 tstShiftLeft(const SWord32 *vs)-{-  const SWord32 s0 = vs[0];-  const SWord32 s1 = vs[1];-  const SWord32 s2 = vs[2];-  const SWord32 s3 = /* Uninterpreted function */ SBV_SHIFTLEFT(s0,-                                                                s2);-  const SWord32 s4 = /* Uninterpreted function */ SBV_SHIFTLEFT(s1,-                                                                s2);-  const SWord32 s5 = s3 + s4;--  return s5;-}-== END: "tstShiftLeft.c" ==================
− SBVUnitTest/GoldFiles/codeGen1.gold 
@@ -1,230 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for foo. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: foo_driver--foo.o: foo.c foo.h-	${CC} ${CCFLAGS} -c $< -o $@--foo_driver.o: foo_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--foo_driver: foo.o foo_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f foo_driver-== END: "Makefile" ==================-== BEGIN: "foo.h" ================-/* Header file for foo. Automatically generated by SBV. Do not edit! */--#ifndef __foo__HEADER_INCLUDED__-#define __foo__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-SInt16 foo(const SInt16 x, const SInt64 *xArr, SWord16 *z,-           SInt16 *zArr, SInt64 *yArr);--#endif /* __foo__HEADER_INCLUDED__ */-== END: "foo.h" ==================-== BEGIN: "foo_driver.c" ================-/* Example driver program for foo. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "foo.h"--int main(void)-{-  const SInt64 xArr[45] = {-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL,-      0x0000000000000000LL, 0x0000000000000000LL, 0x0000000000000000LL-  };--  printf("Contents of input array xArr:\n");-  int xArr_ctr;-  for(xArr_ctr = 0; xArr_ctr < 45 ; ++xArr_ctr)-    printf("  xArr[%d] = %"PRId64"LL\n", xArr_ctr ,xArr[xArr_ctr]);--  SWord16 z;-  SInt16 zArr[7];-  SInt64 yArr[45];--  const SInt16 __result = foo(0x0000, xArr, &z, zArr, yArr);--  printf("foo(0x0000, xArr, &z, zArr, yArr) = %"PRId16"\n", __result);-  printf("  z = 0x%04"PRIx16"U\n", z);-  int zArr_ctr;-  for(zArr_ctr = 0; zArr_ctr < 7 ; ++zArr_ctr)-    printf("  zArr[%d] = %"PRId16"\n", zArr_ctr ,zArr[zArr_ctr]);-  int yArr_ctr;-  for(yArr_ctr = 0; yArr_ctr < 45 ; ++yArr_ctr)-    printf("  yArr[%d] = %"PRId64"LL\n", yArr_ctr ,yArr[yArr_ctr]);--  return 0;-}-== END: "foo_driver.c" ==================-== BEGIN: "foo.c" ================-/* File: "foo.c". Automatically generated by SBV. Do not edit! */--#include "foo.h"--SInt16 foo(const SInt16 x, const SInt64 *xArr, SWord16 *z,-           SInt16 *zArr, SInt64 *yArr)-{-  const SInt16 s0 = x;-  const SInt64 s1 = xArr[0];-  const SInt64 s2 = xArr[1];-  const SInt64 s3 = xArr[2];-  const SInt64 s4 = xArr[3];-  const SInt64 s5 = xArr[4];-  const SInt64 s6 = xArr[5];-  const SInt64 s7 = xArr[6];-  const SInt64 s8 = xArr[7];-  const SInt64 s9 = xArr[8];-  const SInt64 s10 = xArr[9];-  const SInt64 s11 = xArr[10];-  const SInt64 s12 = xArr[11];-  const SInt64 s13 = xArr[12];-  const SInt64 s14 = xArr[13];-  const SInt64 s15 = xArr[14];-  const SInt64 s16 = xArr[15];-  const SInt64 s17 = xArr[16];-  const SInt64 s18 = xArr[17];-  const SInt64 s19 = xArr[18];-  const SInt64 s20 = xArr[19];-  const SInt64 s21 = xArr[20];-  const SInt64 s22 = xArr[21];-  const SInt64 s23 = xArr[22];-  const SInt64 s24 = xArr[23];-  const SInt64 s25 = xArr[24];-  const SInt64 s26 = xArr[25];-  const SInt64 s27 = xArr[26];-  const SInt64 s28 = xArr[27];-  const SInt64 s29 = xArr[28];-  const SInt64 s30 = xArr[29];-  const SInt64 s31 = xArr[30];-  const SInt64 s32 = xArr[31];-  const SInt64 s33 = xArr[32];-  const SInt64 s34 = xArr[33];-  const SInt64 s35 = xArr[34];-  const SInt64 s36 = xArr[35];-  const SInt64 s37 = xArr[36];-  const SInt64 s38 = xArr[37];-  const SInt64 s39 = xArr[38];-  const SInt64 s40 = xArr[39];-  const SInt64 s41 = xArr[40];-  const SInt64 s42 = xArr[41];-  const SInt64 s43 = xArr[42];-  const SInt64 s44 = xArr[43];-  const SInt64 s45 = xArr[44];-  const SInt16 s48 = s0 + 0x0001;-  const SInt16 s50 = s0 * 0x0002;--  *z = 0x0005U;-  zArr[0] = s48;-  zArr[1] = s48;-  zArr[2] = s48;-  zArr[3] = s48;-  zArr[4] = s48;-  zArr[5] = s48;-  zArr[6] = s48;-  yArr[0] = s1;-  yArr[1] = s2;-  yArr[2] = s3;-  yArr[3] = s4;-  yArr[4] = s5;-  yArr[5] = s6;-  yArr[6] = s7;-  yArr[7] = s8;-  yArr[8] = s9;-  yArr[9] = s10;-  yArr[10] = s11;-  yArr[11] = s12;-  yArr[12] = s13;-  yArr[13] = s14;-  yArr[14] = s15;-  yArr[15] = s16;-  yArr[16] = s17;-  yArr[17] = s18;-  yArr[18] = s19;-  yArr[19] = s20;-  yArr[20] = s21;-  yArr[21] = s22;-  yArr[22] = s23;-  yArr[23] = s24;-  yArr[24] = s25;-  yArr[25] = s26;-  yArr[26] = s27;-  yArr[27] = s28;-  yArr[28] = s29;-  yArr[29] = s30;-  yArr[30] = s31;-  yArr[31] = s32;-  yArr[32] = s33;-  yArr[33] = s34;-  yArr[34] = s35;-  yArr[35] = s36;-  yArr[36] = s37;-  yArr[37] = s38;-  yArr[38] = s39;-  yArr[39] = s40;-  yArr[40] = s41;-  yArr[41] = s42;-  yArr[42] = s43;-  yArr[43] = s44;-  yArr[44] = s45;-  return s50;-}-== END: "foo.c" ==================
− SBVUnitTest/GoldFiles/coins.gold 
@@ -1,918 +0,0 @@-INPUTS-  s0 :: SWord16, existential, aliasing "c1"-  s18 :: SWord16, existential, aliasing "c2"-  s30 :: SWord16, existential, aliasing "c3"-  s42 :: SWord16, existential, aliasing "c4"-  s54 :: SWord16, existential, aliasing "c5"-  s66 :: SWord16, existential, aliasing "c6"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s1 = 1 :: Word16-  s3 = 5 :: Word16-  s5 = 10 :: Word16-  s7 = 25 :: Word16-  s9 = 50 :: Word16-  s11 = 100 :: Word16-  s84 = 0 :: Word16-  s88 = 95 :: Word16-  s551 = 115 :: Word16-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s2 :: SBool = s0 == s1-  s4 :: SBool = s0 == s3-  s6 :: SBool = s0 == s5-  s8 :: SBool = s0 == s7-  s10 :: SBool = s0 == s9-  s12 :: SBool = s0 == s11-  s13 :: SBool = s10 | s12-  s14 :: SBool = s8 | s13-  s15 :: SBool = s6 | s14-  s16 :: SBool = s4 | s15-  s17 :: SBool = s2 | s16-  s19 :: SBool = s1 == s18-  s20 :: SBool = s3 == s18-  s21 :: SBool = s5 == s18-  s22 :: SBool = s7 == s18-  s23 :: SBool = s9 == s18-  s24 :: SBool = s11 == s18-  s25 :: SBool = s23 | s24-  s26 :: SBool = s22 | s25-  s27 :: SBool = s21 | s26-  s28 :: SBool = s20 | s27-  s29 :: SBool = s19 | s28-  s31 :: SBool = s1 == s30-  s32 :: SBool = s3 == s30-  s33 :: SBool = s5 == s30-  s34 :: SBool = s7 == s30-  s35 :: SBool = s9 == s30-  s36 :: SBool = s11 == s30-  s37 :: SBool = s35 | s36-  s38 :: SBool = s34 | s37-  s39 :: SBool = s33 | s38-  s40 :: SBool = s32 | s39-  s41 :: SBool = s31 | s40-  s43 :: SBool = s1 == s42-  s44 :: SBool = s3 == s42-  s45 :: SBool = s5 == s42-  s46 :: SBool = s7 == s42-  s47 :: SBool = s9 == s42-  s48 :: SBool = s11 == s42-  s49 :: SBool = s47 | s48-  s50 :: SBool = s46 | s49-  s51 :: SBool = s45 | s50-  s52 :: SBool = s44 | s51-  s53 :: SBool = s43 | s52-  s55 :: SBool = s1 == s54-  s56 :: SBool = s3 == s54-  s57 :: SBool = s5 == s54-  s58 :: SBool = s7 == s54-  s59 :: SBool = s9 == s54-  s60 :: SBool = s11 == s54-  s61 :: SBool = s59 | s60-  s62 :: SBool = s58 | s61-  s63 :: SBool = s57 | s62-  s64 :: SBool = s56 | s63-  s65 :: SBool = s55 | s64-  s67 :: SBool = s1 == s66-  s68 :: SBool = s3 == s66-  s69 :: SBool = s5 == s66-  s70 :: SBool = s7 == s66-  s71 :: SBool = s9 == s66-  s72 :: SBool = s11 == s66-  s73 :: SBool = s71 | s72-  s74 :: SBool = s70 | s73-  s75 :: SBool = s69 | s74-  s76 :: SBool = s68 | s75-  s77 :: SBool = s67 | s76-  s78 :: SWord16 = s0 + s18-  s79 :: SBool = s11 /= s78-  s80 :: SBool = s9 /= s78-  s81 :: SBool = s7 /= s78-  s82 :: SBool = s5 /= s78-  s83 :: SBool = s3 /= s78-  s85 :: SWord16 = if s10 then s84 else s0-  s86 :: SWord16 = if s23 then s84 else s18-  s87 :: SWord16 = s85 + s86-  s89 :: SBool = s87 /= s88-  s90 :: SWord16 = s0 + s30-  s91 :: SBool = s11 /= s90-  s92 :: SBool = s9 /= s90-  s93 :: SBool = s7 /= s90-  s94 :: SBool = s5 /= s90-  s95 :: SBool = s3 /= s90-  s96 :: SWord16 = if s35 then s84 else s30-  s97 :: SWord16 = s85 + s96-  s98 :: SBool = s88 /= s97-  s99 :: SWord16 = s0 + s42-  s100 :: SBool = s11 /= s99-  s101 :: SBool = s9 /= s99-  s102 :: SBool = s7 /= s99-  s103 :: SBool = s5 /= s99-  s104 :: SBool = s3 /= s99-  s105 :: SWord16 = if s47 then s84 else s42-  s106 :: SWord16 = s85 + s105-  s107 :: SBool = s88 /= s106-  s108 :: SWord16 = s0 + s54-  s109 :: SBool = s11 /= s108-  s110 :: SBool = s9 /= s108-  s111 :: SBool = s7 /= s108-  s112 :: SBool = s5 /= s108-  s113 :: SBool = s3 /= s108-  s114 :: SWord16 = if s59 then s84 else s54-  s115 :: SWord16 = s85 + s114-  s116 :: SBool = s88 /= s115-  s117 :: SWord16 = s0 + s66-  s118 :: SBool = s11 /= s117-  s119 :: SBool = s9 /= s117-  s120 :: SBool = s7 /= s117-  s121 :: SBool = s5 /= s117-  s122 :: SBool = s3 /= s117-  s123 :: SWord16 = if s71 then s84 else s66-  s124 :: SWord16 = s85 + s123-  s125 :: SBool = s88 /= s124-  s126 :: SWord16 = s18 + s30-  s127 :: SBool = s11 /= s126-  s128 :: SBool = s9 /= s126-  s129 :: SBool = s7 /= s126-  s130 :: SBool = s5 /= s126-  s131 :: SBool = s3 /= s126-  s132 :: SWord16 = s86 + s96-  s133 :: SBool = s88 /= s132-  s134 :: SWord16 = s18 + s42-  s135 :: SBool = s11 /= s134-  s136 :: SBool = s9 /= s134-  s137 :: SBool = s7 /= s134-  s138 :: SBool = s5 /= s134-  s139 :: SBool = s3 /= s134-  s140 :: SWord16 = s86 + s105-  s141 :: SBool = s88 /= s140-  s142 :: SWord16 = s18 + s54-  s143 :: SBool = s11 /= s142-  s144 :: SBool = s9 /= s142-  s145 :: SBool = s7 /= s142-  s146 :: SBool = s5 /= s142-  s147 :: SBool = s3 /= s142-  s148 :: SWord16 = s86 + s114-  s149 :: SBool = s88 /= s148-  s150 :: SWord16 = s18 + s66-  s151 :: SBool = s11 /= s150-  s152 :: SBool = s9 /= s150-  s153 :: SBool = s7 /= s150-  s154 :: SBool = s5 /= s150-  s155 :: SBool = s3 /= s150-  s156 :: SWord16 = s86 + s123-  s157 :: SBool = s88 /= s156-  s158 :: SWord16 = s30 + s42-  s159 :: SBool = s11 /= s158-  s160 :: SBool = s9 /= s158-  s161 :: SBool = s7 /= s158-  s162 :: SBool = s5 /= s158-  s163 :: SBool = s3 /= s158-  s164 :: SWord16 = s96 + s105-  s165 :: SBool = s88 /= s164-  s166 :: SWord16 = s30 + s54-  s167 :: SBool = s11 /= s166-  s168 :: SBool = s9 /= s166-  s169 :: SBool = s7 /= s166-  s170 :: SBool = s5 /= s166-  s171 :: SBool = s3 /= s166-  s172 :: SWord16 = s96 + s114-  s173 :: SBool = s88 /= s172-  s174 :: SWord16 = s30 + s66-  s175 :: SBool = s11 /= s174-  s176 :: SBool = s9 /= s174-  s177 :: SBool = s7 /= s174-  s178 :: SBool = s5 /= s174-  s179 :: SBool = s3 /= s174-  s180 :: SWord16 = s96 + s123-  s181 :: SBool = s88 /= s180-  s182 :: SWord16 = s42 + s54-  s183 :: SBool = s11 /= s182-  s184 :: SBool = s9 /= s182-  s185 :: SBool = s7 /= s182-  s186 :: SBool = s5 /= s182-  s187 :: SBool = s3 /= s182-  s188 :: SWord16 = s105 + s114-  s189 :: SBool = s88 /= s188-  s190 :: SWord16 = s42 + s66-  s191 :: SBool = s11 /= s190-  s192 :: SBool = s9 /= s190-  s193 :: SBool = s7 /= s190-  s194 :: SBool = s5 /= s190-  s195 :: SBool = s3 /= s190-  s196 :: SWord16 = s105 + s123-  s197 :: SBool = s88 /= s196-  s198 :: SWord16 = s54 + s66-  s199 :: SBool = s11 /= s198-  s200 :: SBool = s9 /= s198-  s201 :: SBool = s7 /= s198-  s202 :: SBool = s5 /= s198-  s203 :: SBool = s3 /= s198-  s204 :: SWord16 = s114 + s123-  s205 :: SBool = s88 /= s204-  s206 :: SWord16 = s30 + s78-  s207 :: SBool = s11 /= s206-  s208 :: SBool = s9 /= s206-  s209 :: SBool = s7 /= s206-  s210 :: SBool = s5 /= s206-  s211 :: SBool = s3 /= s206-  s212 :: SWord16 = s87 + s96-  s213 :: SBool = s88 /= s212-  s214 :: SWord16 = s42 + s78-  s215 :: SBool = s11 /= s214-  s216 :: SBool = s9 /= s214-  s217 :: SBool = s7 /= s214-  s218 :: SBool = s5 /= s214-  s219 :: SBool = s3 /= s214-  s220 :: SWord16 = s87 + s105-  s221 :: SBool = s88 /= s220-  s222 :: SWord16 = s54 + s78-  s223 :: SBool = s11 /= s222-  s224 :: SBool = s9 /= s222-  s225 :: SBool = s7 /= s222-  s226 :: SBool = s5 /= s222-  s227 :: SBool = s3 /= s222-  s228 :: SWord16 = s87 + s114-  s229 :: SBool = s88 /= s228-  s230 :: SWord16 = s66 + s78-  s231 :: SBool = s11 /= s230-  s232 :: SBool = s9 /= s230-  s233 :: SBool = s7 /= s230-  s234 :: SBool = s5 /= s230-  s235 :: SBool = s3 /= s230-  s236 :: SWord16 = s87 + s123-  s237 :: SBool = s88 /= s236-  s238 :: SWord16 = s42 + s90-  s239 :: SBool = s11 /= s238-  s240 :: SBool = s9 /= s238-  s241 :: SBool = s7 /= s238-  s242 :: SBool = s5 /= s238-  s243 :: SBool = s3 /= s238-  s244 :: SWord16 = s97 + s105-  s245 :: SBool = s88 /= s244-  s246 :: SWord16 = s54 + s90-  s247 :: SBool = s11 /= s246-  s248 :: SBool = s9 /= s246-  s249 :: SBool = s7 /= s246-  s250 :: SBool = s5 /= s246-  s251 :: SBool = s3 /= s246-  s252 :: SWord16 = s97 + s114-  s253 :: SBool = s88 /= s252-  s254 :: SWord16 = s66 + s90-  s255 :: SBool = s11 /= s254-  s256 :: SBool = s9 /= s254-  s257 :: SBool = s7 /= s254-  s258 :: SBool = s5 /= s254-  s259 :: SBool = s3 /= s254-  s260 :: SWord16 = s97 + s123-  s261 :: SBool = s88 /= s260-  s262 :: SWord16 = s54 + s99-  s263 :: SBool = s11 /= s262-  s264 :: SBool = s9 /= s262-  s265 :: SBool = s7 /= s262-  s266 :: SBool = s5 /= s262-  s267 :: SBool = s3 /= s262-  s268 :: SWord16 = s106 + s114-  s269 :: SBool = s88 /= s268-  s270 :: SWord16 = s66 + s99-  s271 :: SBool = s11 /= s270-  s272 :: SBool = s9 /= s270-  s273 :: SBool = s7 /= s270-  s274 :: SBool = s5 /= s270-  s275 :: SBool = s3 /= s270-  s276 :: SWord16 = s106 + s123-  s277 :: SBool = s88 /= s276-  s278 :: SWord16 = s66 + s108-  s279 :: SBool = s11 /= s278-  s280 :: SBool = s9 /= s278-  s281 :: SBool = s7 /= s278-  s282 :: SBool = s5 /= s278-  s283 :: SBool = s3 /= s278-  s284 :: SWord16 = s115 + s123-  s285 :: SBool = s88 /= s284-  s286 :: SWord16 = s42 + s126-  s287 :: SBool = s11 /= s286-  s288 :: SBool = s9 /= s286-  s289 :: SBool = s7 /= s286-  s290 :: SBool = s5 /= s286-  s291 :: SBool = s3 /= s286-  s292 :: SWord16 = s105 + s132-  s293 :: SBool = s88 /= s292-  s294 :: SWord16 = s54 + s126-  s295 :: SBool = s11 /= s294-  s296 :: SBool = s9 /= s294-  s297 :: SBool = s7 /= s294-  s298 :: SBool = s5 /= s294-  s299 :: SBool = s3 /= s294-  s300 :: SWord16 = s114 + s132-  s301 :: SBool = s88 /= s300-  s302 :: SWord16 = s66 + s126-  s303 :: SBool = s11 /= s302-  s304 :: SBool = s9 /= s302-  s305 :: SBool = s7 /= s302-  s306 :: SBool = s5 /= s302-  s307 :: SBool = s3 /= s302-  s308 :: SWord16 = s123 + s132-  s309 :: SBool = s88 /= s308-  s310 :: SWord16 = s54 + s134-  s311 :: SBool = s11 /= s310-  s312 :: SBool = s9 /= s310-  s313 :: SBool = s7 /= s310-  s314 :: SBool = s5 /= s310-  s315 :: SBool = s3 /= s310-  s316 :: SWord16 = s114 + s140-  s317 :: SBool = s88 /= s316-  s318 :: SWord16 = s66 + s134-  s319 :: SBool = s11 /= s318-  s320 :: SBool = s9 /= s318-  s321 :: SBool = s7 /= s318-  s322 :: SBool = s5 /= s318-  s323 :: SBool = s3 /= s318-  s324 :: SWord16 = s123 + s140-  s325 :: SBool = s88 /= s324-  s326 :: SWord16 = s66 + s142-  s327 :: SBool = s11 /= s326-  s328 :: SBool = s9 /= s326-  s329 :: SBool = s7 /= s326-  s330 :: SBool = s5 /= s326-  s331 :: SBool = s3 /= s326-  s332 :: SWord16 = s123 + s148-  s333 :: SBool = s88 /= s332-  s334 :: SWord16 = s54 + s158-  s335 :: SBool = s11 /= s334-  s336 :: SBool = s9 /= s334-  s337 :: SBool = s7 /= s334-  s338 :: SBool = s5 /= s334-  s339 :: SBool = s3 /= s334-  s340 :: SWord16 = s114 + s164-  s341 :: SBool = s88 /= s340-  s342 :: SWord16 = s66 + s158-  s343 :: SBool = s11 /= s342-  s344 :: SBool = s9 /= s342-  s345 :: SBool = s7 /= s342-  s346 :: SBool = s5 /= s342-  s347 :: SBool = s3 /= s342-  s348 :: SWord16 = s123 + s164-  s349 :: SBool = s88 /= s348-  s350 :: SWord16 = s66 + s166-  s351 :: SBool = s11 /= s350-  s352 :: SBool = s9 /= s350-  s353 :: SBool = s7 /= s350-  s354 :: SBool = s5 /= s350-  s355 :: SBool = s3 /= s350-  s356 :: SWord16 = s123 + s172-  s357 :: SBool = s88 /= s356-  s358 :: SWord16 = s66 + s182-  s359 :: SBool = s11 /= s358-  s360 :: SBool = s9 /= s358-  s361 :: SBool = s7 /= s358-  s362 :: SBool = s5 /= s358-  s363 :: SBool = s3 /= s358-  s364 :: SWord16 = s123 + s188-  s365 :: SBool = s88 /= s364-  s366 :: SWord16 = s42 + s206-  s367 :: SBool = s11 /= s366-  s368 :: SBool = s9 /= s366-  s369 :: SBool = s7 /= s366-  s370 :: SBool = s5 /= s366-  s371 :: SBool = s3 /= s366-  s372 :: SWord16 = s105 + s212-  s373 :: SBool = s88 /= s372-  s374 :: SWord16 = s54 + s206-  s375 :: SBool = s11 /= s374-  s376 :: SBool = s9 /= s374-  s377 :: SBool = s7 /= s374-  s378 :: SBool = s5 /= s374-  s379 :: SBool = s3 /= s374-  s380 :: SWord16 = s114 + s212-  s381 :: SBool = s88 /= s380-  s382 :: SWord16 = s66 + s206-  s383 :: SBool = s11 /= s382-  s384 :: SBool = s9 /= s382-  s385 :: SBool = s7 /= s382-  s386 :: SBool = s5 /= s382-  s387 :: SBool = s3 /= s382-  s388 :: SWord16 = s123 + s212-  s389 :: SBool = s88 /= s388-  s390 :: SWord16 = s54 + s214-  s391 :: SBool = s11 /= s390-  s392 :: SBool = s9 /= s390-  s393 :: SBool = s7 /= s390-  s394 :: SBool = s5 /= s390-  s395 :: SBool = s3 /= s390-  s396 :: SWord16 = s114 + s220-  s397 :: SBool = s88 /= s396-  s398 :: SWord16 = s66 + s214-  s399 :: SBool = s11 /= s398-  s400 :: SBool = s9 /= s398-  s401 :: SBool = s7 /= s398-  s402 :: SBool = s5 /= s398-  s403 :: SBool = s3 /= s398-  s404 :: SWord16 = s123 + s220-  s405 :: SBool = s88 /= s404-  s406 :: SWord16 = s66 + s222-  s407 :: SBool = s11 /= s406-  s408 :: SBool = s9 /= s406-  s409 :: SBool = s7 /= s406-  s410 :: SBool = s5 /= s406-  s411 :: SBool = s3 /= s406-  s412 :: SWord16 = s123 + s228-  s413 :: SBool = s88 /= s412-  s414 :: SWord16 = s54 + s238-  s415 :: SBool = s11 /= s414-  s416 :: SBool = s9 /= s414-  s417 :: SBool = s7 /= s414-  s418 :: SBool = s5 /= s414-  s419 :: SBool = s3 /= s414-  s420 :: SWord16 = s114 + s244-  s421 :: SBool = s88 /= s420-  s422 :: SWord16 = s66 + s238-  s423 :: SBool = s11 /= s422-  s424 :: SBool = s9 /= s422-  s425 :: SBool = s7 /= s422-  s426 :: SBool = s5 /= s422-  s427 :: SBool = s3 /= s422-  s428 :: SWord16 = s123 + s244-  s429 :: SBool = s88 /= s428-  s430 :: SWord16 = s66 + s246-  s431 :: SBool = s11 /= s430-  s432 :: SBool = s9 /= s430-  s433 :: SBool = s7 /= s430-  s434 :: SBool = s5 /= s430-  s435 :: SBool = s3 /= s430-  s436 :: SWord16 = s123 + s252-  s437 :: SBool = s88 /= s436-  s438 :: SWord16 = s66 + s262-  s439 :: SBool = s11 /= s438-  s440 :: SBool = s9 /= s438-  s441 :: SBool = s7 /= s438-  s442 :: SBool = s5 /= s438-  s443 :: SBool = s3 /= s438-  s444 :: SWord16 = s123 + s268-  s445 :: SBool = s88 /= s444-  s446 :: SWord16 = s54 + s286-  s447 :: SBool = s11 /= s446-  s448 :: SBool = s9 /= s446-  s449 :: SBool = s7 /= s446-  s450 :: SBool = s5 /= s446-  s451 :: SBool = s3 /= s446-  s452 :: SWord16 = s114 + s292-  s453 :: SBool = s88 /= s452-  s454 :: SWord16 = s66 + s286-  s455 :: SBool = s11 /= s454-  s456 :: SBool = s9 /= s454-  s457 :: SBool = s7 /= s454-  s458 :: SBool = s5 /= s454-  s459 :: SBool = s3 /= s454-  s460 :: SWord16 = s123 + s292-  s461 :: SBool = s88 /= s460-  s462 :: SWord16 = s66 + s294-  s463 :: SBool = s11 /= s462-  s464 :: SBool = s9 /= s462-  s465 :: SBool = s7 /= s462-  s466 :: SBool = s5 /= s462-  s467 :: SBool = s3 /= s462-  s468 :: SWord16 = s123 + s300-  s469 :: SBool = s88 /= s468-  s470 :: SWord16 = s66 + s310-  s471 :: SBool = s11 /= s470-  s472 :: SBool = s9 /= s470-  s473 :: SBool = s7 /= s470-  s474 :: SBool = s5 /= s470-  s475 :: SBool = s3 /= s470-  s476 :: SWord16 = s123 + s316-  s477 :: SBool = s88 /= s476-  s478 :: SWord16 = s66 + s334-  s479 :: SBool = s11 /= s478-  s480 :: SBool = s9 /= s478-  s481 :: SBool = s7 /= s478-  s482 :: SBool = s5 /= s478-  s483 :: SBool = s3 /= s478-  s484 :: SWord16 = s123 + s340-  s485 :: SBool = s88 /= s484-  s486 :: SWord16 = s54 + s366-  s487 :: SBool = s11 /= s486-  s488 :: SBool = s9 /= s486-  s489 :: SBool = s7 /= s486-  s490 :: SBool = s5 /= s486-  s491 :: SBool = s3 /= s486-  s492 :: SWord16 = s114 + s372-  s493 :: SBool = s88 /= s492-  s494 :: SWord16 = s66 + s366-  s495 :: SBool = s11 /= s494-  s496 :: SBool = s9 /= s494-  s497 :: SBool = s7 /= s494-  s498 :: SBool = s5 /= s494-  s499 :: SBool = s3 /= s494-  s500 :: SWord16 = s123 + s372-  s501 :: SBool = s88 /= s500-  s502 :: SWord16 = s66 + s374-  s503 :: SBool = s11 /= s502-  s504 :: SBool = s9 /= s502-  s505 :: SBool = s7 /= s502-  s506 :: SBool = s5 /= s502-  s507 :: SBool = s3 /= s502-  s508 :: SWord16 = s123 + s380-  s509 :: SBool = s88 /= s508-  s510 :: SWord16 = s66 + s390-  s511 :: SBool = s11 /= s510-  s512 :: SBool = s9 /= s510-  s513 :: SBool = s7 /= s510-  s514 :: SBool = s5 /= s510-  s515 :: SBool = s3 /= s510-  s516 :: SWord16 = s123 + s396-  s517 :: SBool = s88 /= s516-  s518 :: SWord16 = s66 + s414-  s519 :: SBool = s11 /= s518-  s520 :: SBool = s9 /= s518-  s521 :: SBool = s7 /= s518-  s522 :: SBool = s5 /= s518-  s523 :: SBool = s3 /= s518-  s524 :: SWord16 = s123 + s420-  s525 :: SBool = s88 /= s524-  s526 :: SWord16 = s66 + s446-  s527 :: SBool = s11 /= s526-  s528 :: SBool = s9 /= s526-  s529 :: SBool = s7 /= s526-  s530 :: SBool = s5 /= s526-  s531 :: SBool = s3 /= s526-  s532 :: SWord16 = s123 + s452-  s533 :: SBool = s88 /= s532-  s534 :: SWord16 = s66 + s486-  s535 :: SBool = s11 /= s534-  s536 :: SBool = s9 /= s534-  s537 :: SBool = s7 /= s534-  s538 :: SBool = s5 /= s534-  s539 :: SBool = s3 /= s534-  s540 :: SWord16 = s123 + s492-  s541 :: SBool = s88 /= s540-  s542 :: SBool = s0 >= s18-  s543 :: SBool = s18 >= s30-  s544 :: SBool = s30 >= s42-  s545 :: SBool = s42 >= s54-  s546 :: SBool = s54 >= s66-  s547 :: SBool = s545 & s546-  s548 :: SBool = s544 & s547-  s549 :: SBool = s543 & s548-  s550 :: SBool = s542 & s549-  s552 :: SBool = s534 == s551-CONSTRAINTS-  s17-  s29-  s41-  s53-  s65-  s77-  s79-  s80-  s81-  s82-  s83-  s89-  s91-  s92-  s93-  s94-  s95-  s98-  s100-  s101-  s102-  s103-  s104-  s107-  s109-  s110-  s111-  s112-  s113-  s116-  s118-  s119-  s120-  s121-  s122-  s125-  s127-  s128-  s129-  s130-  s131-  s133-  s135-  s136-  s137-  s138-  s139-  s141-  s143-  s144-  s145-  s146-  s147-  s149-  s151-  s152-  s153-  s154-  s155-  s157-  s159-  s160-  s161-  s162-  s163-  s165-  s167-  s168-  s169-  s170-  s171-  s173-  s175-  s176-  s177-  s178-  s179-  s181-  s183-  s184-  s185-  s186-  s187-  s189-  s191-  s192-  s193-  s194-  s195-  s197-  s199-  s200-  s201-  s202-  s203-  s205-  s207-  s208-  s209-  s210-  s211-  s213-  s215-  s216-  s217-  s218-  s219-  s221-  s223-  s224-  s225-  s226-  s227-  s229-  s231-  s232-  s233-  s234-  s235-  s237-  s239-  s240-  s241-  s242-  s243-  s245-  s247-  s248-  s249-  s250-  s251-  s253-  s255-  s256-  s257-  s258-  s259-  s261-  s263-  s264-  s265-  s266-  s267-  s269-  s271-  s272-  s273-  s274-  s275-  s277-  s279-  s280-  s281-  s282-  s283-  s285-  s287-  s288-  s289-  s290-  s291-  s293-  s295-  s296-  s297-  s298-  s299-  s301-  s303-  s304-  s305-  s306-  s307-  s309-  s311-  s312-  s313-  s314-  s315-  s317-  s319-  s320-  s321-  s322-  s323-  s325-  s327-  s328-  s329-  s330-  s331-  s333-  s335-  s336-  s337-  s338-  s339-  s341-  s343-  s344-  s345-  s346-  s347-  s349-  s351-  s352-  s353-  s354-  s355-  s357-  s359-  s360-  s361-  s362-  s363-  s365-  s367-  s368-  s369-  s370-  s371-  s373-  s375-  s376-  s377-  s378-  s379-  s381-  s383-  s384-  s385-  s386-  s387-  s389-  s391-  s392-  s393-  s394-  s395-  s397-  s399-  s400-  s401-  s402-  s403-  s405-  s407-  s408-  s409-  s410-  s411-  s413-  s415-  s416-  s417-  s418-  s419-  s421-  s423-  s424-  s425-  s426-  s427-  s429-  s431-  s432-  s433-  s434-  s435-  s437-  s439-  s440-  s441-  s442-  s443-  s445-  s447-  s448-  s449-  s450-  s451-  s453-  s455-  s456-  s457-  s458-  s459-  s461-  s463-  s464-  s465-  s466-  s467-  s469-  s471-  s472-  s473-  s474-  s475-  s477-  s479-  s480-  s481-  s482-  s483-  s485-  s487-  s488-  s489-  s490-  s491-  s493-  s495-  s496-  s497-  s498-  s499-  s501-  s503-  s504-  s505-  s506-  s507-  s509-  s511-  s512-  s513-  s514-  s515-  s517-  s519-  s520-  s521-  s522-  s523-  s525-  s527-  s528-  s529-  s530-  s531-  s533-  s535-  s536-  s537-  s538-  s539-  s541-  s550-ASSERTIONS-OUTPUTS-  s552
− SBVUnitTest/GoldFiles/counts.gold 
@@ -1,1707 +0,0 @@-INPUTS-  s0 :: SWord8-  s1 :: SWord8-  s2 :: SWord8-  s3 :: SWord8-  s4 :: SWord8-  s5 :: SWord8-  s6 :: SWord8-  s7 :: SWord8-  s8 :: SWord8-  s9 :: SWord8-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s10 = 10 :: Word8-  s12 = 0 :: Word8-  s32 = 2 :: Word8-  s33 = 1 :: Word8-  s35 = 100 :: Word8-  s555 = 3 :: Word8-  s716 = 4 :: Word8-  s877 = 5 :: Word8-  s1038 = 6 :: Word8-  s1199 = 7 :: Word8-  s1360 = 8 :: Word8-  s1521 = 9 :: Word8-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s11 :: SBool = s9 < s10-  s13 :: SBool = s9 == s12-  s14 :: SBool = s8 < s10-  s15 :: SBool = s8 == s12-  s16 :: SBool = s7 < s10-  s17 :: SBool = s7 == s12-  s18 :: SBool = s6 < s10-  s19 :: SBool = s6 == s12-  s20 :: SBool = s5 < s10-  s21 :: SBool = s5 == s12-  s22 :: SBool = s4 < s10-  s23 :: SBool = s4 == s12-  s24 :: SBool = s3 < s10-  s25 :: SBool = s3 == s12-  s26 :: SBool = s2 < s10-  s27 :: SBool = s2 == s12-  s28 :: SBool = s1 < s10-  s29 :: SBool = s1 == s12-  s30 :: SBool = s0 < s10-  s31 :: SBool = s0 == s12-  s34 :: SWord8 = if s31 then s32 else s33-  s36 :: SBool = s0 < s35-  s37 :: SWord8 = s0 rem s10-  s38 :: SBool = s12 == s37-  s39 :: SWord8 = s0 quot s10-  s40 :: SWord8 = s39 rem s10-  s41 :: SBool = s12 == s40-  s42 :: SWord8 = if s41 then s32 else s33-  s43 :: SWord8 = s33 + s42-  s44 :: SWord8 = if s38 then s43 else s42-  s45 :: SWord8 = s39 quot s10-  s46 :: SBool = s12 == s45-  s47 :: SWord8 = if s46 then s32 else s33-  s48 :: SWord8 = s33 + s47-  s49 :: SWord8 = if s41 then s48 else s47-  s50 :: SWord8 = s33 + s49-  s51 :: SWord8 = if s38 then s50 else s49-  s52 :: SWord8 = if s36 then s44 else s51-  s53 :: SWord8 = if s30 then s34 else s52-  s54 :: SWord8 = s33 + s53-  s55 :: SWord8 = if s29 then s54 else s53-  s56 :: SBool = s1 < s35-  s57 :: SWord8 = s1 rem s10-  s58 :: SBool = s12 == s57-  s59 :: SWord8 = s1 quot s10-  s60 :: SWord8 = s59 rem s10-  s61 :: SBool = s12 == s60-  s62 :: SWord8 = if s61 then s54 else s53-  s63 :: SWord8 = s33 + s62-  s64 :: SWord8 = if s58 then s63 else s62-  s65 :: SWord8 = s59 quot s10-  s66 :: SBool = s12 == s65-  s67 :: SWord8 = if s66 then s54 else s53-  s68 :: SWord8 = s33 + s67-  s69 :: SWord8 = if s61 then s68 else s67-  s70 :: SWord8 = s33 + s69-  s71 :: SWord8 = if s58 then s70 else s69-  s72 :: SWord8 = if s56 then s64 else s71-  s73 :: SWord8 = if s28 then s55 else s72-  s74 :: SWord8 = s33 + s73-  s75 :: SWord8 = if s27 then s74 else s73-  s76 :: SBool = s2 < s35-  s77 :: SWord8 = s2 rem s10-  s78 :: SBool = s12 == s77-  s79 :: SWord8 = s2 quot s10-  s80 :: SWord8 = s79 rem s10-  s81 :: SBool = s12 == s80-  s82 :: SWord8 = if s81 then s74 else s73-  s83 :: SWord8 = s33 + s82-  s84 :: SWord8 = if s78 then s83 else s82-  s85 :: SWord8 = s79 quot s10-  s86 :: SBool = s12 == s85-  s87 :: SWord8 = if s86 then s74 else s73-  s88 :: SWord8 = s33 + s87-  s89 :: SWord8 = if s81 then s88 else s87-  s90 :: SWord8 = s33 + s89-  s91 :: SWord8 = if s78 then s90 else s89-  s92 :: SWord8 = if s76 then s84 else s91-  s93 :: SWord8 = if s26 then s75 else s92-  s94 :: SWord8 = s33 + s93-  s95 :: SWord8 = if s25 then s94 else s93-  s96 :: SBool = s3 < s35-  s97 :: SWord8 = s3 rem s10-  s98 :: SBool = s12 == s97-  s99 :: SWord8 = s3 quot s10-  s100 :: SWord8 = s99 rem s10-  s101 :: SBool = s12 == s100-  s102 :: SWord8 = if s101 then s94 else s93-  s103 :: SWord8 = s33 + s102-  s104 :: SWord8 = if s98 then s103 else s102-  s105 :: SWord8 = s99 quot s10-  s106 :: SBool = s12 == s105-  s107 :: SWord8 = if s106 then s94 else s93-  s108 :: SWord8 = s33 + s107-  s109 :: SWord8 = if s101 then s108 else s107-  s110 :: SWord8 = s33 + s109-  s111 :: SWord8 = if s98 then s110 else s109-  s112 :: SWord8 = if s96 then s104 else s111-  s113 :: SWord8 = if s24 then s95 else s112-  s114 :: SWord8 = s33 + s113-  s115 :: SWord8 = if s23 then s114 else s113-  s116 :: SBool = s4 < s35-  s117 :: SWord8 = s4 rem s10-  s118 :: SBool = s12 == s117-  s119 :: SWord8 = s4 quot s10-  s120 :: SWord8 = s119 rem s10-  s121 :: SBool = s12 == s120-  s122 :: SWord8 = if s121 then s114 else s113-  s123 :: SWord8 = s33 + s122-  s124 :: SWord8 = if s118 then s123 else s122-  s125 :: SWord8 = s119 quot s10-  s126 :: SBool = s12 == s125-  s127 :: SWord8 = if s126 then s114 else s113-  s128 :: SWord8 = s33 + s127-  s129 :: SWord8 = if s121 then s128 else s127-  s130 :: SWord8 = s33 + s129-  s131 :: SWord8 = if s118 then s130 else s129-  s132 :: SWord8 = if s116 then s124 else s131-  s133 :: SWord8 = if s22 then s115 else s132-  s134 :: SWord8 = s33 + s133-  s135 :: SWord8 = if s21 then s134 else s133-  s136 :: SBool = s5 < s35-  s137 :: SWord8 = s5 rem s10-  s138 :: SBool = s12 == s137-  s139 :: SWord8 = s5 quot s10-  s140 :: SWord8 = s139 rem s10-  s141 :: SBool = s12 == s140-  s142 :: SWord8 = if s141 then s134 else s133-  s143 :: SWord8 = s33 + s142-  s144 :: SWord8 = if s138 then s143 else s142-  s145 :: SWord8 = s139 quot s10-  s146 :: SBool = s12 == s145-  s147 :: SWord8 = if s146 then s134 else s133-  s148 :: SWord8 = s33 + s147-  s149 :: SWord8 = if s141 then s148 else s147-  s150 :: SWord8 = s33 + s149-  s151 :: SWord8 = if s138 then s150 else s149-  s152 :: SWord8 = if s136 then s144 else s151-  s153 :: SWord8 = if s20 then s135 else s152-  s154 :: SWord8 = s33 + s153-  s155 :: SWord8 = if s19 then s154 else s153-  s156 :: SBool = s6 < s35-  s157 :: SWord8 = s6 rem s10-  s158 :: SBool = s12 == s157-  s159 :: SWord8 = s6 quot s10-  s160 :: SWord8 = s159 rem s10-  s161 :: SBool = s12 == s160-  s162 :: SWord8 = if s161 then s154 else s153-  s163 :: SWord8 = s33 + s162-  s164 :: SWord8 = if s158 then s163 else s162-  s165 :: SWord8 = s159 quot s10-  s166 :: SBool = s12 == s165-  s167 :: SWord8 = if s166 then s154 else s153-  s168 :: SWord8 = s33 + s167-  s169 :: SWord8 = if s161 then s168 else s167-  s170 :: SWord8 = s33 + s169-  s171 :: SWord8 = if s158 then s170 else s169-  s172 :: SWord8 = if s156 then s164 else s171-  s173 :: SWord8 = if s18 then s155 else s172-  s174 :: SWord8 = s33 + s173-  s175 :: SWord8 = if s17 then s174 else s173-  s176 :: SBool = s7 < s35-  s177 :: SWord8 = s7 rem s10-  s178 :: SBool = s12 == s177-  s179 :: SWord8 = s7 quot s10-  s180 :: SWord8 = s179 rem s10-  s181 :: SBool = s12 == s180-  s182 :: SWord8 = if s181 then s174 else s173-  s183 :: SWord8 = s33 + s182-  s184 :: SWord8 = if s178 then s183 else s182-  s185 :: SWord8 = s179 quot s10-  s186 :: SBool = s12 == s185-  s187 :: SWord8 = if s186 then s174 else s173-  s188 :: SWord8 = s33 + s187-  s189 :: SWord8 = if s181 then s188 else s187-  s190 :: SWord8 = s33 + s189-  s191 :: SWord8 = if s178 then s190 else s189-  s192 :: SWord8 = if s176 then s184 else s191-  s193 :: SWord8 = if s16 then s175 else s192-  s194 :: SWord8 = s33 + s193-  s195 :: SWord8 = if s15 then s194 else s193-  s196 :: SBool = s8 < s35-  s197 :: SWord8 = s8 rem s10-  s198 :: SBool = s12 == s197-  s199 :: SWord8 = s8 quot s10-  s200 :: SWord8 = s199 rem s10-  s201 :: SBool = s12 == s200-  s202 :: SWord8 = if s201 then s194 else s193-  s203 :: SWord8 = s33 + s202-  s204 :: SWord8 = if s198 then s203 else s202-  s205 :: SWord8 = s199 quot s10-  s206 :: SBool = s12 == s205-  s207 :: SWord8 = if s206 then s194 else s193-  s208 :: SWord8 = s33 + s207-  s209 :: SWord8 = if s201 then s208 else s207-  s210 :: SWord8 = s33 + s209-  s211 :: SWord8 = if s198 then s210 else s209-  s212 :: SWord8 = if s196 then s204 else s211-  s213 :: SWord8 = if s14 then s195 else s212-  s214 :: SWord8 = s33 + s213-  s215 :: SWord8 = if s13 then s214 else s213-  s216 :: SBool = s9 < s35-  s217 :: SWord8 = s9 rem s10-  s218 :: SBool = s12 == s217-  s219 :: SWord8 = s9 quot s10-  s220 :: SWord8 = s219 rem s10-  s221 :: SBool = s12 == s220-  s222 :: SWord8 = if s221 then s214 else s213-  s223 :: SWord8 = s33 + s222-  s224 :: SWord8 = if s218 then s223 else s222-  s225 :: SWord8 = s219 quot s10-  s226 :: SBool = s12 == s225-  s227 :: SWord8 = if s226 then s214 else s213-  s228 :: SWord8 = s33 + s227-  s229 :: SWord8 = if s221 then s228 else s227-  s230 :: SWord8 = s33 + s229-  s231 :: SWord8 = if s218 then s230 else s229-  s232 :: SWord8 = if s216 then s224 else s231-  s233 :: SWord8 = if s11 then s215 else s232-  s234 :: SBool = s0 == s233-  s235 :: SBool = s9 == s33-  s236 :: SBool = s8 == s33-  s237 :: SBool = s7 == s33-  s238 :: SBool = s6 == s33-  s239 :: SBool = s5 == s33-  s240 :: SBool = s4 == s33-  s241 :: SBool = s3 == s33-  s242 :: SBool = s2 == s33-  s243 :: SBool = s1 == s33-  s244 :: SBool = s0 == s33-  s245 :: SWord8 = if s244 then s32 else s33-  s246 :: SBool = s33 == s37-  s247 :: SBool = s33 == s40-  s248 :: SWord8 = if s247 then s32 else s33-  s249 :: SWord8 = s33 + s248-  s250 :: SWord8 = if s246 then s249 else s248-  s251 :: SBool = s33 == s45-  s252 :: SWord8 = if s251 then s32 else s33-  s253 :: SWord8 = s33 + s252-  s254 :: SWord8 = if s247 then s253 else s252-  s255 :: SWord8 = s33 + s254-  s256 :: SWord8 = if s246 then s255 else s254-  s257 :: SWord8 = if s36 then s250 else s256-  s258 :: SWord8 = if s30 then s245 else s257-  s259 :: SWord8 = s33 + s258-  s260 :: SWord8 = if s243 then s259 else s258-  s261 :: SBool = s33 == s57-  s262 :: SBool = s33 == s60-  s263 :: SWord8 = if s262 then s259 else s258-  s264 :: SWord8 = s33 + s263-  s265 :: SWord8 = if s261 then s264 else s263-  s266 :: SBool = s33 == s65-  s267 :: SWord8 = if s266 then s259 else s258-  s268 :: SWord8 = s33 + s267-  s269 :: SWord8 = if s262 then s268 else s267-  s270 :: SWord8 = s33 + s269-  s271 :: SWord8 = if s261 then s270 else s269-  s272 :: SWord8 = if s56 then s265 else s271-  s273 :: SWord8 = if s28 then s260 else s272-  s274 :: SWord8 = s33 + s273-  s275 :: SWord8 = if s242 then s274 else s273-  s276 :: SBool = s33 == s77-  s277 :: SBool = s33 == s80-  s278 :: SWord8 = if s277 then s274 else s273-  s279 :: SWord8 = s33 + s278-  s280 :: SWord8 = if s276 then s279 else s278-  s281 :: SBool = s33 == s85-  s282 :: SWord8 = if s281 then s274 else s273-  s283 :: SWord8 = s33 + s282-  s284 :: SWord8 = if s277 then s283 else s282-  s285 :: SWord8 = s33 + s284-  s286 :: SWord8 = if s276 then s285 else s284-  s287 :: SWord8 = if s76 then s280 else s286-  s288 :: SWord8 = if s26 then s275 else s287-  s289 :: SWord8 = s33 + s288-  s290 :: SWord8 = if s241 then s289 else s288-  s291 :: SBool = s33 == s97-  s292 :: SBool = s33 == s100-  s293 :: SWord8 = if s292 then s289 else s288-  s294 :: SWord8 = s33 + s293-  s295 :: SWord8 = if s291 then s294 else s293-  s296 :: SBool = s33 == s105-  s297 :: SWord8 = if s296 then s289 else s288-  s298 :: SWord8 = s33 + s297-  s299 :: SWord8 = if s292 then s298 else s297-  s300 :: SWord8 = s33 + s299-  s301 :: SWord8 = if s291 then s300 else s299-  s302 :: SWord8 = if s96 then s295 else s301-  s303 :: SWord8 = if s24 then s290 else s302-  s304 :: SWord8 = s33 + s303-  s305 :: SWord8 = if s240 then s304 else s303-  s306 :: SBool = s33 == s117-  s307 :: SBool = s33 == s120-  s308 :: SWord8 = if s307 then s304 else s303-  s309 :: SWord8 = s33 + s308-  s310 :: SWord8 = if s306 then s309 else s308-  s311 :: SBool = s33 == s125-  s312 :: SWord8 = if s311 then s304 else s303-  s313 :: SWord8 = s33 + s312-  s314 :: SWord8 = if s307 then s313 else s312-  s315 :: SWord8 = s33 + s314-  s316 :: SWord8 = if s306 then s315 else s314-  s317 :: SWord8 = if s116 then s310 else s316-  s318 :: SWord8 = if s22 then s305 else s317-  s319 :: SWord8 = s33 + s318-  s320 :: SWord8 = if s239 then s319 else s318-  s321 :: SBool = s33 == s137-  s322 :: SBool = s33 == s140-  s323 :: SWord8 = if s322 then s319 else s318-  s324 :: SWord8 = s33 + s323-  s325 :: SWord8 = if s321 then s324 else s323-  s326 :: SBool = s33 == s145-  s327 :: SWord8 = if s326 then s319 else s318-  s328 :: SWord8 = s33 + s327-  s329 :: SWord8 = if s322 then s328 else s327-  s330 :: SWord8 = s33 + s329-  s331 :: SWord8 = if s321 then s330 else s329-  s332 :: SWord8 = if s136 then s325 else s331-  s333 :: SWord8 = if s20 then s320 else s332-  s334 :: SWord8 = s33 + s333-  s335 :: SWord8 = if s238 then s334 else s333-  s336 :: SBool = s33 == s157-  s337 :: SBool = s33 == s160-  s338 :: SWord8 = if s337 then s334 else s333-  s339 :: SWord8 = s33 + s338-  s340 :: SWord8 = if s336 then s339 else s338-  s341 :: SBool = s33 == s165-  s342 :: SWord8 = if s341 then s334 else s333-  s343 :: SWord8 = s33 + s342-  s344 :: SWord8 = if s337 then s343 else s342-  s345 :: SWord8 = s33 + s344-  s346 :: SWord8 = if s336 then s345 else s344-  s347 :: SWord8 = if s156 then s340 else s346-  s348 :: SWord8 = if s18 then s335 else s347-  s349 :: SWord8 = s33 + s348-  s350 :: SWord8 = if s237 then s349 else s348-  s351 :: SBool = s33 == s177-  s352 :: SBool = s33 == s180-  s353 :: SWord8 = if s352 then s349 else s348-  s354 :: SWord8 = s33 + s353-  s355 :: SWord8 = if s351 then s354 else s353-  s356 :: SBool = s33 == s185-  s357 :: SWord8 = if s356 then s349 else s348-  s358 :: SWord8 = s33 + s357-  s359 :: SWord8 = if s352 then s358 else s357-  s360 :: SWord8 = s33 + s359-  s361 :: SWord8 = if s351 then s360 else s359-  s362 :: SWord8 = if s176 then s355 else s361-  s363 :: SWord8 = if s16 then s350 else s362-  s364 :: SWord8 = s33 + s363-  s365 :: SWord8 = if s236 then s364 else s363-  s366 :: SBool = s33 == s197-  s367 :: SBool = s33 == s200-  s368 :: SWord8 = if s367 then s364 else s363-  s369 :: SWord8 = s33 + s368-  s370 :: SWord8 = if s366 then s369 else s368-  s371 :: SBool = s33 == s205-  s372 :: SWord8 = if s371 then s364 else s363-  s373 :: SWord8 = s33 + s372-  s374 :: SWord8 = if s367 then s373 else s372-  s375 :: SWord8 = s33 + s374-  s376 :: SWord8 = if s366 then s375 else s374-  s377 :: SWord8 = if s196 then s370 else s376-  s378 :: SWord8 = if s14 then s365 else s377-  s379 :: SWord8 = s33 + s378-  s380 :: SWord8 = if s235 then s379 else s378-  s381 :: SBool = s33 == s217-  s382 :: SBool = s33 == s220-  s383 :: SWord8 = if s382 then s379 else s378-  s384 :: SWord8 = s33 + s383-  s385 :: SWord8 = if s381 then s384 else s383-  s386 :: SBool = s33 == s225-  s387 :: SWord8 = if s386 then s379 else s378-  s388 :: SWord8 = s33 + s387-  s389 :: SWord8 = if s382 then s388 else s387-  s390 :: SWord8 = s33 + s389-  s391 :: SWord8 = if s381 then s390 else s389-  s392 :: SWord8 = if s216 then s385 else s391-  s393 :: SWord8 = if s11 then s380 else s392-  s394 :: SBool = s1 == s393-  s395 :: SBool = s9 == s32-  s396 :: SBool = s8 == s32-  s397 :: SBool = s7 == s32-  s398 :: SBool = s6 == s32-  s399 :: SBool = s5 == s32-  s400 :: SBool = s4 == s32-  s401 :: SBool = s3 == s32-  s402 :: SBool = s2 == s32-  s403 :: SBool = s1 == s32-  s404 :: SBool = s0 == s32-  s405 :: SWord8 = if s404 then s32 else s33-  s406 :: SBool = s32 == s37-  s407 :: SBool = s32 == s40-  s408 :: SWord8 = if s407 then s32 else s33-  s409 :: SWord8 = s33 + s408-  s410 :: SWord8 = if s406 then s409 else s408-  s411 :: SBool = s32 == s45-  s412 :: SWord8 = if s411 then s32 else s33-  s413 :: SWord8 = s33 + s412-  s414 :: SWord8 = if s407 then s413 else s412-  s415 :: SWord8 = s33 + s414-  s416 :: SWord8 = if s406 then s415 else s414-  s417 :: SWord8 = if s36 then s410 else s416-  s418 :: SWord8 = if s30 then s405 else s417-  s419 :: SWord8 = s33 + s418-  s420 :: SWord8 = if s403 then s419 else s418-  s421 :: SBool = s32 == s57-  s422 :: SBool = s32 == s60-  s423 :: SWord8 = if s422 then s419 else s418-  s424 :: SWord8 = s33 + s423-  s425 :: SWord8 = if s421 then s424 else s423-  s426 :: SBool = s32 == s65-  s427 :: SWord8 = if s426 then s419 else s418-  s428 :: SWord8 = s33 + s427-  s429 :: SWord8 = if s422 then s428 else s427-  s430 :: SWord8 = s33 + s429-  s431 :: SWord8 = if s421 then s430 else s429-  s432 :: SWord8 = if s56 then s425 else s431-  s433 :: SWord8 = if s28 then s420 else s432-  s434 :: SWord8 = s33 + s433-  s435 :: SWord8 = if s402 then s434 else s433-  s436 :: SBool = s32 == s77-  s437 :: SBool = s32 == s80-  s438 :: SWord8 = if s437 then s434 else s433-  s439 :: SWord8 = s33 + s438-  s440 :: SWord8 = if s436 then s439 else s438-  s441 :: SBool = s32 == s85-  s442 :: SWord8 = if s441 then s434 else s433-  s443 :: SWord8 = s33 + s442-  s444 :: SWord8 = if s437 then s443 else s442-  s445 :: SWord8 = s33 + s444-  s446 :: SWord8 = if s436 then s445 else s444-  s447 :: SWord8 = if s76 then s440 else s446-  s448 :: SWord8 = if s26 then s435 else s447-  s449 :: SWord8 = s33 + s448-  s450 :: SWord8 = if s401 then s449 else s448-  s451 :: SBool = s32 == s97-  s452 :: SBool = s32 == s100-  s453 :: SWord8 = if s452 then s449 else s448-  s454 :: SWord8 = s33 + s453-  s455 :: SWord8 = if s451 then s454 else s453-  s456 :: SBool = s32 == s105-  s457 :: SWord8 = if s456 then s449 else s448-  s458 :: SWord8 = s33 + s457-  s459 :: SWord8 = if s452 then s458 else s457-  s460 :: SWord8 = s33 + s459-  s461 :: SWord8 = if s451 then s460 else s459-  s462 :: SWord8 = if s96 then s455 else s461-  s463 :: SWord8 = if s24 then s450 else s462-  s464 :: SWord8 = s33 + s463-  s465 :: SWord8 = if s400 then s464 else s463-  s466 :: SBool = s32 == s117-  s467 :: SBool = s32 == s120-  s468 :: SWord8 = if s467 then s464 else s463-  s469 :: SWord8 = s33 + s468-  s470 :: SWord8 = if s466 then s469 else s468-  s471 :: SBool = s32 == s125-  s472 :: SWord8 = if s471 then s464 else s463-  s473 :: SWord8 = s33 + s472-  s474 :: SWord8 = if s467 then s473 else s472-  s475 :: SWord8 = s33 + s474-  s476 :: SWord8 = if s466 then s475 else s474-  s477 :: SWord8 = if s116 then s470 else s476-  s478 :: SWord8 = if s22 then s465 else s477-  s479 :: SWord8 = s33 + s478-  s480 :: SWord8 = if s399 then s479 else s478-  s481 :: SBool = s32 == s137-  s482 :: SBool = s32 == s140-  s483 :: SWord8 = if s482 then s479 else s478-  s484 :: SWord8 = s33 + s483-  s485 :: SWord8 = if s481 then s484 else s483-  s486 :: SBool = s32 == s145-  s487 :: SWord8 = if s486 then s479 else s478-  s488 :: SWord8 = s33 + s487-  s489 :: SWord8 = if s482 then s488 else s487-  s490 :: SWord8 = s33 + s489-  s491 :: SWord8 = if s481 then s490 else s489-  s492 :: SWord8 = if s136 then s485 else s491-  s493 :: SWord8 = if s20 then s480 else s492-  s494 :: SWord8 = s33 + s493-  s495 :: SWord8 = if s398 then s494 else s493-  s496 :: SBool = s32 == s157-  s497 :: SBool = s32 == s160-  s498 :: SWord8 = if s497 then s494 else s493-  s499 :: SWord8 = s33 + s498-  s500 :: SWord8 = if s496 then s499 else s498-  s501 :: SBool = s32 == s165-  s502 :: SWord8 = if s501 then s494 else s493-  s503 :: SWord8 = s33 + s502-  s504 :: SWord8 = if s497 then s503 else s502-  s505 :: SWord8 = s33 + s504-  s506 :: SWord8 = if s496 then s505 else s504-  s507 :: SWord8 = if s156 then s500 else s506-  s508 :: SWord8 = if s18 then s495 else s507-  s509 :: SWord8 = s33 + s508-  s510 :: SWord8 = if s397 then s509 else s508-  s511 :: SBool = s32 == s177-  s512 :: SBool = s32 == s180-  s513 :: SWord8 = if s512 then s509 else s508-  s514 :: SWord8 = s33 + s513-  s515 :: SWord8 = if s511 then s514 else s513-  s516 :: SBool = s32 == s185-  s517 :: SWord8 = if s516 then s509 else s508-  s518 :: SWord8 = s33 + s517-  s519 :: SWord8 = if s512 then s518 else s517-  s520 :: SWord8 = s33 + s519-  s521 :: SWord8 = if s511 then s520 else s519-  s522 :: SWord8 = if s176 then s515 else s521-  s523 :: SWord8 = if s16 then s510 else s522-  s524 :: SWord8 = s33 + s523-  s525 :: SWord8 = if s396 then s524 else s523-  s526 :: SBool = s32 == s197-  s527 :: SBool = s32 == s200-  s528 :: SWord8 = if s527 then s524 else s523-  s529 :: SWord8 = s33 + s528-  s530 :: SWord8 = if s526 then s529 else s528-  s531 :: SBool = s32 == s205-  s532 :: SWord8 = if s531 then s524 else s523-  s533 :: SWord8 = s33 + s532-  s534 :: SWord8 = if s527 then s533 else s532-  s535 :: SWord8 = s33 + s534-  s536 :: SWord8 = if s526 then s535 else s534-  s537 :: SWord8 = if s196 then s530 else s536-  s538 :: SWord8 = if s14 then s525 else s537-  s539 :: SWord8 = s33 + s538-  s540 :: SWord8 = if s395 then s539 else s538-  s541 :: SBool = s32 == s217-  s542 :: SBool = s32 == s220-  s543 :: SWord8 = if s542 then s539 else s538-  s544 :: SWord8 = s33 + s543-  s545 :: SWord8 = if s541 then s544 else s543-  s546 :: SBool = s32 == s225-  s547 :: SWord8 = if s546 then s539 else s538-  s548 :: SWord8 = s33 + s547-  s549 :: SWord8 = if s542 then s548 else s547-  s550 :: SWord8 = s33 + s549-  s551 :: SWord8 = if s541 then s550 else s549-  s552 :: SWord8 = if s216 then s545 else s551-  s553 :: SWord8 = if s11 then s540 else s552-  s554 :: SBool = s2 == s553-  s556 :: SBool = s9 == s555-  s557 :: SBool = s8 == s555-  s558 :: SBool = s7 == s555-  s559 :: SBool = s6 == s555-  s560 :: SBool = s5 == s555-  s561 :: SBool = s4 == s555-  s562 :: SBool = s3 == s555-  s563 :: SBool = s2 == s555-  s564 :: SBool = s1 == s555-  s565 :: SBool = s0 == s555-  s566 :: SWord8 = if s565 then s32 else s33-  s567 :: SBool = s37 == s555-  s568 :: SBool = s40 == s555-  s569 :: SWord8 = if s568 then s32 else s33-  s570 :: SWord8 = s33 + s569-  s571 :: SWord8 = if s567 then s570 else s569-  s572 :: SBool = s45 == s555-  s573 :: SWord8 = if s572 then s32 else s33-  s574 :: SWord8 = s33 + s573-  s575 :: SWord8 = if s568 then s574 else s573-  s576 :: SWord8 = s33 + s575-  s577 :: SWord8 = if s567 then s576 else s575-  s578 :: SWord8 = if s36 then s571 else s577-  s579 :: SWord8 = if s30 then s566 else s578-  s580 :: SWord8 = s33 + s579-  s581 :: SWord8 = if s564 then s580 else s579-  s582 :: SBool = s57 == s555-  s583 :: SBool = s60 == s555-  s584 :: SWord8 = if s583 then s580 else s579-  s585 :: SWord8 = s33 + s584-  s586 :: SWord8 = if s582 then s585 else s584-  s587 :: SBool = s65 == s555-  s588 :: SWord8 = if s587 then s580 else s579-  s589 :: SWord8 = s33 + s588-  s590 :: SWord8 = if s583 then s589 else s588-  s591 :: SWord8 = s33 + s590-  s592 :: SWord8 = if s582 then s591 else s590-  s593 :: SWord8 = if s56 then s586 else s592-  s594 :: SWord8 = if s28 then s581 else s593-  s595 :: SWord8 = s33 + s594-  s596 :: SWord8 = if s563 then s595 else s594-  s597 :: SBool = s77 == s555-  s598 :: SBool = s80 == s555-  s599 :: SWord8 = if s598 then s595 else s594-  s600 :: SWord8 = s33 + s599-  s601 :: SWord8 = if s597 then s600 else s599-  s602 :: SBool = s85 == s555-  s603 :: SWord8 = if s602 then s595 else s594-  s604 :: SWord8 = s33 + s603-  s605 :: SWord8 = if s598 then s604 else s603-  s606 :: SWord8 = s33 + s605-  s607 :: SWord8 = if s597 then s606 else s605-  s608 :: SWord8 = if s76 then s601 else s607-  s609 :: SWord8 = if s26 then s596 else s608-  s610 :: SWord8 = s33 + s609-  s611 :: SWord8 = if s562 then s610 else s609-  s612 :: SBool = s97 == s555-  s613 :: SBool = s100 == s555-  s614 :: SWord8 = if s613 then s610 else s609-  s615 :: SWord8 = s33 + s614-  s616 :: SWord8 = if s612 then s615 else s614-  s617 :: SBool = s105 == s555-  s618 :: SWord8 = if s617 then s610 else s609-  s619 :: SWord8 = s33 + s618-  s620 :: SWord8 = if s613 then s619 else s618-  s621 :: SWord8 = s33 + s620-  s622 :: SWord8 = if s612 then s621 else s620-  s623 :: SWord8 = if s96 then s616 else s622-  s624 :: SWord8 = if s24 then s611 else s623-  s625 :: SWord8 = s33 + s624-  s626 :: SWord8 = if s561 then s625 else s624-  s627 :: SBool = s117 == s555-  s628 :: SBool = s120 == s555-  s629 :: SWord8 = if s628 then s625 else s624-  s630 :: SWord8 = s33 + s629-  s631 :: SWord8 = if s627 then s630 else s629-  s632 :: SBool = s125 == s555-  s633 :: SWord8 = if s632 then s625 else s624-  s634 :: SWord8 = s33 + s633-  s635 :: SWord8 = if s628 then s634 else s633-  s636 :: SWord8 = s33 + s635-  s637 :: SWord8 = if s627 then s636 else s635-  s638 :: SWord8 = if s116 then s631 else s637-  s639 :: SWord8 = if s22 then s626 else s638-  s640 :: SWord8 = s33 + s639-  s641 :: SWord8 = if s560 then s640 else s639-  s642 :: SBool = s137 == s555-  s643 :: SBool = s140 == s555-  s644 :: SWord8 = if s643 then s640 else s639-  s645 :: SWord8 = s33 + s644-  s646 :: SWord8 = if s642 then s645 else s644-  s647 :: SBool = s145 == s555-  s648 :: SWord8 = if s647 then s640 else s639-  s649 :: SWord8 = s33 + s648-  s650 :: SWord8 = if s643 then s649 else s648-  s651 :: SWord8 = s33 + s650-  s652 :: SWord8 = if s642 then s651 else s650-  s653 :: SWord8 = if s136 then s646 else s652-  s654 :: SWord8 = if s20 then s641 else s653-  s655 :: SWord8 = s33 + s654-  s656 :: SWord8 = if s559 then s655 else s654-  s657 :: SBool = s157 == s555-  s658 :: SBool = s160 == s555-  s659 :: SWord8 = if s658 then s655 else s654-  s660 :: SWord8 = s33 + s659-  s661 :: SWord8 = if s657 then s660 else s659-  s662 :: SBool = s165 == s555-  s663 :: SWord8 = if s662 then s655 else s654-  s664 :: SWord8 = s33 + s663-  s665 :: SWord8 = if s658 then s664 else s663-  s666 :: SWord8 = s33 + s665-  s667 :: SWord8 = if s657 then s666 else s665-  s668 :: SWord8 = if s156 then s661 else s667-  s669 :: SWord8 = if s18 then s656 else s668-  s670 :: SWord8 = s33 + s669-  s671 :: SWord8 = if s558 then s670 else s669-  s672 :: SBool = s177 == s555-  s673 :: SBool = s180 == s555-  s674 :: SWord8 = if s673 then s670 else s669-  s675 :: SWord8 = s33 + s674-  s676 :: SWord8 = if s672 then s675 else s674-  s677 :: SBool = s185 == s555-  s678 :: SWord8 = if s677 then s670 else s669-  s679 :: SWord8 = s33 + s678-  s680 :: SWord8 = if s673 then s679 else s678-  s681 :: SWord8 = s33 + s680-  s682 :: SWord8 = if s672 then s681 else s680-  s683 :: SWord8 = if s176 then s676 else s682-  s684 :: SWord8 = if s16 then s671 else s683-  s685 :: SWord8 = s33 + s684-  s686 :: SWord8 = if s557 then s685 else s684-  s687 :: SBool = s197 == s555-  s688 :: SBool = s200 == s555-  s689 :: SWord8 = if s688 then s685 else s684-  s690 :: SWord8 = s33 + s689-  s691 :: SWord8 = if s687 then s690 else s689-  s692 :: SBool = s205 == s555-  s693 :: SWord8 = if s692 then s685 else s684-  s694 :: SWord8 = s33 + s693-  s695 :: SWord8 = if s688 then s694 else s693-  s696 :: SWord8 = s33 + s695-  s697 :: SWord8 = if s687 then s696 else s695-  s698 :: SWord8 = if s196 then s691 else s697-  s699 :: SWord8 = if s14 then s686 else s698-  s700 :: SWord8 = s33 + s699-  s701 :: SWord8 = if s556 then s700 else s699-  s702 :: SBool = s217 == s555-  s703 :: SBool = s220 == s555-  s704 :: SWord8 = if s703 then s700 else s699-  s705 :: SWord8 = s33 + s704-  s706 :: SWord8 = if s702 then s705 else s704-  s707 :: SBool = s225 == s555-  s708 :: SWord8 = if s707 then s700 else s699-  s709 :: SWord8 = s33 + s708-  s710 :: SWord8 = if s703 then s709 else s708-  s711 :: SWord8 = s33 + s710-  s712 :: SWord8 = if s702 then s711 else s710-  s713 :: SWord8 = if s216 then s706 else s712-  s714 :: SWord8 = if s11 then s701 else s713-  s715 :: SBool = s3 == s714-  s717 :: SBool = s9 == s716-  s718 :: SBool = s8 == s716-  s719 :: SBool = s7 == s716-  s720 :: SBool = s6 == s716-  s721 :: SBool = s5 == s716-  s722 :: SBool = s4 == s716-  s723 :: SBool = s3 == s716-  s724 :: SBool = s2 == s716-  s725 :: SBool = s1 == s716-  s726 :: SBool = s0 == s716-  s727 :: SWord8 = if s726 then s32 else s33-  s728 :: SBool = s37 == s716-  s729 :: SBool = s40 == s716-  s730 :: SWord8 = if s729 then s32 else s33-  s731 :: SWord8 = s33 + s730-  s732 :: SWord8 = if s728 then s731 else s730-  s733 :: SBool = s45 == s716-  s734 :: SWord8 = if s733 then s32 else s33-  s735 :: SWord8 = s33 + s734-  s736 :: SWord8 = if s729 then s735 else s734-  s737 :: SWord8 = s33 + s736-  s738 :: SWord8 = if s728 then s737 else s736-  s739 :: SWord8 = if s36 then s732 else s738-  s740 :: SWord8 = if s30 then s727 else s739-  s741 :: SWord8 = s33 + s740-  s742 :: SWord8 = if s725 then s741 else s740-  s743 :: SBool = s57 == s716-  s744 :: SBool = s60 == s716-  s745 :: SWord8 = if s744 then s741 else s740-  s746 :: SWord8 = s33 + s745-  s747 :: SWord8 = if s743 then s746 else s745-  s748 :: SBool = s65 == s716-  s749 :: SWord8 = if s748 then s741 else s740-  s750 :: SWord8 = s33 + s749-  s751 :: SWord8 = if s744 then s750 else s749-  s752 :: SWord8 = s33 + s751-  s753 :: SWord8 = if s743 then s752 else s751-  s754 :: SWord8 = if s56 then s747 else s753-  s755 :: SWord8 = if s28 then s742 else s754-  s756 :: SWord8 = s33 + s755-  s757 :: SWord8 = if s724 then s756 else s755-  s758 :: SBool = s77 == s716-  s759 :: SBool = s80 == s716-  s760 :: SWord8 = if s759 then s756 else s755-  s761 :: SWord8 = s33 + s760-  s762 :: SWord8 = if s758 then s761 else s760-  s763 :: SBool = s85 == s716-  s764 :: SWord8 = if s763 then s756 else s755-  s765 :: SWord8 = s33 + s764-  s766 :: SWord8 = if s759 then s765 else s764-  s767 :: SWord8 = s33 + s766-  s768 :: SWord8 = if s758 then s767 else s766-  s769 :: SWord8 = if s76 then s762 else s768-  s770 :: SWord8 = if s26 then s757 else s769-  s771 :: SWord8 = s33 + s770-  s772 :: SWord8 = if s723 then s771 else s770-  s773 :: SBool = s97 == s716-  s774 :: SBool = s100 == s716-  s775 :: SWord8 = if s774 then s771 else s770-  s776 :: SWord8 = s33 + s775-  s777 :: SWord8 = if s773 then s776 else s775-  s778 :: SBool = s105 == s716-  s779 :: SWord8 = if s778 then s771 else s770-  s780 :: SWord8 = s33 + s779-  s781 :: SWord8 = if s774 then s780 else s779-  s782 :: SWord8 = s33 + s781-  s783 :: SWord8 = if s773 then s782 else s781-  s784 :: SWord8 = if s96 then s777 else s783-  s785 :: SWord8 = if s24 then s772 else s784-  s786 :: SWord8 = s33 + s785-  s787 :: SWord8 = if s722 then s786 else s785-  s788 :: SBool = s117 == s716-  s789 :: SBool = s120 == s716-  s790 :: SWord8 = if s789 then s786 else s785-  s791 :: SWord8 = s33 + s790-  s792 :: SWord8 = if s788 then s791 else s790-  s793 :: SBool = s125 == s716-  s794 :: SWord8 = if s793 then s786 else s785-  s795 :: SWord8 = s33 + s794-  s796 :: SWord8 = if s789 then s795 else s794-  s797 :: SWord8 = s33 + s796-  s798 :: SWord8 = if s788 then s797 else s796-  s799 :: SWord8 = if s116 then s792 else s798-  s800 :: SWord8 = if s22 then s787 else s799-  s801 :: SWord8 = s33 + s800-  s802 :: SWord8 = if s721 then s801 else s800-  s803 :: SBool = s137 == s716-  s804 :: SBool = s140 == s716-  s805 :: SWord8 = if s804 then s801 else s800-  s806 :: SWord8 = s33 + s805-  s807 :: SWord8 = if s803 then s806 else s805-  s808 :: SBool = s145 == s716-  s809 :: SWord8 = if s808 then s801 else s800-  s810 :: SWord8 = s33 + s809-  s811 :: SWord8 = if s804 then s810 else s809-  s812 :: SWord8 = s33 + s811-  s813 :: SWord8 = if s803 then s812 else s811-  s814 :: SWord8 = if s136 then s807 else s813-  s815 :: SWord8 = if s20 then s802 else s814-  s816 :: SWord8 = s33 + s815-  s817 :: SWord8 = if s720 then s816 else s815-  s818 :: SBool = s157 == s716-  s819 :: SBool = s160 == s716-  s820 :: SWord8 = if s819 then s816 else s815-  s821 :: SWord8 = s33 + s820-  s822 :: SWord8 = if s818 then s821 else s820-  s823 :: SBool = s165 == s716-  s824 :: SWord8 = if s823 then s816 else s815-  s825 :: SWord8 = s33 + s824-  s826 :: SWord8 = if s819 then s825 else s824-  s827 :: SWord8 = s33 + s826-  s828 :: SWord8 = if s818 then s827 else s826-  s829 :: SWord8 = if s156 then s822 else s828-  s830 :: SWord8 = if s18 then s817 else s829-  s831 :: SWord8 = s33 + s830-  s832 :: SWord8 = if s719 then s831 else s830-  s833 :: SBool = s177 == s716-  s834 :: SBool = s180 == s716-  s835 :: SWord8 = if s834 then s831 else s830-  s836 :: SWord8 = s33 + s835-  s837 :: SWord8 = if s833 then s836 else s835-  s838 :: SBool = s185 == s716-  s839 :: SWord8 = if s838 then s831 else s830-  s840 :: SWord8 = s33 + s839-  s841 :: SWord8 = if s834 then s840 else s839-  s842 :: SWord8 = s33 + s841-  s843 :: SWord8 = if s833 then s842 else s841-  s844 :: SWord8 = if s176 then s837 else s843-  s845 :: SWord8 = if s16 then s832 else s844-  s846 :: SWord8 = s33 + s845-  s847 :: SWord8 = if s718 then s846 else s845-  s848 :: SBool = s197 == s716-  s849 :: SBool = s200 == s716-  s850 :: SWord8 = if s849 then s846 else s845-  s851 :: SWord8 = s33 + s850-  s852 :: SWord8 = if s848 then s851 else s850-  s853 :: SBool = s205 == s716-  s854 :: SWord8 = if s853 then s846 else s845-  s855 :: SWord8 = s33 + s854-  s856 :: SWord8 = if s849 then s855 else s854-  s857 :: SWord8 = s33 + s856-  s858 :: SWord8 = if s848 then s857 else s856-  s859 :: SWord8 = if s196 then s852 else s858-  s860 :: SWord8 = if s14 then s847 else s859-  s861 :: SWord8 = s33 + s860-  s862 :: SWord8 = if s717 then s861 else s860-  s863 :: SBool = s217 == s716-  s864 :: SBool = s220 == s716-  s865 :: SWord8 = if s864 then s861 else s860-  s866 :: SWord8 = s33 + s865-  s867 :: SWord8 = if s863 then s866 else s865-  s868 :: SBool = s225 == s716-  s869 :: SWord8 = if s868 then s861 else s860-  s870 :: SWord8 = s33 + s869-  s871 :: SWord8 = if s864 then s870 else s869-  s872 :: SWord8 = s33 + s871-  s873 :: SWord8 = if s863 then s872 else s871-  s874 :: SWord8 = if s216 then s867 else s873-  s875 :: SWord8 = if s11 then s862 else s874-  s876 :: SBool = s4 == s875-  s878 :: SBool = s9 == s877-  s879 :: SBool = s8 == s877-  s880 :: SBool = s7 == s877-  s881 :: SBool = s6 == s877-  s882 :: SBool = s5 == s877-  s883 :: SBool = s4 == s877-  s884 :: SBool = s3 == s877-  s885 :: SBool = s2 == s877-  s886 :: SBool = s1 == s877-  s887 :: SBool = s0 == s877-  s888 :: SWord8 = if s887 then s32 else s33-  s889 :: SBool = s37 == s877-  s890 :: SBool = s40 == s877-  s891 :: SWord8 = if s890 then s32 else s33-  s892 :: SWord8 = s33 + s891-  s893 :: SWord8 = if s889 then s892 else s891-  s894 :: SBool = s45 == s877-  s895 :: SWord8 = if s894 then s32 else s33-  s896 :: SWord8 = s33 + s895-  s897 :: SWord8 = if s890 then s896 else s895-  s898 :: SWord8 = s33 + s897-  s899 :: SWord8 = if s889 then s898 else s897-  s900 :: SWord8 = if s36 then s893 else s899-  s901 :: SWord8 = if s30 then s888 else s900-  s902 :: SWord8 = s33 + s901-  s903 :: SWord8 = if s886 then s902 else s901-  s904 :: SBool = s57 == s877-  s905 :: SBool = s60 == s877-  s906 :: SWord8 = if s905 then s902 else s901-  s907 :: SWord8 = s33 + s906-  s908 :: SWord8 = if s904 then s907 else s906-  s909 :: SBool = s65 == s877-  s910 :: SWord8 = if s909 then s902 else s901-  s911 :: SWord8 = s33 + s910-  s912 :: SWord8 = if s905 then s911 else s910-  s913 :: SWord8 = s33 + s912-  s914 :: SWord8 = if s904 then s913 else s912-  s915 :: SWord8 = if s56 then s908 else s914-  s916 :: SWord8 = if s28 then s903 else s915-  s917 :: SWord8 = s33 + s916-  s918 :: SWord8 = if s885 then s917 else s916-  s919 :: SBool = s77 == s877-  s920 :: SBool = s80 == s877-  s921 :: SWord8 = if s920 then s917 else s916-  s922 :: SWord8 = s33 + s921-  s923 :: SWord8 = if s919 then s922 else s921-  s924 :: SBool = s85 == s877-  s925 :: SWord8 = if s924 then s917 else s916-  s926 :: SWord8 = s33 + s925-  s927 :: SWord8 = if s920 then s926 else s925-  s928 :: SWord8 = s33 + s927-  s929 :: SWord8 = if s919 then s928 else s927-  s930 :: SWord8 = if s76 then s923 else s929-  s931 :: SWord8 = if s26 then s918 else s930-  s932 :: SWord8 = s33 + s931-  s933 :: SWord8 = if s884 then s932 else s931-  s934 :: SBool = s97 == s877-  s935 :: SBool = s100 == s877-  s936 :: SWord8 = if s935 then s932 else s931-  s937 :: SWord8 = s33 + s936-  s938 :: SWord8 = if s934 then s937 else s936-  s939 :: SBool = s105 == s877-  s940 :: SWord8 = if s939 then s932 else s931-  s941 :: SWord8 = s33 + s940-  s942 :: SWord8 = if s935 then s941 else s940-  s943 :: SWord8 = s33 + s942-  s944 :: SWord8 = if s934 then s943 else s942-  s945 :: SWord8 = if s96 then s938 else s944-  s946 :: SWord8 = if s24 then s933 else s945-  s947 :: SWord8 = s33 + s946-  s948 :: SWord8 = if s883 then s947 else s946-  s949 :: SBool = s117 == s877-  s950 :: SBool = s120 == s877-  s951 :: SWord8 = if s950 then s947 else s946-  s952 :: SWord8 = s33 + s951-  s953 :: SWord8 = if s949 then s952 else s951-  s954 :: SBool = s125 == s877-  s955 :: SWord8 = if s954 then s947 else s946-  s956 :: SWord8 = s33 + s955-  s957 :: SWord8 = if s950 then s956 else s955-  s958 :: SWord8 = s33 + s957-  s959 :: SWord8 = if s949 then s958 else s957-  s960 :: SWord8 = if s116 then s953 else s959-  s961 :: SWord8 = if s22 then s948 else s960-  s962 :: SWord8 = s33 + s961-  s963 :: SWord8 = if s882 then s962 else s961-  s964 :: SBool = s137 == s877-  s965 :: SBool = s140 == s877-  s966 :: SWord8 = if s965 then s962 else s961-  s967 :: SWord8 = s33 + s966-  s968 :: SWord8 = if s964 then s967 else s966-  s969 :: SBool = s145 == s877-  s970 :: SWord8 = if s969 then s962 else s961-  s971 :: SWord8 = s33 + s970-  s972 :: SWord8 = if s965 then s971 else s970-  s973 :: SWord8 = s33 + s972-  s974 :: SWord8 = if s964 then s973 else s972-  s975 :: SWord8 = if s136 then s968 else s974-  s976 :: SWord8 = if s20 then s963 else s975-  s977 :: SWord8 = s33 + s976-  s978 :: SWord8 = if s881 then s977 else s976-  s979 :: SBool = s157 == s877-  s980 :: SBool = s160 == s877-  s981 :: SWord8 = if s980 then s977 else s976-  s982 :: SWord8 = s33 + s981-  s983 :: SWord8 = if s979 then s982 else s981-  s984 :: SBool = s165 == s877-  s985 :: SWord8 = if s984 then s977 else s976-  s986 :: SWord8 = s33 + s985-  s987 :: SWord8 = if s980 then s986 else s985-  s988 :: SWord8 = s33 + s987-  s989 :: SWord8 = if s979 then s988 else s987-  s990 :: SWord8 = if s156 then s983 else s989-  s991 :: SWord8 = if s18 then s978 else s990-  s992 :: SWord8 = s33 + s991-  s993 :: SWord8 = if s880 then s992 else s991-  s994 :: SBool = s177 == s877-  s995 :: SBool = s180 == s877-  s996 :: SWord8 = if s995 then s992 else s991-  s997 :: SWord8 = s33 + s996-  s998 :: SWord8 = if s994 then s997 else s996-  s999 :: SBool = s185 == s877-  s1000 :: SWord8 = if s999 then s992 else s991-  s1001 :: SWord8 = s33 + s1000-  s1002 :: SWord8 = if s995 then s1001 else s1000-  s1003 :: SWord8 = s33 + s1002-  s1004 :: SWord8 = if s994 then s1003 else s1002-  s1005 :: SWord8 = if s176 then s998 else s1004-  s1006 :: SWord8 = if s16 then s993 else s1005-  s1007 :: SWord8 = s33 + s1006-  s1008 :: SWord8 = if s879 then s1007 else s1006-  s1009 :: SBool = s197 == s877-  s1010 :: SBool = s200 == s877-  s1011 :: SWord8 = if s1010 then s1007 else s1006-  s1012 :: SWord8 = s33 + s1011-  s1013 :: SWord8 = if s1009 then s1012 else s1011-  s1014 :: SBool = s205 == s877-  s1015 :: SWord8 = if s1014 then s1007 else s1006-  s1016 :: SWord8 = s33 + s1015-  s1017 :: SWord8 = if s1010 then s1016 else s1015-  s1018 :: SWord8 = s33 + s1017-  s1019 :: SWord8 = if s1009 then s1018 else s1017-  s1020 :: SWord8 = if s196 then s1013 else s1019-  s1021 :: SWord8 = if s14 then s1008 else s1020-  s1022 :: SWord8 = s33 + s1021-  s1023 :: SWord8 = if s878 then s1022 else s1021-  s1024 :: SBool = s217 == s877-  s1025 :: SBool = s220 == s877-  s1026 :: SWord8 = if s1025 then s1022 else s1021-  s1027 :: SWord8 = s33 + s1026-  s1028 :: SWord8 = if s1024 then s1027 else s1026-  s1029 :: SBool = s225 == s877-  s1030 :: SWord8 = if s1029 then s1022 else s1021-  s1031 :: SWord8 = s33 + s1030-  s1032 :: SWord8 = if s1025 then s1031 else s1030-  s1033 :: SWord8 = s33 + s1032-  s1034 :: SWord8 = if s1024 then s1033 else s1032-  s1035 :: SWord8 = if s216 then s1028 else s1034-  s1036 :: SWord8 = if s11 then s1023 else s1035-  s1037 :: SBool = s5 == s1036-  s1039 :: SBool = s9 == s1038-  s1040 :: SBool = s8 == s1038-  s1041 :: SBool = s7 == s1038-  s1042 :: SBool = s6 == s1038-  s1043 :: SBool = s5 == s1038-  s1044 :: SBool = s4 == s1038-  s1045 :: SBool = s3 == s1038-  s1046 :: SBool = s2 == s1038-  s1047 :: SBool = s1 == s1038-  s1048 :: SBool = s0 == s1038-  s1049 :: SWord8 = if s1048 then s32 else s33-  s1050 :: SBool = s37 == s1038-  s1051 :: SBool = s40 == s1038-  s1052 :: SWord8 = if s1051 then s32 else s33-  s1053 :: SWord8 = s33 + s1052-  s1054 :: SWord8 = if s1050 then s1053 else s1052-  s1055 :: SBool = s45 == s1038-  s1056 :: SWord8 = if s1055 then s32 else s33-  s1057 :: SWord8 = s33 + s1056-  s1058 :: SWord8 = if s1051 then s1057 else s1056-  s1059 :: SWord8 = s33 + s1058-  s1060 :: SWord8 = if s1050 then s1059 else s1058-  s1061 :: SWord8 = if s36 then s1054 else s1060-  s1062 :: SWord8 = if s30 then s1049 else s1061-  s1063 :: SWord8 = s33 + s1062-  s1064 :: SWord8 = if s1047 then s1063 else s1062-  s1065 :: SBool = s57 == s1038-  s1066 :: SBool = s60 == s1038-  s1067 :: SWord8 = if s1066 then s1063 else s1062-  s1068 :: SWord8 = s33 + s1067-  s1069 :: SWord8 = if s1065 then s1068 else s1067-  s1070 :: SBool = s65 == s1038-  s1071 :: SWord8 = if s1070 then s1063 else s1062-  s1072 :: SWord8 = s33 + s1071-  s1073 :: SWord8 = if s1066 then s1072 else s1071-  s1074 :: SWord8 = s33 + s1073-  s1075 :: SWord8 = if s1065 then s1074 else s1073-  s1076 :: SWord8 = if s56 then s1069 else s1075-  s1077 :: SWord8 = if s28 then s1064 else s1076-  s1078 :: SWord8 = s33 + s1077-  s1079 :: SWord8 = if s1046 then s1078 else s1077-  s1080 :: SBool = s77 == s1038-  s1081 :: SBool = s80 == s1038-  s1082 :: SWord8 = if s1081 then s1078 else s1077-  s1083 :: SWord8 = s33 + s1082-  s1084 :: SWord8 = if s1080 then s1083 else s1082-  s1085 :: SBool = s85 == s1038-  s1086 :: SWord8 = if s1085 then s1078 else s1077-  s1087 :: SWord8 = s33 + s1086-  s1088 :: SWord8 = if s1081 then s1087 else s1086-  s1089 :: SWord8 = s33 + s1088-  s1090 :: SWord8 = if s1080 then s1089 else s1088-  s1091 :: SWord8 = if s76 then s1084 else s1090-  s1092 :: SWord8 = if s26 then s1079 else s1091-  s1093 :: SWord8 = s33 + s1092-  s1094 :: SWord8 = if s1045 then s1093 else s1092-  s1095 :: SBool = s97 == s1038-  s1096 :: SBool = s100 == s1038-  s1097 :: SWord8 = if s1096 then s1093 else s1092-  s1098 :: SWord8 = s33 + s1097-  s1099 :: SWord8 = if s1095 then s1098 else s1097-  s1100 :: SBool = s105 == s1038-  s1101 :: SWord8 = if s1100 then s1093 else s1092-  s1102 :: SWord8 = s33 + s1101-  s1103 :: SWord8 = if s1096 then s1102 else s1101-  s1104 :: SWord8 = s33 + s1103-  s1105 :: SWord8 = if s1095 then s1104 else s1103-  s1106 :: SWord8 = if s96 then s1099 else s1105-  s1107 :: SWord8 = if s24 then s1094 else s1106-  s1108 :: SWord8 = s33 + s1107-  s1109 :: SWord8 = if s1044 then s1108 else s1107-  s1110 :: SBool = s117 == s1038-  s1111 :: SBool = s120 == s1038-  s1112 :: SWord8 = if s1111 then s1108 else s1107-  s1113 :: SWord8 = s33 + s1112-  s1114 :: SWord8 = if s1110 then s1113 else s1112-  s1115 :: SBool = s125 == s1038-  s1116 :: SWord8 = if s1115 then s1108 else s1107-  s1117 :: SWord8 = s33 + s1116-  s1118 :: SWord8 = if s1111 then s1117 else s1116-  s1119 :: SWord8 = s33 + s1118-  s1120 :: SWord8 = if s1110 then s1119 else s1118-  s1121 :: SWord8 = if s116 then s1114 else s1120-  s1122 :: SWord8 = if s22 then s1109 else s1121-  s1123 :: SWord8 = s33 + s1122-  s1124 :: SWord8 = if s1043 then s1123 else s1122-  s1125 :: SBool = s137 == s1038-  s1126 :: SBool = s140 == s1038-  s1127 :: SWord8 = if s1126 then s1123 else s1122-  s1128 :: SWord8 = s33 + s1127-  s1129 :: SWord8 = if s1125 then s1128 else s1127-  s1130 :: SBool = s145 == s1038-  s1131 :: SWord8 = if s1130 then s1123 else s1122-  s1132 :: SWord8 = s33 + s1131-  s1133 :: SWord8 = if s1126 then s1132 else s1131-  s1134 :: SWord8 = s33 + s1133-  s1135 :: SWord8 = if s1125 then s1134 else s1133-  s1136 :: SWord8 = if s136 then s1129 else s1135-  s1137 :: SWord8 = if s20 then s1124 else s1136-  s1138 :: SWord8 = s33 + s1137-  s1139 :: SWord8 = if s1042 then s1138 else s1137-  s1140 :: SBool = s157 == s1038-  s1141 :: SBool = s160 == s1038-  s1142 :: SWord8 = if s1141 then s1138 else s1137-  s1143 :: SWord8 = s33 + s1142-  s1144 :: SWord8 = if s1140 then s1143 else s1142-  s1145 :: SBool = s165 == s1038-  s1146 :: SWord8 = if s1145 then s1138 else s1137-  s1147 :: SWord8 = s33 + s1146-  s1148 :: SWord8 = if s1141 then s1147 else s1146-  s1149 :: SWord8 = s33 + s1148-  s1150 :: SWord8 = if s1140 then s1149 else s1148-  s1151 :: SWord8 = if s156 then s1144 else s1150-  s1152 :: SWord8 = if s18 then s1139 else s1151-  s1153 :: SWord8 = s33 + s1152-  s1154 :: SWord8 = if s1041 then s1153 else s1152-  s1155 :: SBool = s177 == s1038-  s1156 :: SBool = s180 == s1038-  s1157 :: SWord8 = if s1156 then s1153 else s1152-  s1158 :: SWord8 = s33 + s1157-  s1159 :: SWord8 = if s1155 then s1158 else s1157-  s1160 :: SBool = s185 == s1038-  s1161 :: SWord8 = if s1160 then s1153 else s1152-  s1162 :: SWord8 = s33 + s1161-  s1163 :: SWord8 = if s1156 then s1162 else s1161-  s1164 :: SWord8 = s33 + s1163-  s1165 :: SWord8 = if s1155 then s1164 else s1163-  s1166 :: SWord8 = if s176 then s1159 else s1165-  s1167 :: SWord8 = if s16 then s1154 else s1166-  s1168 :: SWord8 = s33 + s1167-  s1169 :: SWord8 = if s1040 then s1168 else s1167-  s1170 :: SBool = s197 == s1038-  s1171 :: SBool = s200 == s1038-  s1172 :: SWord8 = if s1171 then s1168 else s1167-  s1173 :: SWord8 = s33 + s1172-  s1174 :: SWord8 = if s1170 then s1173 else s1172-  s1175 :: SBool = s205 == s1038-  s1176 :: SWord8 = if s1175 then s1168 else s1167-  s1177 :: SWord8 = s33 + s1176-  s1178 :: SWord8 = if s1171 then s1177 else s1176-  s1179 :: SWord8 = s33 + s1178-  s1180 :: SWord8 = if s1170 then s1179 else s1178-  s1181 :: SWord8 = if s196 then s1174 else s1180-  s1182 :: SWord8 = if s14 then s1169 else s1181-  s1183 :: SWord8 = s33 + s1182-  s1184 :: SWord8 = if s1039 then s1183 else s1182-  s1185 :: SBool = s217 == s1038-  s1186 :: SBool = s220 == s1038-  s1187 :: SWord8 = if s1186 then s1183 else s1182-  s1188 :: SWord8 = s33 + s1187-  s1189 :: SWord8 = if s1185 then s1188 else s1187-  s1190 :: SBool = s225 == s1038-  s1191 :: SWord8 = if s1190 then s1183 else s1182-  s1192 :: SWord8 = s33 + s1191-  s1193 :: SWord8 = if s1186 then s1192 else s1191-  s1194 :: SWord8 = s33 + s1193-  s1195 :: SWord8 = if s1185 then s1194 else s1193-  s1196 :: SWord8 = if s216 then s1189 else s1195-  s1197 :: SWord8 = if s11 then s1184 else s1196-  s1198 :: SBool = s6 == s1197-  s1200 :: SBool = s9 == s1199-  s1201 :: SBool = s8 == s1199-  s1202 :: SBool = s7 == s1199-  s1203 :: SBool = s6 == s1199-  s1204 :: SBool = s5 == s1199-  s1205 :: SBool = s4 == s1199-  s1206 :: SBool = s3 == s1199-  s1207 :: SBool = s2 == s1199-  s1208 :: SBool = s1 == s1199-  s1209 :: SBool = s0 == s1199-  s1210 :: SWord8 = if s1209 then s32 else s33-  s1211 :: SBool = s37 == s1199-  s1212 :: SBool = s40 == s1199-  s1213 :: SWord8 = if s1212 then s32 else s33-  s1214 :: SWord8 = s33 + s1213-  s1215 :: SWord8 = if s1211 then s1214 else s1213-  s1216 :: SBool = s45 == s1199-  s1217 :: SWord8 = if s1216 then s32 else s33-  s1218 :: SWord8 = s33 + s1217-  s1219 :: SWord8 = if s1212 then s1218 else s1217-  s1220 :: SWord8 = s33 + s1219-  s1221 :: SWord8 = if s1211 then s1220 else s1219-  s1222 :: SWord8 = if s36 then s1215 else s1221-  s1223 :: SWord8 = if s30 then s1210 else s1222-  s1224 :: SWord8 = s33 + s1223-  s1225 :: SWord8 = if s1208 then s1224 else s1223-  s1226 :: SBool = s57 == s1199-  s1227 :: SBool = s60 == s1199-  s1228 :: SWord8 = if s1227 then s1224 else s1223-  s1229 :: SWord8 = s33 + s1228-  s1230 :: SWord8 = if s1226 then s1229 else s1228-  s1231 :: SBool = s65 == s1199-  s1232 :: SWord8 = if s1231 then s1224 else s1223-  s1233 :: SWord8 = s33 + s1232-  s1234 :: SWord8 = if s1227 then s1233 else s1232-  s1235 :: SWord8 = s33 + s1234-  s1236 :: SWord8 = if s1226 then s1235 else s1234-  s1237 :: SWord8 = if s56 then s1230 else s1236-  s1238 :: SWord8 = if s28 then s1225 else s1237-  s1239 :: SWord8 = s33 + s1238-  s1240 :: SWord8 = if s1207 then s1239 else s1238-  s1241 :: SBool = s77 == s1199-  s1242 :: SBool = s80 == s1199-  s1243 :: SWord8 = if s1242 then s1239 else s1238-  s1244 :: SWord8 = s33 + s1243-  s1245 :: SWord8 = if s1241 then s1244 else s1243-  s1246 :: SBool = s85 == s1199-  s1247 :: SWord8 = if s1246 then s1239 else s1238-  s1248 :: SWord8 = s33 + s1247-  s1249 :: SWord8 = if s1242 then s1248 else s1247-  s1250 :: SWord8 = s33 + s1249-  s1251 :: SWord8 = if s1241 then s1250 else s1249-  s1252 :: SWord8 = if s76 then s1245 else s1251-  s1253 :: SWord8 = if s26 then s1240 else s1252-  s1254 :: SWord8 = s33 + s1253-  s1255 :: SWord8 = if s1206 then s1254 else s1253-  s1256 :: SBool = s97 == s1199-  s1257 :: SBool = s100 == s1199-  s1258 :: SWord8 = if s1257 then s1254 else s1253-  s1259 :: SWord8 = s33 + s1258-  s1260 :: SWord8 = if s1256 then s1259 else s1258-  s1261 :: SBool = s105 == s1199-  s1262 :: SWord8 = if s1261 then s1254 else s1253-  s1263 :: SWord8 = s33 + s1262-  s1264 :: SWord8 = if s1257 then s1263 else s1262-  s1265 :: SWord8 = s33 + s1264-  s1266 :: SWord8 = if s1256 then s1265 else s1264-  s1267 :: SWord8 = if s96 then s1260 else s1266-  s1268 :: SWord8 = if s24 then s1255 else s1267-  s1269 :: SWord8 = s33 + s1268-  s1270 :: SWord8 = if s1205 then s1269 else s1268-  s1271 :: SBool = s117 == s1199-  s1272 :: SBool = s120 == s1199-  s1273 :: SWord8 = if s1272 then s1269 else s1268-  s1274 :: SWord8 = s33 + s1273-  s1275 :: SWord8 = if s1271 then s1274 else s1273-  s1276 :: SBool = s125 == s1199-  s1277 :: SWord8 = if s1276 then s1269 else s1268-  s1278 :: SWord8 = s33 + s1277-  s1279 :: SWord8 = if s1272 then s1278 else s1277-  s1280 :: SWord8 = s33 + s1279-  s1281 :: SWord8 = if s1271 then s1280 else s1279-  s1282 :: SWord8 = if s116 then s1275 else s1281-  s1283 :: SWord8 = if s22 then s1270 else s1282-  s1284 :: SWord8 = s33 + s1283-  s1285 :: SWord8 = if s1204 then s1284 else s1283-  s1286 :: SBool = s137 == s1199-  s1287 :: SBool = s140 == s1199-  s1288 :: SWord8 = if s1287 then s1284 else s1283-  s1289 :: SWord8 = s33 + s1288-  s1290 :: SWord8 = if s1286 then s1289 else s1288-  s1291 :: SBool = s145 == s1199-  s1292 :: SWord8 = if s1291 then s1284 else s1283-  s1293 :: SWord8 = s33 + s1292-  s1294 :: SWord8 = if s1287 then s1293 else s1292-  s1295 :: SWord8 = s33 + s1294-  s1296 :: SWord8 = if s1286 then s1295 else s1294-  s1297 :: SWord8 = if s136 then s1290 else s1296-  s1298 :: SWord8 = if s20 then s1285 else s1297-  s1299 :: SWord8 = s33 + s1298-  s1300 :: SWord8 = if s1203 then s1299 else s1298-  s1301 :: SBool = s157 == s1199-  s1302 :: SBool = s160 == s1199-  s1303 :: SWord8 = if s1302 then s1299 else s1298-  s1304 :: SWord8 = s33 + s1303-  s1305 :: SWord8 = if s1301 then s1304 else s1303-  s1306 :: SBool = s165 == s1199-  s1307 :: SWord8 = if s1306 then s1299 else s1298-  s1308 :: SWord8 = s33 + s1307-  s1309 :: SWord8 = if s1302 then s1308 else s1307-  s1310 :: SWord8 = s33 + s1309-  s1311 :: SWord8 = if s1301 then s1310 else s1309-  s1312 :: SWord8 = if s156 then s1305 else s1311-  s1313 :: SWord8 = if s18 then s1300 else s1312-  s1314 :: SWord8 = s33 + s1313-  s1315 :: SWord8 = if s1202 then s1314 else s1313-  s1316 :: SBool = s177 == s1199-  s1317 :: SBool = s180 == s1199-  s1318 :: SWord8 = if s1317 then s1314 else s1313-  s1319 :: SWord8 = s33 + s1318-  s1320 :: SWord8 = if s1316 then s1319 else s1318-  s1321 :: SBool = s185 == s1199-  s1322 :: SWord8 = if s1321 then s1314 else s1313-  s1323 :: SWord8 = s33 + s1322-  s1324 :: SWord8 = if s1317 then s1323 else s1322-  s1325 :: SWord8 = s33 + s1324-  s1326 :: SWord8 = if s1316 then s1325 else s1324-  s1327 :: SWord8 = if s176 then s1320 else s1326-  s1328 :: SWord8 = if s16 then s1315 else s1327-  s1329 :: SWord8 = s33 + s1328-  s1330 :: SWord8 = if s1201 then s1329 else s1328-  s1331 :: SBool = s197 == s1199-  s1332 :: SBool = s200 == s1199-  s1333 :: SWord8 = if s1332 then s1329 else s1328-  s1334 :: SWord8 = s33 + s1333-  s1335 :: SWord8 = if s1331 then s1334 else s1333-  s1336 :: SBool = s205 == s1199-  s1337 :: SWord8 = if s1336 then s1329 else s1328-  s1338 :: SWord8 = s33 + s1337-  s1339 :: SWord8 = if s1332 then s1338 else s1337-  s1340 :: SWord8 = s33 + s1339-  s1341 :: SWord8 = if s1331 then s1340 else s1339-  s1342 :: SWord8 = if s196 then s1335 else s1341-  s1343 :: SWord8 = if s14 then s1330 else s1342-  s1344 :: SWord8 = s33 + s1343-  s1345 :: SWord8 = if s1200 then s1344 else s1343-  s1346 :: SBool = s217 == s1199-  s1347 :: SBool = s220 == s1199-  s1348 :: SWord8 = if s1347 then s1344 else s1343-  s1349 :: SWord8 = s33 + s1348-  s1350 :: SWord8 = if s1346 then s1349 else s1348-  s1351 :: SBool = s225 == s1199-  s1352 :: SWord8 = if s1351 then s1344 else s1343-  s1353 :: SWord8 = s33 + s1352-  s1354 :: SWord8 = if s1347 then s1353 else s1352-  s1355 :: SWord8 = s33 + s1354-  s1356 :: SWord8 = if s1346 then s1355 else s1354-  s1357 :: SWord8 = if s216 then s1350 else s1356-  s1358 :: SWord8 = if s11 then s1345 else s1357-  s1359 :: SBool = s7 == s1358-  s1361 :: SBool = s9 == s1360-  s1362 :: SBool = s8 == s1360-  s1363 :: SBool = s7 == s1360-  s1364 :: SBool = s6 == s1360-  s1365 :: SBool = s5 == s1360-  s1366 :: SBool = s4 == s1360-  s1367 :: SBool = s3 == s1360-  s1368 :: SBool = s2 == s1360-  s1369 :: SBool = s1 == s1360-  s1370 :: SBool = s0 == s1360-  s1371 :: SWord8 = if s1370 then s32 else s33-  s1372 :: SBool = s37 == s1360-  s1373 :: SBool = s40 == s1360-  s1374 :: SWord8 = if s1373 then s32 else s33-  s1375 :: SWord8 = s33 + s1374-  s1376 :: SWord8 = if s1372 then s1375 else s1374-  s1377 :: SBool = s45 == s1360-  s1378 :: SWord8 = if s1377 then s32 else s33-  s1379 :: SWord8 = s33 + s1378-  s1380 :: SWord8 = if s1373 then s1379 else s1378-  s1381 :: SWord8 = s33 + s1380-  s1382 :: SWord8 = if s1372 then s1381 else s1380-  s1383 :: SWord8 = if s36 then s1376 else s1382-  s1384 :: SWord8 = if s30 then s1371 else s1383-  s1385 :: SWord8 = s33 + s1384-  s1386 :: SWord8 = if s1369 then s1385 else s1384-  s1387 :: SBool = s57 == s1360-  s1388 :: SBool = s60 == s1360-  s1389 :: SWord8 = if s1388 then s1385 else s1384-  s1390 :: SWord8 = s33 + s1389-  s1391 :: SWord8 = if s1387 then s1390 else s1389-  s1392 :: SBool = s65 == s1360-  s1393 :: SWord8 = if s1392 then s1385 else s1384-  s1394 :: SWord8 = s33 + s1393-  s1395 :: SWord8 = if s1388 then s1394 else s1393-  s1396 :: SWord8 = s33 + s1395-  s1397 :: SWord8 = if s1387 then s1396 else s1395-  s1398 :: SWord8 = if s56 then s1391 else s1397-  s1399 :: SWord8 = if s28 then s1386 else s1398-  s1400 :: SWord8 = s33 + s1399-  s1401 :: SWord8 = if s1368 then s1400 else s1399-  s1402 :: SBool = s77 == s1360-  s1403 :: SBool = s80 == s1360-  s1404 :: SWord8 = if s1403 then s1400 else s1399-  s1405 :: SWord8 = s33 + s1404-  s1406 :: SWord8 = if s1402 then s1405 else s1404-  s1407 :: SBool = s85 == s1360-  s1408 :: SWord8 = if s1407 then s1400 else s1399-  s1409 :: SWord8 = s33 + s1408-  s1410 :: SWord8 = if s1403 then s1409 else s1408-  s1411 :: SWord8 = s33 + s1410-  s1412 :: SWord8 = if s1402 then s1411 else s1410-  s1413 :: SWord8 = if s76 then s1406 else s1412-  s1414 :: SWord8 = if s26 then s1401 else s1413-  s1415 :: SWord8 = s33 + s1414-  s1416 :: SWord8 = if s1367 then s1415 else s1414-  s1417 :: SBool = s97 == s1360-  s1418 :: SBool = s100 == s1360-  s1419 :: SWord8 = if s1418 then s1415 else s1414-  s1420 :: SWord8 = s33 + s1419-  s1421 :: SWord8 = if s1417 then s1420 else s1419-  s1422 :: SBool = s105 == s1360-  s1423 :: SWord8 = if s1422 then s1415 else s1414-  s1424 :: SWord8 = s33 + s1423-  s1425 :: SWord8 = if s1418 then s1424 else s1423-  s1426 :: SWord8 = s33 + s1425-  s1427 :: SWord8 = if s1417 then s1426 else s1425-  s1428 :: SWord8 = if s96 then s1421 else s1427-  s1429 :: SWord8 = if s24 then s1416 else s1428-  s1430 :: SWord8 = s33 + s1429-  s1431 :: SWord8 = if s1366 then s1430 else s1429-  s1432 :: SBool = s117 == s1360-  s1433 :: SBool = s120 == s1360-  s1434 :: SWord8 = if s1433 then s1430 else s1429-  s1435 :: SWord8 = s33 + s1434-  s1436 :: SWord8 = if s1432 then s1435 else s1434-  s1437 :: SBool = s125 == s1360-  s1438 :: SWord8 = if s1437 then s1430 else s1429-  s1439 :: SWord8 = s33 + s1438-  s1440 :: SWord8 = if s1433 then s1439 else s1438-  s1441 :: SWord8 = s33 + s1440-  s1442 :: SWord8 = if s1432 then s1441 else s1440-  s1443 :: SWord8 = if s116 then s1436 else s1442-  s1444 :: SWord8 = if s22 then s1431 else s1443-  s1445 :: SWord8 = s33 + s1444-  s1446 :: SWord8 = if s1365 then s1445 else s1444-  s1447 :: SBool = s137 == s1360-  s1448 :: SBool = s140 == s1360-  s1449 :: SWord8 = if s1448 then s1445 else s1444-  s1450 :: SWord8 = s33 + s1449-  s1451 :: SWord8 = if s1447 then s1450 else s1449-  s1452 :: SBool = s145 == s1360-  s1453 :: SWord8 = if s1452 then s1445 else s1444-  s1454 :: SWord8 = s33 + s1453-  s1455 :: SWord8 = if s1448 then s1454 else s1453-  s1456 :: SWord8 = s33 + s1455-  s1457 :: SWord8 = if s1447 then s1456 else s1455-  s1458 :: SWord8 = if s136 then s1451 else s1457-  s1459 :: SWord8 = if s20 then s1446 else s1458-  s1460 :: SWord8 = s33 + s1459-  s1461 :: SWord8 = if s1364 then s1460 else s1459-  s1462 :: SBool = s157 == s1360-  s1463 :: SBool = s160 == s1360-  s1464 :: SWord8 = if s1463 then s1460 else s1459-  s1465 :: SWord8 = s33 + s1464-  s1466 :: SWord8 = if s1462 then s1465 else s1464-  s1467 :: SBool = s165 == s1360-  s1468 :: SWord8 = if s1467 then s1460 else s1459-  s1469 :: SWord8 = s33 + s1468-  s1470 :: SWord8 = if s1463 then s1469 else s1468-  s1471 :: SWord8 = s33 + s1470-  s1472 :: SWord8 = if s1462 then s1471 else s1470-  s1473 :: SWord8 = if s156 then s1466 else s1472-  s1474 :: SWord8 = if s18 then s1461 else s1473-  s1475 :: SWord8 = s33 + s1474-  s1476 :: SWord8 = if s1363 then s1475 else s1474-  s1477 :: SBool = s177 == s1360-  s1478 :: SBool = s180 == s1360-  s1479 :: SWord8 = if s1478 then s1475 else s1474-  s1480 :: SWord8 = s33 + s1479-  s1481 :: SWord8 = if s1477 then s1480 else s1479-  s1482 :: SBool = s185 == s1360-  s1483 :: SWord8 = if s1482 then s1475 else s1474-  s1484 :: SWord8 = s33 + s1483-  s1485 :: SWord8 = if s1478 then s1484 else s1483-  s1486 :: SWord8 = s33 + s1485-  s1487 :: SWord8 = if s1477 then s1486 else s1485-  s1488 :: SWord8 = if s176 then s1481 else s1487-  s1489 :: SWord8 = if s16 then s1476 else s1488-  s1490 :: SWord8 = s33 + s1489-  s1491 :: SWord8 = if s1362 then s1490 else s1489-  s1492 :: SBool = s197 == s1360-  s1493 :: SBool = s200 == s1360-  s1494 :: SWord8 = if s1493 then s1490 else s1489-  s1495 :: SWord8 = s33 + s1494-  s1496 :: SWord8 = if s1492 then s1495 else s1494-  s1497 :: SBool = s205 == s1360-  s1498 :: SWord8 = if s1497 then s1490 else s1489-  s1499 :: SWord8 = s33 + s1498-  s1500 :: SWord8 = if s1493 then s1499 else s1498-  s1501 :: SWord8 = s33 + s1500-  s1502 :: SWord8 = if s1492 then s1501 else s1500-  s1503 :: SWord8 = if s196 then s1496 else s1502-  s1504 :: SWord8 = if s14 then s1491 else s1503-  s1505 :: SWord8 = s33 + s1504-  s1506 :: SWord8 = if s1361 then s1505 else s1504-  s1507 :: SBool = s217 == s1360-  s1508 :: SBool = s220 == s1360-  s1509 :: SWord8 = if s1508 then s1505 else s1504-  s1510 :: SWord8 = s33 + s1509-  s1511 :: SWord8 = if s1507 then s1510 else s1509-  s1512 :: SBool = s225 == s1360-  s1513 :: SWord8 = if s1512 then s1505 else s1504-  s1514 :: SWord8 = s33 + s1513-  s1515 :: SWord8 = if s1508 then s1514 else s1513-  s1516 :: SWord8 = s33 + s1515-  s1517 :: SWord8 = if s1507 then s1516 else s1515-  s1518 :: SWord8 = if s216 then s1511 else s1517-  s1519 :: SWord8 = if s11 then s1506 else s1518-  s1520 :: SBool = s8 == s1519-  s1522 :: SBool = s9 == s1521-  s1523 :: SBool = s8 == s1521-  s1524 :: SBool = s7 == s1521-  s1525 :: SBool = s6 == s1521-  s1526 :: SBool = s5 == s1521-  s1527 :: SBool = s4 == s1521-  s1528 :: SBool = s3 == s1521-  s1529 :: SBool = s2 == s1521-  s1530 :: SBool = s1 == s1521-  s1531 :: SBool = s0 == s1521-  s1532 :: SWord8 = if s1531 then s32 else s33-  s1533 :: SBool = s37 == s1521-  s1534 :: SBool = s40 == s1521-  s1535 :: SWord8 = if s1534 then s32 else s33-  s1536 :: SWord8 = s33 + s1535-  s1537 :: SWord8 = if s1533 then s1536 else s1535-  s1538 :: SBool = s45 == s1521-  s1539 :: SWord8 = if s1538 then s32 else s33-  s1540 :: SWord8 = s33 + s1539-  s1541 :: SWord8 = if s1534 then s1540 else s1539-  s1542 :: SWord8 = s33 + s1541-  s1543 :: SWord8 = if s1533 then s1542 else s1541-  s1544 :: SWord8 = if s36 then s1537 else s1543-  s1545 :: SWord8 = if s30 then s1532 else s1544-  s1546 :: SWord8 = s33 + s1545-  s1547 :: SWord8 = if s1530 then s1546 else s1545-  s1548 :: SBool = s57 == s1521-  s1549 :: SBool = s60 == s1521-  s1550 :: SWord8 = if s1549 then s1546 else s1545-  s1551 :: SWord8 = s33 + s1550-  s1552 :: SWord8 = if s1548 then s1551 else s1550-  s1553 :: SBool = s65 == s1521-  s1554 :: SWord8 = if s1553 then s1546 else s1545-  s1555 :: SWord8 = s33 + s1554-  s1556 :: SWord8 = if s1549 then s1555 else s1554-  s1557 :: SWord8 = s33 + s1556-  s1558 :: SWord8 = if s1548 then s1557 else s1556-  s1559 :: SWord8 = if s56 then s1552 else s1558-  s1560 :: SWord8 = if s28 then s1547 else s1559-  s1561 :: SWord8 = s33 + s1560-  s1562 :: SWord8 = if s1529 then s1561 else s1560-  s1563 :: SBool = s77 == s1521-  s1564 :: SBool = s80 == s1521-  s1565 :: SWord8 = if s1564 then s1561 else s1560-  s1566 :: SWord8 = s33 + s1565-  s1567 :: SWord8 = if s1563 then s1566 else s1565-  s1568 :: SBool = s85 == s1521-  s1569 :: SWord8 = if s1568 then s1561 else s1560-  s1570 :: SWord8 = s33 + s1569-  s1571 :: SWord8 = if s1564 then s1570 else s1569-  s1572 :: SWord8 = s33 + s1571-  s1573 :: SWord8 = if s1563 then s1572 else s1571-  s1574 :: SWord8 = if s76 then s1567 else s1573-  s1575 :: SWord8 = if s26 then s1562 else s1574-  s1576 :: SWord8 = s33 + s1575-  s1577 :: SWord8 = if s1528 then s1576 else s1575-  s1578 :: SBool = s97 == s1521-  s1579 :: SBool = s100 == s1521-  s1580 :: SWord8 = if s1579 then s1576 else s1575-  s1581 :: SWord8 = s33 + s1580-  s1582 :: SWord8 = if s1578 then s1581 else s1580-  s1583 :: SBool = s105 == s1521-  s1584 :: SWord8 = if s1583 then s1576 else s1575-  s1585 :: SWord8 = s33 + s1584-  s1586 :: SWord8 = if s1579 then s1585 else s1584-  s1587 :: SWord8 = s33 + s1586-  s1588 :: SWord8 = if s1578 then s1587 else s1586-  s1589 :: SWord8 = if s96 then s1582 else s1588-  s1590 :: SWord8 = if s24 then s1577 else s1589-  s1591 :: SWord8 = s33 + s1590-  s1592 :: SWord8 = if s1527 then s1591 else s1590-  s1593 :: SBool = s117 == s1521-  s1594 :: SBool = s120 == s1521-  s1595 :: SWord8 = if s1594 then s1591 else s1590-  s1596 :: SWord8 = s33 + s1595-  s1597 :: SWord8 = if s1593 then s1596 else s1595-  s1598 :: SBool = s125 == s1521-  s1599 :: SWord8 = if s1598 then s1591 else s1590-  s1600 :: SWord8 = s33 + s1599-  s1601 :: SWord8 = if s1594 then s1600 else s1599-  s1602 :: SWord8 = s33 + s1601-  s1603 :: SWord8 = if s1593 then s1602 else s1601-  s1604 :: SWord8 = if s116 then s1597 else s1603-  s1605 :: SWord8 = if s22 then s1592 else s1604-  s1606 :: SWord8 = s33 + s1605-  s1607 :: SWord8 = if s1526 then s1606 else s1605-  s1608 :: SBool = s137 == s1521-  s1609 :: SBool = s140 == s1521-  s1610 :: SWord8 = if s1609 then s1606 else s1605-  s1611 :: SWord8 = s33 + s1610-  s1612 :: SWord8 = if s1608 then s1611 else s1610-  s1613 :: SBool = s145 == s1521-  s1614 :: SWord8 = if s1613 then s1606 else s1605-  s1615 :: SWord8 = s33 + s1614-  s1616 :: SWord8 = if s1609 then s1615 else s1614-  s1617 :: SWord8 = s33 + s1616-  s1618 :: SWord8 = if s1608 then s1617 else s1616-  s1619 :: SWord8 = if s136 then s1612 else s1618-  s1620 :: SWord8 = if s20 then s1607 else s1619-  s1621 :: SWord8 = s33 + s1620-  s1622 :: SWord8 = if s1525 then s1621 else s1620-  s1623 :: SBool = s157 == s1521-  s1624 :: SBool = s160 == s1521-  s1625 :: SWord8 = if s1624 then s1621 else s1620-  s1626 :: SWord8 = s33 + s1625-  s1627 :: SWord8 = if s1623 then s1626 else s1625-  s1628 :: SBool = s165 == s1521-  s1629 :: SWord8 = if s1628 then s1621 else s1620-  s1630 :: SWord8 = s33 + s1629-  s1631 :: SWord8 = if s1624 then s1630 else s1629-  s1632 :: SWord8 = s33 + s1631-  s1633 :: SWord8 = if s1623 then s1632 else s1631-  s1634 :: SWord8 = if s156 then s1627 else s1633-  s1635 :: SWord8 = if s18 then s1622 else s1634-  s1636 :: SWord8 = s33 + s1635-  s1637 :: SWord8 = if s1524 then s1636 else s1635-  s1638 :: SBool = s177 == s1521-  s1639 :: SBool = s180 == s1521-  s1640 :: SWord8 = if s1639 then s1636 else s1635-  s1641 :: SWord8 = s33 + s1640-  s1642 :: SWord8 = if s1638 then s1641 else s1640-  s1643 :: SBool = s185 == s1521-  s1644 :: SWord8 = if s1643 then s1636 else s1635-  s1645 :: SWord8 = s33 + s1644-  s1646 :: SWord8 = if s1639 then s1645 else s1644-  s1647 :: SWord8 = s33 + s1646-  s1648 :: SWord8 = if s1638 then s1647 else s1646-  s1649 :: SWord8 = if s176 then s1642 else s1648-  s1650 :: SWord8 = if s16 then s1637 else s1649-  s1651 :: SWord8 = s33 + s1650-  s1652 :: SWord8 = if s1523 then s1651 else s1650-  s1653 :: SBool = s197 == s1521-  s1654 :: SBool = s200 == s1521-  s1655 :: SWord8 = if s1654 then s1651 else s1650-  s1656 :: SWord8 = s33 + s1655-  s1657 :: SWord8 = if s1653 then s1656 else s1655-  s1658 :: SBool = s205 == s1521-  s1659 :: SWord8 = if s1658 then s1651 else s1650-  s1660 :: SWord8 = s33 + s1659-  s1661 :: SWord8 = if s1654 then s1660 else s1659-  s1662 :: SWord8 = s33 + s1661-  s1663 :: SWord8 = if s1653 then s1662 else s1661-  s1664 :: SWord8 = if s196 then s1657 else s1663-  s1665 :: SWord8 = if s14 then s1652 else s1664-  s1666 :: SWord8 = s33 + s1665-  s1667 :: SWord8 = if s1522 then s1666 else s1665-  s1668 :: SBool = s217 == s1521-  s1669 :: SBool = s220 == s1521-  s1670 :: SWord8 = if s1669 then s1666 else s1665-  s1671 :: SWord8 = s33 + s1670-  s1672 :: SWord8 = if s1668 then s1671 else s1670-  s1673 :: SBool = s225 == s1521-  s1674 :: SWord8 = if s1673 then s1666 else s1665-  s1675 :: SWord8 = s33 + s1674-  s1676 :: SWord8 = if s1669 then s1675 else s1674-  s1677 :: SWord8 = s33 + s1676-  s1678 :: SWord8 = if s1668 then s1677 else s1676-  s1679 :: SWord8 = if s216 then s1672 else s1678-  s1680 :: SWord8 = if s11 then s1667 else s1679-  s1681 :: SBool = s9 == s1680-  s1682 :: SBool = s1520 & s1681-  s1683 :: SBool = s1359 & s1682-  s1684 :: SBool = s1198 & s1683-  s1685 :: SBool = s1037 & s1684-  s1686 :: SBool = s876 & s1685-  s1687 :: SBool = s715 & s1686-  s1688 :: SBool = s554 & s1687-  s1689 :: SBool = s394 & s1688-  s1690 :: SBool = s234 & s1689-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s1690
− SBVUnitTest/GoldFiles/crcPolyExist.gold 
@@ -1,3488 +0,0 @@-INPUTS-  s0 :: SWord16, existential, aliasing "poly"-  s1 :: SWord32, aliasing "sh"-  s2 :: SWord16, aliasing "sl"-  s3 :: SWord32, aliasing "rh"-  s4 :: SWord16, aliasing "rl"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s6 = 0 :: Word1-  s18 = 1 :: Word8-  s3340 = 0 :: Word8-  s3468 = 4 :: Word8-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s5 :: SWord1 = choose [0:0] s0-  s7 :: SBool = s5 /= s6-  s8 :: SBool = s1 == s3-  s9 :: SBool = s2 == s4-  s10 :: SBool = s8 & s9-  s11 :: SBool = ~ s10-  s12 :: SBool = ~ s11-  s13 :: SWord1 = choose [31:31] s1-  s14 :: SBool = s6 /= s13-  s15 :: SWord1 = choose [31:31] s3-  s16 :: SBool = s6 /= s15-  s17 :: SBool = s14 ^ s16-  s19 :: SWord1 = choose [30:30] s1-  s20 :: SBool = s6 /= s19-  s21 :: SWord1 = choose [30:30] s3-  s22 :: SBool = s6 /= s21-  s23 :: SBool = s20 ^ s22-  s24 :: SWord1 = choose [29:29] s1-  s25 :: SBool = s6 /= s24-  s26 :: SWord1 = choose [29:29] s3-  s27 :: SBool = s6 /= s26-  s28 :: SBool = s25 ^ s27-  s29 :: SWord1 = choose [28:28] s1-  s30 :: SBool = s6 /= s29-  s31 :: SWord1 = choose [28:28] s3-  s32 :: SBool = s6 /= s31-  s33 :: SBool = s30 ^ s32-  s34 :: SWord1 = choose [27:27] s1-  s35 :: SBool = s6 /= s34-  s36 :: SWord1 = choose [27:27] s3-  s37 :: SBool = s6 /= s36-  s38 :: SBool = s35 ^ s37-  s39 :: SWord1 = choose [26:26] s1-  s40 :: SBool = s6 /= s39-  s41 :: SWord1 = choose [26:26] s3-  s42 :: SBool = s6 /= s41-  s43 :: SBool = s40 ^ s42-  s44 :: SWord1 = choose [25:25] s1-  s45 :: SBool = s6 /= s44-  s46 :: SWord1 = choose [25:25] s3-  s47 :: SBool = s6 /= s46-  s48 :: SBool = s45 ^ s47-  s49 :: SWord1 = choose [24:24] s1-  s50 :: SBool = s6 /= s49-  s51 :: SWord1 = choose [24:24] s3-  s52 :: SBool = s6 /= s51-  s53 :: SBool = s50 ^ s52-  s54 :: SWord1 = choose [23:23] s1-  s55 :: SBool = s6 /= s54-  s56 :: SWord1 = choose [23:23] s3-  s57 :: SBool = s6 /= s56-  s58 :: SBool = s55 ^ s57-  s59 :: SWord1 = choose [22:22] s1-  s60 :: SBool = s6 /= s59-  s61 :: SWord1 = choose [22:22] s3-  s62 :: SBool = s6 /= s61-  s63 :: SBool = s60 ^ s62-  s64 :: SWord1 = choose [21:21] s1-  s65 :: SBool = s6 /= s64-  s66 :: SWord1 = choose [21:21] s3-  s67 :: SBool = s6 /= s66-  s68 :: SBool = s65 ^ s67-  s69 :: SWord1 = choose [20:20] s1-  s70 :: SBool = s6 /= s69-  s71 :: SWord1 = choose [20:20] s3-  s72 :: SBool = s6 /= s71-  s73 :: SBool = s70 ^ s72-  s74 :: SWord1 = choose [19:19] s1-  s75 :: SBool = s6 /= s74-  s76 :: SWord1 = choose [19:19] s3-  s77 :: SBool = s6 /= s76-  s78 :: SBool = s75 ^ s77-  s79 :: SWord1 = choose [18:18] s1-  s80 :: SBool = s6 /= s79-  s81 :: SWord1 = choose [18:18] s3-  s82 :: SBool = s6 /= s81-  s83 :: SBool = s80 ^ s82-  s84 :: SWord1 = choose [17:17] s1-  s85 :: SBool = s6 /= s84-  s86 :: SWord1 = choose [17:17] s3-  s87 :: SBool = s6 /= s86-  s88 :: SBool = s85 ^ s87-  s89 :: SWord1 = choose [16:16] s1-  s90 :: SBool = s6 /= s89-  s91 :: SWord1 = choose [16:16] s3-  s92 :: SBool = s6 /= s91-  s93 :: SBool = s90 ^ s92-  s94 :: SWord1 = choose [15:15] s1-  s95 :: SBool = s6 /= s94-  s96 :: SWord1 = choose [15:15] s3-  s97 :: SBool = s6 /= s96-  s98 :: SBool = s95 ^ s97-  s99 :: SWord1 = choose [14:14] s1-  s100 :: SBool = s6 /= s99-  s101 :: SWord1 = choose [14:14] s3-  s102 :: SBool = s6 /= s101-  s103 :: SBool = s100 ^ s102-  s104 :: SWord1 = choose [13:13] s1-  s105 :: SBool = s6 /= s104-  s106 :: SWord1 = choose [13:13] s3-  s107 :: SBool = s6 /= s106-  s108 :: SBool = s105 ^ s107-  s109 :: SWord1 = choose [12:12] s1-  s110 :: SBool = s6 /= s109-  s111 :: SWord1 = choose [12:12] s3-  s112 :: SBool = s6 /= s111-  s113 :: SBool = s110 ^ s112-  s114 :: SWord1 = choose [11:11] s1-  s115 :: SBool = s6 /= s114-  s116 :: SWord1 = choose [11:11] s3-  s117 :: SBool = s6 /= s116-  s118 :: SBool = s115 ^ s117-  s119 :: SWord1 = choose [10:10] s1-  s120 :: SBool = s6 /= s119-  s121 :: SWord1 = choose [10:10] s3-  s122 :: SBool = s6 /= s121-  s123 :: SBool = s120 ^ s122-  s124 :: SWord1 = choose [9:9] s1-  s125 :: SBool = s6 /= s124-  s126 :: SWord1 = choose [9:9] s3-  s127 :: SBool = s6 /= s126-  s128 :: SBool = s125 ^ s127-  s129 :: SWord1 = choose [8:8] s1-  s130 :: SBool = s6 /= s129-  s131 :: SWord1 = choose [8:8] s3-  s132 :: SBool = s6 /= s131-  s133 :: SBool = s130 ^ s132-  s134 :: SWord1 = choose [7:7] s1-  s135 :: SBool = s6 /= s134-  s136 :: SWord1 = choose [7:7] s3-  s137 :: SBool = s6 /= s136-  s138 :: SBool = s135 ^ s137-  s139 :: SWord1 = choose [6:6] s1-  s140 :: SBool = s6 /= s139-  s141 :: SWord1 = choose [6:6] s3-  s142 :: SBool = s6 /= s141-  s143 :: SBool = s140 ^ s142-  s144 :: SWord1 = choose [5:5] s1-  s145 :: SBool = s6 /= s144-  s146 :: SWord1 = choose [5:5] s3-  s147 :: SBool = s6 /= s146-  s148 :: SBool = s145 ^ s147-  s149 :: SWord1 = choose [4:4] s1-  s150 :: SBool = s6 /= s149-  s151 :: SWord1 = choose [4:4] s3-  s152 :: SBool = s6 /= s151-  s153 :: SBool = s150 ^ s152-  s154 :: SWord1 = choose [3:3] s1-  s155 :: SBool = s6 /= s154-  s156 :: SWord1 = choose [3:3] s3-  s157 :: SBool = s6 /= s156-  s158 :: SBool = s155 ^ s157-  s159 :: SWord1 = choose [2:2] s1-  s160 :: SBool = s6 /= s159-  s161 :: SWord1 = choose [2:2] s3-  s162 :: SBool = s6 /= s161-  s163 :: SBool = s160 ^ s162-  s164 :: SWord1 = choose [1:1] s1-  s165 :: SBool = s6 /= s164-  s166 :: SWord1 = choose [1:1] s3-  s167 :: SBool = s6 /= s166-  s168 :: SBool = s165 ^ s167-  s169 :: SWord1 = choose [0:0] s1-  s170 :: SBool = s6 /= s169-  s171 :: SWord1 = choose [0:0] s3-  s172 :: SBool = s6 /= s171-  s173 :: SBool = s170 ^ s172-  s174 :: SWord1 = choose [15:15] s2-  s175 :: SBool = s6 /= s174-  s176 :: SWord1 = choose [15:15] s4-  s177 :: SBool = s6 /= s176-  s178 :: SBool = s175 ^ s177-  s179 :: SWord1 = choose [14:14] s2-  s180 :: SBool = s6 /= s179-  s181 :: SWord1 = choose [14:14] s4-  s182 :: SBool = s6 /= s181-  s183 :: SBool = s180 ^ s182-  s184 :: SWord1 = choose [13:13] s2-  s185 :: SBool = s6 /= s184-  s186 :: SWord1 = choose [13:13] s4-  s187 :: SBool = s6 /= s186-  s188 :: SBool = s185 ^ s187-  s189 :: SWord1 = choose [12:12] s2-  s190 :: SBool = s6 /= s189-  s191 :: SWord1 = choose [12:12] s4-  s192 :: SBool = s6 /= s191-  s193 :: SBool = s190 ^ s192-  s194 :: SWord1 = choose [11:11] s2-  s195 :: SBool = s6 /= s194-  s196 :: SWord1 = choose [11:11] s4-  s197 :: SBool = s6 /= s196-  s198 :: SBool = s195 ^ s197-  s199 :: SWord1 = choose [10:10] s2-  s200 :: SBool = s6 /= s199-  s201 :: SWord1 = choose [10:10] s4-  s202 :: SBool = s6 /= s201-  s203 :: SBool = s200 ^ s202-  s204 :: SWord1 = choose [9:9] s2-  s205 :: SBool = s6 /= s204-  s206 :: SWord1 = choose [9:9] s4-  s207 :: SBool = s6 /= s206-  s208 :: SBool = s205 ^ s207-  s209 :: SWord1 = choose [8:8] s2-  s210 :: SBool = s6 /= s209-  s211 :: SWord1 = choose [8:8] s4-  s212 :: SBool = s6 /= s211-  s213 :: SBool = s210 ^ s212-  s214 :: SWord1 = choose [7:7] s2-  s215 :: SBool = s6 /= s214-  s216 :: SWord1 = choose [7:7] s4-  s217 :: SBool = s6 /= s216-  s218 :: SBool = s215 ^ s217-  s219 :: SWord1 = choose [6:6] s2-  s220 :: SBool = s6 /= s219-  s221 :: SWord1 = choose [6:6] s4-  s222 :: SBool = s6 /= s221-  s223 :: SBool = s220 ^ s222-  s224 :: SWord1 = choose [5:5] s2-  s225 :: SBool = s6 /= s224-  s226 :: SWord1 = choose [5:5] s4-  s227 :: SBool = s6 /= s226-  s228 :: SBool = s225 ^ s227-  s229 :: SWord1 = choose [4:4] s2-  s230 :: SBool = s6 /= s229-  s231 :: SWord1 = choose [4:4] s4-  s232 :: SBool = s6 /= s231-  s233 :: SBool = s230 ^ s232-  s234 :: SWord1 = choose [3:3] s2-  s235 :: SBool = s6 /= s234-  s236 :: SWord1 = choose [3:3] s4-  s237 :: SBool = s6 /= s236-  s238 :: SBool = s235 ^ s237-  s239 :: SWord1 = choose [2:2] s2-  s240 :: SBool = s6 /= s239-  s241 :: SWord1 = choose [2:2] s4-  s242 :: SBool = s6 /= s241-  s243 :: SBool = s240 ^ s242-  s244 :: SWord1 = choose [1:1] s2-  s245 :: SBool = s6 /= s244-  s246 :: SWord1 = choose [1:1] s4-  s247 :: SBool = s6 /= s246-  s248 :: SBool = s245 ^ s247-  s249 :: SWord1 = choose [0:0] s2-  s250 :: SBool = s6 /= s249-  s251 :: SWord1 = choose [0:0] s4-  s252 :: SBool = s6 /= s251-  s253 :: SBool = s250 ^ s252-  s254 :: SWord1 = choose [15:15] s0-  s255 :: SBool = s6 /= s254-  s256 :: SBool = s20 ^ s255-  s257 :: SBool = if s14 then s256 else s20-  s258 :: SWord1 = choose [14:14] s0-  s259 :: SBool = s6 /= s258-  s260 :: SBool = s25 ^ s259-  s261 :: SBool = if s14 then s260 else s25-  s262 :: SBool = s255 ^ s261-  s263 :: SBool = if s257 then s262 else s261-  s264 :: SWord1 = choose [13:13] s0-  s265 :: SBool = s6 /= s264-  s266 :: SBool = s30 ^ s265-  s267 :: SBool = if s14 then s266 else s30-  s268 :: SBool = s259 ^ s267-  s269 :: SBool = if s257 then s268 else s267-  s270 :: SBool = s255 ^ s269-  s271 :: SBool = if s263 then s270 else s269-  s272 :: SWord1 = choose [12:12] s0-  s273 :: SBool = s6 /= s272-  s274 :: SBool = s35 ^ s273-  s275 :: SBool = if s14 then s274 else s35-  s276 :: SBool = s265 ^ s275-  s277 :: SBool = if s257 then s276 else s275-  s278 :: SBool = s259 ^ s277-  s279 :: SBool = if s263 then s278 else s277-  s280 :: SBool = s255 ^ s279-  s281 :: SBool = if s271 then s280 else s279-  s282 :: SWord1 = choose [11:11] s0-  s283 :: SBool = s6 /= s282-  s284 :: SBool = s40 ^ s283-  s285 :: SBool = if s14 then s284 else s40-  s286 :: SBool = s273 ^ s285-  s287 :: SBool = if s257 then s286 else s285-  s288 :: SBool = s265 ^ s287-  s289 :: SBool = if s263 then s288 else s287-  s290 :: SBool = s259 ^ s289-  s291 :: SBool = if s271 then s290 else s289-  s292 :: SBool = s255 ^ s291-  s293 :: SBool = if s281 then s292 else s291-  s294 :: SWord1 = choose [10:10] s0-  s295 :: SBool = s6 /= s294-  s296 :: SBool = s45 ^ s295-  s297 :: SBool = if s14 then s296 else s45-  s298 :: SBool = s283 ^ s297-  s299 :: SBool = if s257 then s298 else s297-  s300 :: SBool = s273 ^ s299-  s301 :: SBool = if s263 then s300 else s299-  s302 :: SBool = s265 ^ s301-  s303 :: SBool = if s271 then s302 else s301-  s304 :: SBool = s259 ^ s303-  s305 :: SBool = if s281 then s304 else s303-  s306 :: SBool = s255 ^ s305-  s307 :: SBool = if s293 then s306 else s305-  s308 :: SWord1 = choose [9:9] s0-  s309 :: SBool = s6 /= s308-  s310 :: SBool = s50 ^ s309-  s311 :: SBool = if s14 then s310 else s50-  s312 :: SBool = s295 ^ s311-  s313 :: SBool = if s257 then s312 else s311-  s314 :: SBool = s283 ^ s313-  s315 :: SBool = if s263 then s314 else s313-  s316 :: SBool = s273 ^ s315-  s317 :: SBool = if s271 then s316 else s315-  s318 :: SBool = s265 ^ s317-  s319 :: SBool = if s281 then s318 else s317-  s320 :: SBool = s259 ^ s319-  s321 :: SBool = if s293 then s320 else s319-  s322 :: SBool = s255 ^ s321-  s323 :: SBool = if s307 then s322 else s321-  s324 :: SWord1 = choose [8:8] s0-  s325 :: SBool = s6 /= s324-  s326 :: SBool = s55 ^ s325-  s327 :: SBool = if s14 then s326 else s55-  s328 :: SBool = s309 ^ s327-  s329 :: SBool = if s257 then s328 else s327-  s330 :: SBool = s295 ^ s329-  s331 :: SBool = if s263 then s330 else s329-  s332 :: SBool = s283 ^ s331-  s333 :: SBool = if s271 then s332 else s331-  s334 :: SBool = s273 ^ s333-  s335 :: SBool = if s281 then s334 else s333-  s336 :: SBool = s265 ^ s335-  s337 :: SBool = if s293 then s336 else s335-  s338 :: SBool = s259 ^ s337-  s339 :: SBool = if s307 then s338 else s337-  s340 :: SBool = s255 ^ s339-  s341 :: SBool = if s323 then s340 else s339-  s342 :: SWord1 = choose [7:7] s0-  s343 :: SBool = s6 /= s342-  s344 :: SBool = s60 ^ s343-  s345 :: SBool = if s14 then s344 else s60-  s346 :: SBool = s325 ^ s345-  s347 :: SBool = if s257 then s346 else s345-  s348 :: SBool = s309 ^ s347-  s349 :: SBool = if s263 then s348 else s347-  s350 :: SBool = s295 ^ s349-  s351 :: SBool = if s271 then s350 else s349-  s352 :: SBool = s283 ^ s351-  s353 :: SBool = if s281 then s352 else s351-  s354 :: SBool = s273 ^ s353-  s355 :: SBool = if s293 then s354 else s353-  s356 :: SBool = s265 ^ s355-  s357 :: SBool = if s307 then s356 else s355-  s358 :: SBool = s259 ^ s357-  s359 :: SBool = if s323 then s358 else s357-  s360 :: SBool = s255 ^ s359-  s361 :: SBool = if s341 then s360 else s359-  s362 :: SWord1 = choose [6:6] s0-  s363 :: SBool = s6 /= s362-  s364 :: SBool = s65 ^ s363-  s365 :: SBool = if s14 then s364 else s65-  s366 :: SBool = s343 ^ s365-  s367 :: SBool = if s257 then s366 else s365-  s368 :: SBool = s325 ^ s367-  s369 :: SBool = if s263 then s368 else s367-  s370 :: SBool = s309 ^ s369-  s371 :: SBool = if s271 then s370 else s369-  s372 :: SBool = s295 ^ s371-  s373 :: SBool = if s281 then s372 else s371-  s374 :: SBool = s283 ^ s373-  s375 :: SBool = if s293 then s374 else s373-  s376 :: SBool = s273 ^ s375-  s377 :: SBool = if s307 then s376 else s375-  s378 :: SBool = s265 ^ s377-  s379 :: SBool = if s323 then s378 else s377-  s380 :: SBool = s259 ^ s379-  s381 :: SBool = if s341 then s380 else s379-  s382 :: SBool = s255 ^ s381-  s383 :: SBool = if s361 then s382 else s381-  s384 :: SWord1 = choose [5:5] s0-  s385 :: SBool = s6 /= s384-  s386 :: SBool = s70 ^ s385-  s387 :: SBool = if s14 then s386 else s70-  s388 :: SBool = s363 ^ s387-  s389 :: SBool = if s257 then s388 else s387-  s390 :: SBool = s343 ^ s389-  s391 :: SBool = if s263 then s390 else s389-  s392 :: SBool = s325 ^ s391-  s393 :: SBool = if s271 then s392 else s391-  s394 :: SBool = s309 ^ s393-  s395 :: SBool = if s281 then s394 else s393-  s396 :: SBool = s295 ^ s395-  s397 :: SBool = if s293 then s396 else s395-  s398 :: SBool = s283 ^ s397-  s399 :: SBool = if s307 then s398 else s397-  s400 :: SBool = s273 ^ s399-  s401 :: SBool = if s323 then s400 else s399-  s402 :: SBool = s265 ^ s401-  s403 :: SBool = if s341 then s402 else s401-  s404 :: SBool = s259 ^ s403-  s405 :: SBool = if s361 then s404 else s403-  s406 :: SBool = s255 ^ s405-  s407 :: SBool = if s383 then s406 else s405-  s408 :: SWord1 = choose [4:4] s0-  s409 :: SBool = s6 /= s408-  s410 :: SBool = s75 ^ s409-  s411 :: SBool = if s14 then s410 else s75-  s412 :: SBool = s385 ^ s411-  s413 :: SBool = if s257 then s412 else s411-  s414 :: SBool = s363 ^ s413-  s415 :: SBool = if s263 then s414 else s413-  s416 :: SBool = s343 ^ s415-  s417 :: SBool = if s271 then s416 else s415-  s418 :: SBool = s325 ^ s417-  s419 :: SBool = if s281 then s418 else s417-  s420 :: SBool = s309 ^ s419-  s421 :: SBool = if s293 then s420 else s419-  s422 :: SBool = s295 ^ s421-  s423 :: SBool = if s307 then s422 else s421-  s424 :: SBool = s283 ^ s423-  s425 :: SBool = if s323 then s424 else s423-  s426 :: SBool = s273 ^ s425-  s427 :: SBool = if s341 then s426 else s425-  s428 :: SBool = s265 ^ s427-  s429 :: SBool = if s361 then s428 else s427-  s430 :: SBool = s259 ^ s429-  s431 :: SBool = if s383 then s430 else s429-  s432 :: SBool = s255 ^ s431-  s433 :: SBool = if s407 then s432 else s431-  s434 :: SWord1 = choose [3:3] s0-  s435 :: SBool = s6 /= s434-  s436 :: SBool = s80 ^ s435-  s437 :: SBool = if s14 then s436 else s80-  s438 :: SBool = s409 ^ s437-  s439 :: SBool = if s257 then s438 else s437-  s440 :: SBool = s385 ^ s439-  s441 :: SBool = if s263 then s440 else s439-  s442 :: SBool = s363 ^ s441-  s443 :: SBool = if s271 then s442 else s441-  s444 :: SBool = s343 ^ s443-  s445 :: SBool = if s281 then s444 else s443-  s446 :: SBool = s325 ^ s445-  s447 :: SBool = if s293 then s446 else s445-  s448 :: SBool = s309 ^ s447-  s449 :: SBool = if s307 then s448 else s447-  s450 :: SBool = s295 ^ s449-  s451 :: SBool = if s323 then s450 else s449-  s452 :: SBool = s283 ^ s451-  s453 :: SBool = if s341 then s452 else s451-  s454 :: SBool = s273 ^ s453-  s455 :: SBool = if s361 then s454 else s453-  s456 :: SBool = s265 ^ s455-  s457 :: SBool = if s383 then s456 else s455-  s458 :: SBool = s259 ^ s457-  s459 :: SBool = if s407 then s458 else s457-  s460 :: SBool = s255 ^ s459-  s461 :: SBool = if s433 then s460 else s459-  s462 :: SWord1 = choose [2:2] s0-  s463 :: SBool = s6 /= s462-  s464 :: SBool = s85 ^ s463-  s465 :: SBool = if s14 then s464 else s85-  s466 :: SBool = s435 ^ s465-  s467 :: SBool = if s257 then s466 else s465-  s468 :: SBool = s409 ^ s467-  s469 :: SBool = if s263 then s468 else s467-  s470 :: SBool = s385 ^ s469-  s471 :: SBool = if s271 then s470 else s469-  s472 :: SBool = s363 ^ s471-  s473 :: SBool = if s281 then s472 else s471-  s474 :: SBool = s343 ^ s473-  s475 :: SBool = if s293 then s474 else s473-  s476 :: SBool = s325 ^ s475-  s477 :: SBool = if s307 then s476 else s475-  s478 :: SBool = s309 ^ s477-  s479 :: SBool = if s323 then s478 else s477-  s480 :: SBool = s295 ^ s479-  s481 :: SBool = if s341 then s480 else s479-  s482 :: SBool = s283 ^ s481-  s483 :: SBool = if s361 then s482 else s481-  s484 :: SBool = s273 ^ s483-  s485 :: SBool = if s383 then s484 else s483-  s486 :: SBool = s265 ^ s485-  s487 :: SBool = if s407 then s486 else s485-  s488 :: SBool = s259 ^ s487-  s489 :: SBool = if s433 then s488 else s487-  s490 :: SBool = s255 ^ s489-  s491 :: SBool = if s461 then s490 else s489-  s492 :: SWord1 = choose [1:1] s0-  s493 :: SBool = s6 /= s492-  s494 :: SBool = s90 ^ s493-  s495 :: SBool = if s14 then s494 else s90-  s496 :: SBool = s463 ^ s495-  s497 :: SBool = if s257 then s496 else s495-  s498 :: SBool = s435 ^ s497-  s499 :: SBool = if s263 then s498 else s497-  s500 :: SBool = s409 ^ s499-  s501 :: SBool = if s271 then s500 else s499-  s502 :: SBool = s385 ^ s501-  s503 :: SBool = if s281 then s502 else s501-  s504 :: SBool = s363 ^ s503-  s505 :: SBool = if s293 then s504 else s503-  s506 :: SBool = s343 ^ s505-  s507 :: SBool = if s307 then s506 else s505-  s508 :: SBool = s325 ^ s507-  s509 :: SBool = if s323 then s508 else s507-  s510 :: SBool = s309 ^ s509-  s511 :: SBool = if s341 then s510 else s509-  s512 :: SBool = s295 ^ s511-  s513 :: SBool = if s361 then s512 else s511-  s514 :: SBool = s283 ^ s513-  s515 :: SBool = if s383 then s514 else s513-  s516 :: SBool = s273 ^ s515-  s517 :: SBool = if s407 then s516 else s515-  s518 :: SBool = s265 ^ s517-  s519 :: SBool = if s433 then s518 else s517-  s520 :: SBool = s259 ^ s519-  s521 :: SBool = if s461 then s520 else s519-  s522 :: SBool = s255 ^ s521-  s523 :: SBool = if s491 then s522 else s521-  s524 :: SBool = s7 ^ s95-  s525 :: SBool = if s14 then s524 else s95-  s526 :: SBool = s493 ^ s525-  s527 :: SBool = if s257 then s526 else s525-  s528 :: SBool = s463 ^ s527-  s529 :: SBool = if s263 then s528 else s527-  s530 :: SBool = s435 ^ s529-  s531 :: SBool = if s271 then s530 else s529-  s532 :: SBool = s409 ^ s531-  s533 :: SBool = if s281 then s532 else s531-  s534 :: SBool = s385 ^ s533-  s535 :: SBool = if s293 then s534 else s533-  s536 :: SBool = s363 ^ s535-  s537 :: SBool = if s307 then s536 else s535-  s538 :: SBool = s343 ^ s537-  s539 :: SBool = if s323 then s538 else s537-  s540 :: SBool = s325 ^ s539-  s541 :: SBool = if s341 then s540 else s539-  s542 :: SBool = s309 ^ s541-  s543 :: SBool = if s361 then s542 else s541-  s544 :: SBool = s295 ^ s543-  s545 :: SBool = if s383 then s544 else s543-  s546 :: SBool = s283 ^ s545-  s547 :: SBool = if s407 then s546 else s545-  s548 :: SBool = s273 ^ s547-  s549 :: SBool = if s433 then s548 else s547-  s550 :: SBool = s265 ^ s549-  s551 :: SBool = if s461 then s550 else s549-  s552 :: SBool = s259 ^ s551-  s553 :: SBool = if s491 then s552 else s551-  s554 :: SBool = s255 ^ s553-  s555 :: SBool = if s523 then s554 else s553-  s556 :: SBool = s7 ^ s100-  s557 :: SBool = if s257 then s556 else s100-  s558 :: SBool = s493 ^ s557-  s559 :: SBool = if s263 then s558 else s557-  s560 :: SBool = s463 ^ s559-  s561 :: SBool = if s271 then s560 else s559-  s562 :: SBool = s435 ^ s561-  s563 :: SBool = if s281 then s562 else s561-  s564 :: SBool = s409 ^ s563-  s565 :: SBool = if s293 then s564 else s563-  s566 :: SBool = s385 ^ s565-  s567 :: SBool = if s307 then s566 else s565-  s568 :: SBool = s363 ^ s567-  s569 :: SBool = if s323 then s568 else s567-  s570 :: SBool = s343 ^ s569-  s571 :: SBool = if s341 then s570 else s569-  s572 :: SBool = s325 ^ s571-  s573 :: SBool = if s361 then s572 else s571-  s574 :: SBool = s309 ^ s573-  s575 :: SBool = if s383 then s574 else s573-  s576 :: SBool = s295 ^ s575-  s577 :: SBool = if s407 then s576 else s575-  s578 :: SBool = s283 ^ s577-  s579 :: SBool = if s433 then s578 else s577-  s580 :: SBool = s273 ^ s579-  s581 :: SBool = if s461 then s580 else s579-  s582 :: SBool = s265 ^ s581-  s583 :: SBool = if s491 then s582 else s581-  s584 :: SBool = s259 ^ s583-  s585 :: SBool = if s523 then s584 else s583-  s586 :: SBool = s255 ^ s585-  s587 :: SBool = if s555 then s586 else s585-  s588 :: SBool = s7 ^ s105-  s589 :: SBool = if s263 then s588 else s105-  s590 :: SBool = s493 ^ s589-  s591 :: SBool = if s271 then s590 else s589-  s592 :: SBool = s463 ^ s591-  s593 :: SBool = if s281 then s592 else s591-  s594 :: SBool = s435 ^ s593-  s595 :: SBool = if s293 then s594 else s593-  s596 :: SBool = s409 ^ s595-  s597 :: SBool = if s307 then s596 else s595-  s598 :: SBool = s385 ^ s597-  s599 :: SBool = if s323 then s598 else s597-  s600 :: SBool = s363 ^ s599-  s601 :: SBool = if s341 then s600 else s599-  s602 :: SBool = s343 ^ s601-  s603 :: SBool = if s361 then s602 else s601-  s604 :: SBool = s325 ^ s603-  s605 :: SBool = if s383 then s604 else s603-  s606 :: SBool = s309 ^ s605-  s607 :: SBool = if s407 then s606 else s605-  s608 :: SBool = s295 ^ s607-  s609 :: SBool = if s433 then s608 else s607-  s610 :: SBool = s283 ^ s609-  s611 :: SBool = if s461 then s610 else s609-  s612 :: SBool = s273 ^ s611-  s613 :: SBool = if s491 then s612 else s611-  s614 :: SBool = s265 ^ s613-  s615 :: SBool = if s523 then s614 else s613-  s616 :: SBool = s259 ^ s615-  s617 :: SBool = if s555 then s616 else s615-  s618 :: SBool = s255 ^ s617-  s619 :: SBool = if s587 then s618 else s617-  s620 :: SBool = s7 ^ s110-  s621 :: SBool = if s271 then s620 else s110-  s622 :: SBool = s493 ^ s621-  s623 :: SBool = if s281 then s622 else s621-  s624 :: SBool = s463 ^ s623-  s625 :: SBool = if s293 then s624 else s623-  s626 :: SBool = s435 ^ s625-  s627 :: SBool = if s307 then s626 else s625-  s628 :: SBool = s409 ^ s627-  s629 :: SBool = if s323 then s628 else s627-  s630 :: SBool = s385 ^ s629-  s631 :: SBool = if s341 then s630 else s629-  s632 :: SBool = s363 ^ s631-  s633 :: SBool = if s361 then s632 else s631-  s634 :: SBool = s343 ^ s633-  s635 :: SBool = if s383 then s634 else s633-  s636 :: SBool = s325 ^ s635-  s637 :: SBool = if s407 then s636 else s635-  s638 :: SBool = s309 ^ s637-  s639 :: SBool = if s433 then s638 else s637-  s640 :: SBool = s295 ^ s639-  s641 :: SBool = if s461 then s640 else s639-  s642 :: SBool = s283 ^ s641-  s643 :: SBool = if s491 then s642 else s641-  s644 :: SBool = s273 ^ s643-  s645 :: SBool = if s523 then s644 else s643-  s646 :: SBool = s265 ^ s645-  s647 :: SBool = if s555 then s646 else s645-  s648 :: SBool = s259 ^ s647-  s649 :: SBool = if s587 then s648 else s647-  s650 :: SBool = s255 ^ s649-  s651 :: SBool = if s619 then s650 else s649-  s652 :: SBool = s7 ^ s115-  s653 :: SBool = if s281 then s652 else s115-  s654 :: SBool = s493 ^ s653-  s655 :: SBool = if s293 then s654 else s653-  s656 :: SBool = s463 ^ s655-  s657 :: SBool = if s307 then s656 else s655-  s658 :: SBool = s435 ^ s657-  s659 :: SBool = if s323 then s658 else s657-  s660 :: SBool = s409 ^ s659-  s661 :: SBool = if s341 then s660 else s659-  s662 :: SBool = s385 ^ s661-  s663 :: SBool = if s361 then s662 else s661-  s664 :: SBool = s363 ^ s663-  s665 :: SBool = if s383 then s664 else s663-  s666 :: SBool = s343 ^ s665-  s667 :: SBool = if s407 then s666 else s665-  s668 :: SBool = s325 ^ s667-  s669 :: SBool = if s433 then s668 else s667-  s670 :: SBool = s309 ^ s669-  s671 :: SBool = if s461 then s670 else s669-  s672 :: SBool = s295 ^ s671-  s673 :: SBool = if s491 then s672 else s671-  s674 :: SBool = s283 ^ s673-  s675 :: SBool = if s523 then s674 else s673-  s676 :: SBool = s273 ^ s675-  s677 :: SBool = if s555 then s676 else s675-  s678 :: SBool = s265 ^ s677-  s679 :: SBool = if s587 then s678 else s677-  s680 :: SBool = s259 ^ s679-  s681 :: SBool = if s619 then s680 else s679-  s682 :: SBool = s255 ^ s681-  s683 :: SBool = if s651 then s682 else s681-  s684 :: SBool = s7 ^ s120-  s685 :: SBool = if s293 then s684 else s120-  s686 :: SBool = s493 ^ s685-  s687 :: SBool = if s307 then s686 else s685-  s688 :: SBool = s463 ^ s687-  s689 :: SBool = if s323 then s688 else s687-  s690 :: SBool = s435 ^ s689-  s691 :: SBool = if s341 then s690 else s689-  s692 :: SBool = s409 ^ s691-  s693 :: SBool = if s361 then s692 else s691-  s694 :: SBool = s385 ^ s693-  s695 :: SBool = if s383 then s694 else s693-  s696 :: SBool = s363 ^ s695-  s697 :: SBool = if s407 then s696 else s695-  s698 :: SBool = s343 ^ s697-  s699 :: SBool = if s433 then s698 else s697-  s700 :: SBool = s325 ^ s699-  s701 :: SBool = if s461 then s700 else s699-  s702 :: SBool = s309 ^ s701-  s703 :: SBool = if s491 then s702 else s701-  s704 :: SBool = s295 ^ s703-  s705 :: SBool = if s523 then s704 else s703-  s706 :: SBool = s283 ^ s705-  s707 :: SBool = if s555 then s706 else s705-  s708 :: SBool = s273 ^ s707-  s709 :: SBool = if s587 then s708 else s707-  s710 :: SBool = s265 ^ s709-  s711 :: SBool = if s619 then s710 else s709-  s712 :: SBool = s259 ^ s711-  s713 :: SBool = if s651 then s712 else s711-  s714 :: SBool = s255 ^ s713-  s715 :: SBool = if s683 then s714 else s713-  s716 :: SBool = s7 ^ s125-  s717 :: SBool = if s307 then s716 else s125-  s718 :: SBool = s493 ^ s717-  s719 :: SBool = if s323 then s718 else s717-  s720 :: SBool = s463 ^ s719-  s721 :: SBool = if s341 then s720 else s719-  s722 :: SBool = s435 ^ s721-  s723 :: SBool = if s361 then s722 else s721-  s724 :: SBool = s409 ^ s723-  s725 :: SBool = if s383 then s724 else s723-  s726 :: SBool = s385 ^ s725-  s727 :: SBool = if s407 then s726 else s725-  s728 :: SBool = s363 ^ s727-  s729 :: SBool = if s433 then s728 else s727-  s730 :: SBool = s343 ^ s729-  s731 :: SBool = if s461 then s730 else s729-  s732 :: SBool = s325 ^ s731-  s733 :: SBool = if s491 then s732 else s731-  s734 :: SBool = s309 ^ s733-  s735 :: SBool = if s523 then s734 else s733-  s736 :: SBool = s295 ^ s735-  s737 :: SBool = if s555 then s736 else s735-  s738 :: SBool = s283 ^ s737-  s739 :: SBool = if s587 then s738 else s737-  s740 :: SBool = s273 ^ s739-  s741 :: SBool = if s619 then s740 else s739-  s742 :: SBool = s265 ^ s741-  s743 :: SBool = if s651 then s742 else s741-  s744 :: SBool = s259 ^ s743-  s745 :: SBool = if s683 then s744 else s743-  s746 :: SBool = s255 ^ s745-  s747 :: SBool = if s715 then s746 else s745-  s748 :: SBool = s7 ^ s130-  s749 :: SBool = if s323 then s748 else s130-  s750 :: SBool = s493 ^ s749-  s751 :: SBool = if s341 then s750 else s749-  s752 :: SBool = s463 ^ s751-  s753 :: SBool = if s361 then s752 else s751-  s754 :: SBool = s435 ^ s753-  s755 :: SBool = if s383 then s754 else s753-  s756 :: SBool = s409 ^ s755-  s757 :: SBool = if s407 then s756 else s755-  s758 :: SBool = s385 ^ s757-  s759 :: SBool = if s433 then s758 else s757-  s760 :: SBool = s363 ^ s759-  s761 :: SBool = if s461 then s760 else s759-  s762 :: SBool = s343 ^ s761-  s763 :: SBool = if s491 then s762 else s761-  s764 :: SBool = s325 ^ s763-  s765 :: SBool = if s523 then s764 else s763-  s766 :: SBool = s309 ^ s765-  s767 :: SBool = if s555 then s766 else s765-  s768 :: SBool = s295 ^ s767-  s769 :: SBool = if s587 then s768 else s767-  s770 :: SBool = s283 ^ s769-  s771 :: SBool = if s619 then s770 else s769-  s772 :: SBool = s273 ^ s771-  s773 :: SBool = if s651 then s772 else s771-  s774 :: SBool = s265 ^ s773-  s775 :: SBool = if s683 then s774 else s773-  s776 :: SBool = s259 ^ s775-  s777 :: SBool = if s715 then s776 else s775-  s778 :: SBool = s255 ^ s777-  s779 :: SBool = if s747 then s778 else s777-  s780 :: SBool = s7 ^ s135-  s781 :: SBool = if s341 then s780 else s135-  s782 :: SBool = s493 ^ s781-  s783 :: SBool = if s361 then s782 else s781-  s784 :: SBool = s463 ^ s783-  s785 :: SBool = if s383 then s784 else s783-  s786 :: SBool = s435 ^ s785-  s787 :: SBool = if s407 then s786 else s785-  s788 :: SBool = s409 ^ s787-  s789 :: SBool = if s433 then s788 else s787-  s790 :: SBool = s385 ^ s789-  s791 :: SBool = if s461 then s790 else s789-  s792 :: SBool = s363 ^ s791-  s793 :: SBool = if s491 then s792 else s791-  s794 :: SBool = s343 ^ s793-  s795 :: SBool = if s523 then s794 else s793-  s796 :: SBool = s325 ^ s795-  s797 :: SBool = if s555 then s796 else s795-  s798 :: SBool = s309 ^ s797-  s799 :: SBool = if s587 then s798 else s797-  s800 :: SBool = s295 ^ s799-  s801 :: SBool = if s619 then s800 else s799-  s802 :: SBool = s283 ^ s801-  s803 :: SBool = if s651 then s802 else s801-  s804 :: SBool = s273 ^ s803-  s805 :: SBool = if s683 then s804 else s803-  s806 :: SBool = s265 ^ s805-  s807 :: SBool = if s715 then s806 else s805-  s808 :: SBool = s259 ^ s807-  s809 :: SBool = if s747 then s808 else s807-  s810 :: SBool = s255 ^ s809-  s811 :: SBool = if s779 then s810 else s809-  s812 :: SBool = s7 ^ s140-  s813 :: SBool = if s361 then s812 else s140-  s814 :: SBool = s493 ^ s813-  s815 :: SBool = if s383 then s814 else s813-  s816 :: SBool = s463 ^ s815-  s817 :: SBool = if s407 then s816 else s815-  s818 :: SBool = s435 ^ s817-  s819 :: SBool = if s433 then s818 else s817-  s820 :: SBool = s409 ^ s819-  s821 :: SBool = if s461 then s820 else s819-  s822 :: SBool = s385 ^ s821-  s823 :: SBool = if s491 then s822 else s821-  s824 :: SBool = s363 ^ s823-  s825 :: SBool = if s523 then s824 else s823-  s826 :: SBool = s343 ^ s825-  s827 :: SBool = if s555 then s826 else s825-  s828 :: SBool = s325 ^ s827-  s829 :: SBool = if s587 then s828 else s827-  s830 :: SBool = s309 ^ s829-  s831 :: SBool = if s619 then s830 else s829-  s832 :: SBool = s295 ^ s831-  s833 :: SBool = if s651 then s832 else s831-  s834 :: SBool = s283 ^ s833-  s835 :: SBool = if s683 then s834 else s833-  s836 :: SBool = s273 ^ s835-  s837 :: SBool = if s715 then s836 else s835-  s838 :: SBool = s265 ^ s837-  s839 :: SBool = if s747 then s838 else s837-  s840 :: SBool = s259 ^ s839-  s841 :: SBool = if s779 then s840 else s839-  s842 :: SBool = s255 ^ s841-  s843 :: SBool = if s811 then s842 else s841-  s844 :: SBool = s7 ^ s145-  s845 :: SBool = if s383 then s844 else s145-  s846 :: SBool = s493 ^ s845-  s847 :: SBool = if s407 then s846 else s845-  s848 :: SBool = s463 ^ s847-  s849 :: SBool = if s433 then s848 else s847-  s850 :: SBool = s435 ^ s849-  s851 :: SBool = if s461 then s850 else s849-  s852 :: SBool = s409 ^ s851-  s853 :: SBool = if s491 then s852 else s851-  s854 :: SBool = s385 ^ s853-  s855 :: SBool = if s523 then s854 else s853-  s856 :: SBool = s363 ^ s855-  s857 :: SBool = if s555 then s856 else s855-  s858 :: SBool = s343 ^ s857-  s859 :: SBool = if s587 then s858 else s857-  s860 :: SBool = s325 ^ s859-  s861 :: SBool = if s619 then s860 else s859-  s862 :: SBool = s309 ^ s861-  s863 :: SBool = if s651 then s862 else s861-  s864 :: SBool = s295 ^ s863-  s865 :: SBool = if s683 then s864 else s863-  s866 :: SBool = s283 ^ s865-  s867 :: SBool = if s715 then s866 else s865-  s868 :: SBool = s273 ^ s867-  s869 :: SBool = if s747 then s868 else s867-  s870 :: SBool = s265 ^ s869-  s871 :: SBool = if s779 then s870 else s869-  s872 :: SBool = s259 ^ s871-  s873 :: SBool = if s811 then s872 else s871-  s874 :: SBool = s255 ^ s873-  s875 :: SBool = if s843 then s874 else s873-  s876 :: SBool = s7 ^ s150-  s877 :: SBool = if s407 then s876 else s150-  s878 :: SBool = s493 ^ s877-  s879 :: SBool = if s433 then s878 else s877-  s880 :: SBool = s463 ^ s879-  s881 :: SBool = if s461 then s880 else s879-  s882 :: SBool = s435 ^ s881-  s883 :: SBool = if s491 then s882 else s881-  s884 :: SBool = s409 ^ s883-  s885 :: SBool = if s523 then s884 else s883-  s886 :: SBool = s385 ^ s885-  s887 :: SBool = if s555 then s886 else s885-  s888 :: SBool = s363 ^ s887-  s889 :: SBool = if s587 then s888 else s887-  s890 :: SBool = s343 ^ s889-  s891 :: SBool = if s619 then s890 else s889-  s892 :: SBool = s325 ^ s891-  s893 :: SBool = if s651 then s892 else s891-  s894 :: SBool = s309 ^ s893-  s895 :: SBool = if s683 then s894 else s893-  s896 :: SBool = s295 ^ s895-  s897 :: SBool = if s715 then s896 else s895-  s898 :: SBool = s283 ^ s897-  s899 :: SBool = if s747 then s898 else s897-  s900 :: SBool = s273 ^ s899-  s901 :: SBool = if s779 then s900 else s899-  s902 :: SBool = s265 ^ s901-  s903 :: SBool = if s811 then s902 else s901-  s904 :: SBool = s259 ^ s903-  s905 :: SBool = if s843 then s904 else s903-  s906 :: SBool = s255 ^ s905-  s907 :: SBool = if s875 then s906 else s905-  s908 :: SBool = s7 ^ s155-  s909 :: SBool = if s433 then s908 else s155-  s910 :: SBool = s493 ^ s909-  s911 :: SBool = if s461 then s910 else s909-  s912 :: SBool = s463 ^ s911-  s913 :: SBool = if s491 then s912 else s911-  s914 :: SBool = s435 ^ s913-  s915 :: SBool = if s523 then s914 else s913-  s916 :: SBool = s409 ^ s915-  s917 :: SBool = if s555 then s916 else s915-  s918 :: SBool = s385 ^ s917-  s919 :: SBool = if s587 then s918 else s917-  s920 :: SBool = s363 ^ s919-  s921 :: SBool = if s619 then s920 else s919-  s922 :: SBool = s343 ^ s921-  s923 :: SBool = if s651 then s922 else s921-  s924 :: SBool = s325 ^ s923-  s925 :: SBool = if s683 then s924 else s923-  s926 :: SBool = s309 ^ s925-  s927 :: SBool = if s715 then s926 else s925-  s928 :: SBool = s295 ^ s927-  s929 :: SBool = if s747 then s928 else s927-  s930 :: SBool = s283 ^ s929-  s931 :: SBool = if s779 then s930 else s929-  s932 :: SBool = s273 ^ s931-  s933 :: SBool = if s811 then s932 else s931-  s934 :: SBool = s265 ^ s933-  s935 :: SBool = if s843 then s934 else s933-  s936 :: SBool = s259 ^ s935-  s937 :: SBool = if s875 then s936 else s935-  s938 :: SBool = s255 ^ s937-  s939 :: SBool = if s907 then s938 else s937-  s940 :: SBool = s7 ^ s160-  s941 :: SBool = if s461 then s940 else s160-  s942 :: SBool = s493 ^ s941-  s943 :: SBool = if s491 then s942 else s941-  s944 :: SBool = s463 ^ s943-  s945 :: SBool = if s523 then s944 else s943-  s946 :: SBool = s435 ^ s945-  s947 :: SBool = if s555 then s946 else s945-  s948 :: SBool = s409 ^ s947-  s949 :: SBool = if s587 then s948 else s947-  s950 :: SBool = s385 ^ s949-  s951 :: SBool = if s619 then s950 else s949-  s952 :: SBool = s363 ^ s951-  s953 :: SBool = if s651 then s952 else s951-  s954 :: SBool = s343 ^ s953-  s955 :: SBool = if s683 then s954 else s953-  s956 :: SBool = s325 ^ s955-  s957 :: SBool = if s715 then s956 else s955-  s958 :: SBool = s309 ^ s957-  s959 :: SBool = if s747 then s958 else s957-  s960 :: SBool = s295 ^ s959-  s961 :: SBool = if s779 then s960 else s959-  s962 :: SBool = s283 ^ s961-  s963 :: SBool = if s811 then s962 else s961-  s964 :: SBool = s273 ^ s963-  s965 :: SBool = if s843 then s964 else s963-  s966 :: SBool = s265 ^ s965-  s967 :: SBool = if s875 then s966 else s965-  s968 :: SBool = s259 ^ s967-  s969 :: SBool = if s907 then s968 else s967-  s970 :: SBool = s255 ^ s969-  s971 :: SBool = if s939 then s970 else s969-  s972 :: SBool = s7 ^ s165-  s973 :: SBool = if s491 then s972 else s165-  s974 :: SBool = s493 ^ s973-  s975 :: SBool = if s523 then s974 else s973-  s976 :: SBool = s463 ^ s975-  s977 :: SBool = if s555 then s976 else s975-  s978 :: SBool = s435 ^ s977-  s979 :: SBool = if s587 then s978 else s977-  s980 :: SBool = s409 ^ s979-  s981 :: SBool = if s619 then s980 else s979-  s982 :: SBool = s385 ^ s981-  s983 :: SBool = if s651 then s982 else s981-  s984 :: SBool = s363 ^ s983-  s985 :: SBool = if s683 then s984 else s983-  s986 :: SBool = s343 ^ s985-  s987 :: SBool = if s715 then s986 else s985-  s988 :: SBool = s325 ^ s987-  s989 :: SBool = if s747 then s988 else s987-  s990 :: SBool = s309 ^ s989-  s991 :: SBool = if s779 then s990 else s989-  s992 :: SBool = s295 ^ s991-  s993 :: SBool = if s811 then s992 else s991-  s994 :: SBool = s283 ^ s993-  s995 :: SBool = if s843 then s994 else s993-  s996 :: SBool = s273 ^ s995-  s997 :: SBool = if s875 then s996 else s995-  s998 :: SBool = s265 ^ s997-  s999 :: SBool = if s907 then s998 else s997-  s1000 :: SBool = s259 ^ s999-  s1001 :: SBool = if s939 then s1000 else s999-  s1002 :: SBool = s255 ^ s1001-  s1003 :: SBool = if s971 then s1002 else s1001-  s1004 :: SBool = s7 ^ s170-  s1005 :: SBool = if s523 then s1004 else s170-  s1006 :: SBool = s493 ^ s1005-  s1007 :: SBool = if s555 then s1006 else s1005-  s1008 :: SBool = s463 ^ s1007-  s1009 :: SBool = if s587 then s1008 else s1007-  s1010 :: SBool = s435 ^ s1009-  s1011 :: SBool = if s619 then s1010 else s1009-  s1012 :: SBool = s409 ^ s1011-  s1013 :: SBool = if s651 then s1012 else s1011-  s1014 :: SBool = s385 ^ s1013-  s1015 :: SBool = if s683 then s1014 else s1013-  s1016 :: SBool = s363 ^ s1015-  s1017 :: SBool = if s715 then s1016 else s1015-  s1018 :: SBool = s343 ^ s1017-  s1019 :: SBool = if s747 then s1018 else s1017-  s1020 :: SBool = s325 ^ s1019-  s1021 :: SBool = if s779 then s1020 else s1019-  s1022 :: SBool = s309 ^ s1021-  s1023 :: SBool = if s811 then s1022 else s1021-  s1024 :: SBool = s295 ^ s1023-  s1025 :: SBool = if s843 then s1024 else s1023-  s1026 :: SBool = s283 ^ s1025-  s1027 :: SBool = if s875 then s1026 else s1025-  s1028 :: SBool = s273 ^ s1027-  s1029 :: SBool = if s907 then s1028 else s1027-  s1030 :: SBool = s265 ^ s1029-  s1031 :: SBool = if s939 then s1030 else s1029-  s1032 :: SBool = s259 ^ s1031-  s1033 :: SBool = if s971 then s1032 else s1031-  s1034 :: SBool = s255 ^ s1033-  s1035 :: SBool = if s1003 then s1034 else s1033-  s1036 :: SBool = s7 ^ s175-  s1037 :: SBool = if s555 then s1036 else s175-  s1038 :: SBool = s493 ^ s1037-  s1039 :: SBool = if s587 then s1038 else s1037-  s1040 :: SBool = s463 ^ s1039-  s1041 :: SBool = if s619 then s1040 else s1039-  s1042 :: SBool = s435 ^ s1041-  s1043 :: SBool = if s651 then s1042 else s1041-  s1044 :: SBool = s409 ^ s1043-  s1045 :: SBool = if s683 then s1044 else s1043-  s1046 :: SBool = s385 ^ s1045-  s1047 :: SBool = if s715 then s1046 else s1045-  s1048 :: SBool = s363 ^ s1047-  s1049 :: SBool = if s747 then s1048 else s1047-  s1050 :: SBool = s343 ^ s1049-  s1051 :: SBool = if s779 then s1050 else s1049-  s1052 :: SBool = s325 ^ s1051-  s1053 :: SBool = if s811 then s1052 else s1051-  s1054 :: SBool = s309 ^ s1053-  s1055 :: SBool = if s843 then s1054 else s1053-  s1056 :: SBool = s295 ^ s1055-  s1057 :: SBool = if s875 then s1056 else s1055-  s1058 :: SBool = s283 ^ s1057-  s1059 :: SBool = if s907 then s1058 else s1057-  s1060 :: SBool = s273 ^ s1059-  s1061 :: SBool = if s939 then s1060 else s1059-  s1062 :: SBool = s265 ^ s1061-  s1063 :: SBool = if s971 then s1062 else s1061-  s1064 :: SBool = s259 ^ s1063-  s1065 :: SBool = if s1003 then s1064 else s1063-  s1066 :: SBool = s255 ^ s1065-  s1067 :: SBool = if s1035 then s1066 else s1065-  s1068 :: SBool = s7 ^ s180-  s1069 :: SBool = if s587 then s1068 else s180-  s1070 :: SBool = s493 ^ s1069-  s1071 :: SBool = if s619 then s1070 else s1069-  s1072 :: SBool = s463 ^ s1071-  s1073 :: SBool = if s651 then s1072 else s1071-  s1074 :: SBool = s435 ^ s1073-  s1075 :: SBool = if s683 then s1074 else s1073-  s1076 :: SBool = s409 ^ s1075-  s1077 :: SBool = if s715 then s1076 else s1075-  s1078 :: SBool = s385 ^ s1077-  s1079 :: SBool = if s747 then s1078 else s1077-  s1080 :: SBool = s363 ^ s1079-  s1081 :: SBool = if s779 then s1080 else s1079-  s1082 :: SBool = s343 ^ s1081-  s1083 :: SBool = if s811 then s1082 else s1081-  s1084 :: SBool = s325 ^ s1083-  s1085 :: SBool = if s843 then s1084 else s1083-  s1086 :: SBool = s309 ^ s1085-  s1087 :: SBool = if s875 then s1086 else s1085-  s1088 :: SBool = s295 ^ s1087-  s1089 :: SBool = if s907 then s1088 else s1087-  s1090 :: SBool = s283 ^ s1089-  s1091 :: SBool = if s939 then s1090 else s1089-  s1092 :: SBool = s273 ^ s1091-  s1093 :: SBool = if s971 then s1092 else s1091-  s1094 :: SBool = s265 ^ s1093-  s1095 :: SBool = if s1003 then s1094 else s1093-  s1096 :: SBool = s259 ^ s1095-  s1097 :: SBool = if s1035 then s1096 else s1095-  s1098 :: SBool = s255 ^ s1097-  s1099 :: SBool = if s1067 then s1098 else s1097-  s1100 :: SBool = s7 ^ s185-  s1101 :: SBool = if s619 then s1100 else s185-  s1102 :: SBool = s493 ^ s1101-  s1103 :: SBool = if s651 then s1102 else s1101-  s1104 :: SBool = s463 ^ s1103-  s1105 :: SBool = if s683 then s1104 else s1103-  s1106 :: SBool = s435 ^ s1105-  s1107 :: SBool = if s715 then s1106 else s1105-  s1108 :: SBool = s409 ^ s1107-  s1109 :: SBool = if s747 then s1108 else s1107-  s1110 :: SBool = s385 ^ s1109-  s1111 :: SBool = if s779 then s1110 else s1109-  s1112 :: SBool = s363 ^ s1111-  s1113 :: SBool = if s811 then s1112 else s1111-  s1114 :: SBool = s343 ^ s1113-  s1115 :: SBool = if s843 then s1114 else s1113-  s1116 :: SBool = s325 ^ s1115-  s1117 :: SBool = if s875 then s1116 else s1115-  s1118 :: SBool = s309 ^ s1117-  s1119 :: SBool = if s907 then s1118 else s1117-  s1120 :: SBool = s295 ^ s1119-  s1121 :: SBool = if s939 then s1120 else s1119-  s1122 :: SBool = s283 ^ s1121-  s1123 :: SBool = if s971 then s1122 else s1121-  s1124 :: SBool = s273 ^ s1123-  s1125 :: SBool = if s1003 then s1124 else s1123-  s1126 :: SBool = s265 ^ s1125-  s1127 :: SBool = if s1035 then s1126 else s1125-  s1128 :: SBool = s259 ^ s1127-  s1129 :: SBool = if s1067 then s1128 else s1127-  s1130 :: SBool = s255 ^ s1129-  s1131 :: SBool = if s1099 then s1130 else s1129-  s1132 :: SBool = s7 ^ s190-  s1133 :: SBool = if s651 then s1132 else s190-  s1134 :: SBool = s493 ^ s1133-  s1135 :: SBool = if s683 then s1134 else s1133-  s1136 :: SBool = s463 ^ s1135-  s1137 :: SBool = if s715 then s1136 else s1135-  s1138 :: SBool = s435 ^ s1137-  s1139 :: SBool = if s747 then s1138 else s1137-  s1140 :: SBool = s409 ^ s1139-  s1141 :: SBool = if s779 then s1140 else s1139-  s1142 :: SBool = s385 ^ s1141-  s1143 :: SBool = if s811 then s1142 else s1141-  s1144 :: SBool = s363 ^ s1143-  s1145 :: SBool = if s843 then s1144 else s1143-  s1146 :: SBool = s343 ^ s1145-  s1147 :: SBool = if s875 then s1146 else s1145-  s1148 :: SBool = s325 ^ s1147-  s1149 :: SBool = if s907 then s1148 else s1147-  s1150 :: SBool = s309 ^ s1149-  s1151 :: SBool = if s939 then s1150 else s1149-  s1152 :: SBool = s295 ^ s1151-  s1153 :: SBool = if s971 then s1152 else s1151-  s1154 :: SBool = s283 ^ s1153-  s1155 :: SBool = if s1003 then s1154 else s1153-  s1156 :: SBool = s273 ^ s1155-  s1157 :: SBool = if s1035 then s1156 else s1155-  s1158 :: SBool = s265 ^ s1157-  s1159 :: SBool = if s1067 then s1158 else s1157-  s1160 :: SBool = s259 ^ s1159-  s1161 :: SBool = if s1099 then s1160 else s1159-  s1162 :: SBool = s255 ^ s1161-  s1163 :: SBool = if s1131 then s1162 else s1161-  s1164 :: SBool = s7 ^ s195-  s1165 :: SBool = if s683 then s1164 else s195-  s1166 :: SBool = s493 ^ s1165-  s1167 :: SBool = if s715 then s1166 else s1165-  s1168 :: SBool = s463 ^ s1167-  s1169 :: SBool = if s747 then s1168 else s1167-  s1170 :: SBool = s435 ^ s1169-  s1171 :: SBool = if s779 then s1170 else s1169-  s1172 :: SBool = s409 ^ s1171-  s1173 :: SBool = if s811 then s1172 else s1171-  s1174 :: SBool = s385 ^ s1173-  s1175 :: SBool = if s843 then s1174 else s1173-  s1176 :: SBool = s363 ^ s1175-  s1177 :: SBool = if s875 then s1176 else s1175-  s1178 :: SBool = s343 ^ s1177-  s1179 :: SBool = if s907 then s1178 else s1177-  s1180 :: SBool = s325 ^ s1179-  s1181 :: SBool = if s939 then s1180 else s1179-  s1182 :: SBool = s309 ^ s1181-  s1183 :: SBool = if s971 then s1182 else s1181-  s1184 :: SBool = s295 ^ s1183-  s1185 :: SBool = if s1003 then s1184 else s1183-  s1186 :: SBool = s283 ^ s1185-  s1187 :: SBool = if s1035 then s1186 else s1185-  s1188 :: SBool = s273 ^ s1187-  s1189 :: SBool = if s1067 then s1188 else s1187-  s1190 :: SBool = s265 ^ s1189-  s1191 :: SBool = if s1099 then s1190 else s1189-  s1192 :: SBool = s259 ^ s1191-  s1193 :: SBool = if s1131 then s1192 else s1191-  s1194 :: SBool = s255 ^ s1193-  s1195 :: SBool = if s1163 then s1194 else s1193-  s1196 :: SBool = s7 ^ s200-  s1197 :: SBool = if s715 then s1196 else s200-  s1198 :: SBool = s493 ^ s1197-  s1199 :: SBool = if s747 then s1198 else s1197-  s1200 :: SBool = s463 ^ s1199-  s1201 :: SBool = if s779 then s1200 else s1199-  s1202 :: SBool = s435 ^ s1201-  s1203 :: SBool = if s811 then s1202 else s1201-  s1204 :: SBool = s409 ^ s1203-  s1205 :: SBool = if s843 then s1204 else s1203-  s1206 :: SBool = s385 ^ s1205-  s1207 :: SBool = if s875 then s1206 else s1205-  s1208 :: SBool = s363 ^ s1207-  s1209 :: SBool = if s907 then s1208 else s1207-  s1210 :: SBool = s343 ^ s1209-  s1211 :: SBool = if s939 then s1210 else s1209-  s1212 :: SBool = s325 ^ s1211-  s1213 :: SBool = if s971 then s1212 else s1211-  s1214 :: SBool = s309 ^ s1213-  s1215 :: SBool = if s1003 then s1214 else s1213-  s1216 :: SBool = s295 ^ s1215-  s1217 :: SBool = if s1035 then s1216 else s1215-  s1218 :: SBool = s283 ^ s1217-  s1219 :: SBool = if s1067 then s1218 else s1217-  s1220 :: SBool = s273 ^ s1219-  s1221 :: SBool = if s1099 then s1220 else s1219-  s1222 :: SBool = s265 ^ s1221-  s1223 :: SBool = if s1131 then s1222 else s1221-  s1224 :: SBool = s259 ^ s1223-  s1225 :: SBool = if s1163 then s1224 else s1223-  s1226 :: SBool = s255 ^ s1225-  s1227 :: SBool = if s1195 then s1226 else s1225-  s1228 :: SBool = s7 ^ s205-  s1229 :: SBool = if s747 then s1228 else s205-  s1230 :: SBool = s493 ^ s1229-  s1231 :: SBool = if s779 then s1230 else s1229-  s1232 :: SBool = s463 ^ s1231-  s1233 :: SBool = if s811 then s1232 else s1231-  s1234 :: SBool = s435 ^ s1233-  s1235 :: SBool = if s843 then s1234 else s1233-  s1236 :: SBool = s409 ^ s1235-  s1237 :: SBool = if s875 then s1236 else s1235-  s1238 :: SBool = s385 ^ s1237-  s1239 :: SBool = if s907 then s1238 else s1237-  s1240 :: SBool = s363 ^ s1239-  s1241 :: SBool = if s939 then s1240 else s1239-  s1242 :: SBool = s343 ^ s1241-  s1243 :: SBool = if s971 then s1242 else s1241-  s1244 :: SBool = s325 ^ s1243-  s1245 :: SBool = if s1003 then s1244 else s1243-  s1246 :: SBool = s309 ^ s1245-  s1247 :: SBool = if s1035 then s1246 else s1245-  s1248 :: SBool = s295 ^ s1247-  s1249 :: SBool = if s1067 then s1248 else s1247-  s1250 :: SBool = s283 ^ s1249-  s1251 :: SBool = if s1099 then s1250 else s1249-  s1252 :: SBool = s273 ^ s1251-  s1253 :: SBool = if s1131 then s1252 else s1251-  s1254 :: SBool = s265 ^ s1253-  s1255 :: SBool = if s1163 then s1254 else s1253-  s1256 :: SBool = s259 ^ s1255-  s1257 :: SBool = if s1195 then s1256 else s1255-  s1258 :: SBool = s255 ^ s1257-  s1259 :: SBool = if s1227 then s1258 else s1257-  s1260 :: SBool = s7 ^ s210-  s1261 :: SBool = if s779 then s1260 else s210-  s1262 :: SBool = s493 ^ s1261-  s1263 :: SBool = if s811 then s1262 else s1261-  s1264 :: SBool = s463 ^ s1263-  s1265 :: SBool = if s843 then s1264 else s1263-  s1266 :: SBool = s435 ^ s1265-  s1267 :: SBool = if s875 then s1266 else s1265-  s1268 :: SBool = s409 ^ s1267-  s1269 :: SBool = if s907 then s1268 else s1267-  s1270 :: SBool = s385 ^ s1269-  s1271 :: SBool = if s939 then s1270 else s1269-  s1272 :: SBool = s363 ^ s1271-  s1273 :: SBool = if s971 then s1272 else s1271-  s1274 :: SBool = s343 ^ s1273-  s1275 :: SBool = if s1003 then s1274 else s1273-  s1276 :: SBool = s325 ^ s1275-  s1277 :: SBool = if s1035 then s1276 else s1275-  s1278 :: SBool = s309 ^ s1277-  s1279 :: SBool = if s1067 then s1278 else s1277-  s1280 :: SBool = s295 ^ s1279-  s1281 :: SBool = if s1099 then s1280 else s1279-  s1282 :: SBool = s283 ^ s1281-  s1283 :: SBool = if s1131 then s1282 else s1281-  s1284 :: SBool = s273 ^ s1283-  s1285 :: SBool = if s1163 then s1284 else s1283-  s1286 :: SBool = s265 ^ s1285-  s1287 :: SBool = if s1195 then s1286 else s1285-  s1288 :: SBool = s259 ^ s1287-  s1289 :: SBool = if s1227 then s1288 else s1287-  s1290 :: SBool = s255 ^ s1289-  s1291 :: SBool = if s1259 then s1290 else s1289-  s1292 :: SBool = s7 ^ s215-  s1293 :: SBool = if s811 then s1292 else s215-  s1294 :: SBool = s493 ^ s1293-  s1295 :: SBool = if s843 then s1294 else s1293-  s1296 :: SBool = s463 ^ s1295-  s1297 :: SBool = if s875 then s1296 else s1295-  s1298 :: SBool = s435 ^ s1297-  s1299 :: SBool = if s907 then s1298 else s1297-  s1300 :: SBool = s409 ^ s1299-  s1301 :: SBool = if s939 then s1300 else s1299-  s1302 :: SBool = s385 ^ s1301-  s1303 :: SBool = if s971 then s1302 else s1301-  s1304 :: SBool = s363 ^ s1303-  s1305 :: SBool = if s1003 then s1304 else s1303-  s1306 :: SBool = s343 ^ s1305-  s1307 :: SBool = if s1035 then s1306 else s1305-  s1308 :: SBool = s325 ^ s1307-  s1309 :: SBool = if s1067 then s1308 else s1307-  s1310 :: SBool = s309 ^ s1309-  s1311 :: SBool = if s1099 then s1310 else s1309-  s1312 :: SBool = s295 ^ s1311-  s1313 :: SBool = if s1131 then s1312 else s1311-  s1314 :: SBool = s283 ^ s1313-  s1315 :: SBool = if s1163 then s1314 else s1313-  s1316 :: SBool = s273 ^ s1315-  s1317 :: SBool = if s1195 then s1316 else s1315-  s1318 :: SBool = s265 ^ s1317-  s1319 :: SBool = if s1227 then s1318 else s1317-  s1320 :: SBool = s259 ^ s1319-  s1321 :: SBool = if s1259 then s1320 else s1319-  s1322 :: SBool = s255 ^ s1321-  s1323 :: SBool = if s1291 then s1322 else s1321-  s1324 :: SBool = s7 ^ s220-  s1325 :: SBool = if s843 then s1324 else s220-  s1326 :: SBool = s493 ^ s1325-  s1327 :: SBool = if s875 then s1326 else s1325-  s1328 :: SBool = s463 ^ s1327-  s1329 :: SBool = if s907 then s1328 else s1327-  s1330 :: SBool = s435 ^ s1329-  s1331 :: SBool = if s939 then s1330 else s1329-  s1332 :: SBool = s409 ^ s1331-  s1333 :: SBool = if s971 then s1332 else s1331-  s1334 :: SBool = s385 ^ s1333-  s1335 :: SBool = if s1003 then s1334 else s1333-  s1336 :: SBool = s363 ^ s1335-  s1337 :: SBool = if s1035 then s1336 else s1335-  s1338 :: SBool = s343 ^ s1337-  s1339 :: SBool = if s1067 then s1338 else s1337-  s1340 :: SBool = s325 ^ s1339-  s1341 :: SBool = if s1099 then s1340 else s1339-  s1342 :: SBool = s309 ^ s1341-  s1343 :: SBool = if s1131 then s1342 else s1341-  s1344 :: SBool = s295 ^ s1343-  s1345 :: SBool = if s1163 then s1344 else s1343-  s1346 :: SBool = s283 ^ s1345-  s1347 :: SBool = if s1195 then s1346 else s1345-  s1348 :: SBool = s273 ^ s1347-  s1349 :: SBool = if s1227 then s1348 else s1347-  s1350 :: SBool = s265 ^ s1349-  s1351 :: SBool = if s1259 then s1350 else s1349-  s1352 :: SBool = s259 ^ s1351-  s1353 :: SBool = if s1291 then s1352 else s1351-  s1354 :: SBool = s255 ^ s1353-  s1355 :: SBool = if s1323 then s1354 else s1353-  s1356 :: SBool = s7 ^ s225-  s1357 :: SBool = if s875 then s1356 else s225-  s1358 :: SBool = s493 ^ s1357-  s1359 :: SBool = if s907 then s1358 else s1357-  s1360 :: SBool = s463 ^ s1359-  s1361 :: SBool = if s939 then s1360 else s1359-  s1362 :: SBool = s435 ^ s1361-  s1363 :: SBool = if s971 then s1362 else s1361-  s1364 :: SBool = s409 ^ s1363-  s1365 :: SBool = if s1003 then s1364 else s1363-  s1366 :: SBool = s385 ^ s1365-  s1367 :: SBool = if s1035 then s1366 else s1365-  s1368 :: SBool = s363 ^ s1367-  s1369 :: SBool = if s1067 then s1368 else s1367-  s1370 :: SBool = s343 ^ s1369-  s1371 :: SBool = if s1099 then s1370 else s1369-  s1372 :: SBool = s325 ^ s1371-  s1373 :: SBool = if s1131 then s1372 else s1371-  s1374 :: SBool = s309 ^ s1373-  s1375 :: SBool = if s1163 then s1374 else s1373-  s1376 :: SBool = s295 ^ s1375-  s1377 :: SBool = if s1195 then s1376 else s1375-  s1378 :: SBool = s283 ^ s1377-  s1379 :: SBool = if s1227 then s1378 else s1377-  s1380 :: SBool = s273 ^ s1379-  s1381 :: SBool = if s1259 then s1380 else s1379-  s1382 :: SBool = s265 ^ s1381-  s1383 :: SBool = if s1291 then s1382 else s1381-  s1384 :: SBool = s259 ^ s1383-  s1385 :: SBool = if s1323 then s1384 else s1383-  s1386 :: SBool = s255 ^ s1385-  s1387 :: SBool = if s1355 then s1386 else s1385-  s1388 :: SBool = s7 ^ s230-  s1389 :: SBool = if s907 then s1388 else s230-  s1390 :: SBool = s493 ^ s1389-  s1391 :: SBool = if s939 then s1390 else s1389-  s1392 :: SBool = s463 ^ s1391-  s1393 :: SBool = if s971 then s1392 else s1391-  s1394 :: SBool = s435 ^ s1393-  s1395 :: SBool = if s1003 then s1394 else s1393-  s1396 :: SBool = s409 ^ s1395-  s1397 :: SBool = if s1035 then s1396 else s1395-  s1398 :: SBool = s385 ^ s1397-  s1399 :: SBool = if s1067 then s1398 else s1397-  s1400 :: SBool = s363 ^ s1399-  s1401 :: SBool = if s1099 then s1400 else s1399-  s1402 :: SBool = s343 ^ s1401-  s1403 :: SBool = if s1131 then s1402 else s1401-  s1404 :: SBool = s325 ^ s1403-  s1405 :: SBool = if s1163 then s1404 else s1403-  s1406 :: SBool = s309 ^ s1405-  s1407 :: SBool = if s1195 then s1406 else s1405-  s1408 :: SBool = s295 ^ s1407-  s1409 :: SBool = if s1227 then s1408 else s1407-  s1410 :: SBool = s283 ^ s1409-  s1411 :: SBool = if s1259 then s1410 else s1409-  s1412 :: SBool = s273 ^ s1411-  s1413 :: SBool = if s1291 then s1412 else s1411-  s1414 :: SBool = s265 ^ s1413-  s1415 :: SBool = if s1323 then s1414 else s1413-  s1416 :: SBool = s259 ^ s1415-  s1417 :: SBool = if s1355 then s1416 else s1415-  s1418 :: SBool = s255 ^ s1417-  s1419 :: SBool = if s1387 then s1418 else s1417-  s1420 :: SBool = s7 ^ s235-  s1421 :: SBool = if s939 then s1420 else s235-  s1422 :: SBool = s493 ^ s1421-  s1423 :: SBool = if s971 then s1422 else s1421-  s1424 :: SBool = s463 ^ s1423-  s1425 :: SBool = if s1003 then s1424 else s1423-  s1426 :: SBool = s435 ^ s1425-  s1427 :: SBool = if s1035 then s1426 else s1425-  s1428 :: SBool = s409 ^ s1427-  s1429 :: SBool = if s1067 then s1428 else s1427-  s1430 :: SBool = s385 ^ s1429-  s1431 :: SBool = if s1099 then s1430 else s1429-  s1432 :: SBool = s363 ^ s1431-  s1433 :: SBool = if s1131 then s1432 else s1431-  s1434 :: SBool = s343 ^ s1433-  s1435 :: SBool = if s1163 then s1434 else s1433-  s1436 :: SBool = s325 ^ s1435-  s1437 :: SBool = if s1195 then s1436 else s1435-  s1438 :: SBool = s309 ^ s1437-  s1439 :: SBool = if s1227 then s1438 else s1437-  s1440 :: SBool = s295 ^ s1439-  s1441 :: SBool = if s1259 then s1440 else s1439-  s1442 :: SBool = s283 ^ s1441-  s1443 :: SBool = if s1291 then s1442 else s1441-  s1444 :: SBool = s273 ^ s1443-  s1445 :: SBool = if s1323 then s1444 else s1443-  s1446 :: SBool = s265 ^ s1445-  s1447 :: SBool = if s1355 then s1446 else s1445-  s1448 :: SBool = s259 ^ s1447-  s1449 :: SBool = if s1387 then s1448 else s1447-  s1450 :: SBool = s255 ^ s1449-  s1451 :: SBool = if s1419 then s1450 else s1449-  s1452 :: SBool = s7 ^ s240-  s1453 :: SBool = if s971 then s1452 else s240-  s1454 :: SBool = s493 ^ s1453-  s1455 :: SBool = if s1003 then s1454 else s1453-  s1456 :: SBool = s463 ^ s1455-  s1457 :: SBool = if s1035 then s1456 else s1455-  s1458 :: SBool = s435 ^ s1457-  s1459 :: SBool = if s1067 then s1458 else s1457-  s1460 :: SBool = s409 ^ s1459-  s1461 :: SBool = if s1099 then s1460 else s1459-  s1462 :: SBool = s385 ^ s1461-  s1463 :: SBool = if s1131 then s1462 else s1461-  s1464 :: SBool = s363 ^ s1463-  s1465 :: SBool = if s1163 then s1464 else s1463-  s1466 :: SBool = s343 ^ s1465-  s1467 :: SBool = if s1195 then s1466 else s1465-  s1468 :: SBool = s325 ^ s1467-  s1469 :: SBool = if s1227 then s1468 else s1467-  s1470 :: SBool = s309 ^ s1469-  s1471 :: SBool = if s1259 then s1470 else s1469-  s1472 :: SBool = s295 ^ s1471-  s1473 :: SBool = if s1291 then s1472 else s1471-  s1474 :: SBool = s283 ^ s1473-  s1475 :: SBool = if s1323 then s1474 else s1473-  s1476 :: SBool = s273 ^ s1475-  s1477 :: SBool = if s1355 then s1476 else s1475-  s1478 :: SBool = s265 ^ s1477-  s1479 :: SBool = if s1387 then s1478 else s1477-  s1480 :: SBool = s259 ^ s1479-  s1481 :: SBool = if s1419 then s1480 else s1479-  s1482 :: SBool = s255 ^ s1481-  s1483 :: SBool = if s1451 then s1482 else s1481-  s1484 :: SBool = s7 ^ s245-  s1485 :: SBool = if s1003 then s1484 else s245-  s1486 :: SBool = s493 ^ s1485-  s1487 :: SBool = if s1035 then s1486 else s1485-  s1488 :: SBool = s463 ^ s1487-  s1489 :: SBool = if s1067 then s1488 else s1487-  s1490 :: SBool = s435 ^ s1489-  s1491 :: SBool = if s1099 then s1490 else s1489-  s1492 :: SBool = s409 ^ s1491-  s1493 :: SBool = if s1131 then s1492 else s1491-  s1494 :: SBool = s385 ^ s1493-  s1495 :: SBool = if s1163 then s1494 else s1493-  s1496 :: SBool = s363 ^ s1495-  s1497 :: SBool = if s1195 then s1496 else s1495-  s1498 :: SBool = s343 ^ s1497-  s1499 :: SBool = if s1227 then s1498 else s1497-  s1500 :: SBool = s325 ^ s1499-  s1501 :: SBool = if s1259 then s1500 else s1499-  s1502 :: SBool = s309 ^ s1501-  s1503 :: SBool = if s1291 then s1502 else s1501-  s1504 :: SBool = s295 ^ s1503-  s1505 :: SBool = if s1323 then s1504 else s1503-  s1506 :: SBool = s283 ^ s1505-  s1507 :: SBool = if s1355 then s1506 else s1505-  s1508 :: SBool = s273 ^ s1507-  s1509 :: SBool = if s1387 then s1508 else s1507-  s1510 :: SBool = s265 ^ s1509-  s1511 :: SBool = if s1419 then s1510 else s1509-  s1512 :: SBool = s259 ^ s1511-  s1513 :: SBool = if s1451 then s1512 else s1511-  s1514 :: SBool = s255 ^ s1513-  s1515 :: SBool = if s1483 then s1514 else s1513-  s1516 :: SBool = s7 ^ s250-  s1517 :: SBool = if s1035 then s1516 else s250-  s1518 :: SBool = s493 ^ s1517-  s1519 :: SBool = if s1067 then s1518 else s1517-  s1520 :: SBool = s463 ^ s1519-  s1521 :: SBool = if s1099 then s1520 else s1519-  s1522 :: SBool = s435 ^ s1521-  s1523 :: SBool = if s1131 then s1522 else s1521-  s1524 :: SBool = s409 ^ s1523-  s1525 :: SBool = if s1163 then s1524 else s1523-  s1526 :: SBool = s385 ^ s1525-  s1527 :: SBool = if s1195 then s1526 else s1525-  s1528 :: SBool = s363 ^ s1527-  s1529 :: SBool = if s1227 then s1528 else s1527-  s1530 :: SBool = s343 ^ s1529-  s1531 :: SBool = if s1259 then s1530 else s1529-  s1532 :: SBool = s325 ^ s1531-  s1533 :: SBool = if s1291 then s1532 else s1531-  s1534 :: SBool = s309 ^ s1533-  s1535 :: SBool = if s1323 then s1534 else s1533-  s1536 :: SBool = s295 ^ s1535-  s1537 :: SBool = if s1355 then s1536 else s1535-  s1538 :: SBool = s283 ^ s1537-  s1539 :: SBool = if s1387 then s1538 else s1537-  s1540 :: SBool = s273 ^ s1539-  s1541 :: SBool = if s1419 then s1540 else s1539-  s1542 :: SBool = s265 ^ s1541-  s1543 :: SBool = if s1451 then s1542 else s1541-  s1544 :: SBool = s259 ^ s1543-  s1545 :: SBool = if s1483 then s1544 else s1543-  s1546 :: SBool = s255 ^ s1545-  s1547 :: SBool = if s1515 then s1546 else s1545-  s1548 :: SBool = if s1067 then s7 else s_2-  s1549 :: SBool = s493 ^ s1548-  s1550 :: SBool = if s1099 then s1549 else s1548-  s1551 :: SBool = s463 ^ s1550-  s1552 :: SBool = if s1131 then s1551 else s1550-  s1553 :: SBool = s435 ^ s1552-  s1554 :: SBool = if s1163 then s1553 else s1552-  s1555 :: SBool = s409 ^ s1554-  s1556 :: SBool = if s1195 then s1555 else s1554-  s1557 :: SBool = s385 ^ s1556-  s1558 :: SBool = if s1227 then s1557 else s1556-  s1559 :: SBool = s363 ^ s1558-  s1560 :: SBool = if s1259 then s1559 else s1558-  s1561 :: SBool = s343 ^ s1560-  s1562 :: SBool = if s1291 then s1561 else s1560-  s1563 :: SBool = s325 ^ s1562-  s1564 :: SBool = if s1323 then s1563 else s1562-  s1565 :: SBool = s309 ^ s1564-  s1566 :: SBool = if s1355 then s1565 else s1564-  s1567 :: SBool = s295 ^ s1566-  s1568 :: SBool = if s1387 then s1567 else s1566-  s1569 :: SBool = s283 ^ s1568-  s1570 :: SBool = if s1419 then s1569 else s1568-  s1571 :: SBool = s273 ^ s1570-  s1572 :: SBool = if s1451 then s1571 else s1570-  s1573 :: SBool = s265 ^ s1572-  s1574 :: SBool = if s1483 then s1573 else s1572-  s1575 :: SBool = s259 ^ s1574-  s1576 :: SBool = if s1515 then s1575 else s1574-  s1577 :: SBool = s255 ^ s1576-  s1578 :: SBool = if s1547 then s1577 else s1576-  s1579 :: SBool = s22 ^ s255-  s1580 :: SBool = if s16 then s1579 else s22-  s1581 :: SBool = s27 ^ s259-  s1582 :: SBool = if s16 then s1581 else s27-  s1583 :: SBool = s255 ^ s1582-  s1584 :: SBool = if s1580 then s1583 else s1582-  s1585 :: SBool = s32 ^ s265-  s1586 :: SBool = if s16 then s1585 else s32-  s1587 :: SBool = s259 ^ s1586-  s1588 :: SBool = if s1580 then s1587 else s1586-  s1589 :: SBool = s255 ^ s1588-  s1590 :: SBool = if s1584 then s1589 else s1588-  s1591 :: SBool = s37 ^ s273-  s1592 :: SBool = if s16 then s1591 else s37-  s1593 :: SBool = s265 ^ s1592-  s1594 :: SBool = if s1580 then s1593 else s1592-  s1595 :: SBool = s259 ^ s1594-  s1596 :: SBool = if s1584 then s1595 else s1594-  s1597 :: SBool = s255 ^ s1596-  s1598 :: SBool = if s1590 then s1597 else s1596-  s1599 :: SBool = s42 ^ s283-  s1600 :: SBool = if s16 then s1599 else s42-  s1601 :: SBool = s273 ^ s1600-  s1602 :: SBool = if s1580 then s1601 else s1600-  s1603 :: SBool = s265 ^ s1602-  s1604 :: SBool = if s1584 then s1603 else s1602-  s1605 :: SBool = s259 ^ s1604-  s1606 :: SBool = if s1590 then s1605 else s1604-  s1607 :: SBool = s255 ^ s1606-  s1608 :: SBool = if s1598 then s1607 else s1606-  s1609 :: SBool = s47 ^ s295-  s1610 :: SBool = if s16 then s1609 else s47-  s1611 :: SBool = s283 ^ s1610-  s1612 :: SBool = if s1580 then s1611 else s1610-  s1613 :: SBool = s273 ^ s1612-  s1614 :: SBool = if s1584 then s1613 else s1612-  s1615 :: SBool = s265 ^ s1614-  s1616 :: SBool = if s1590 then s1615 else s1614-  s1617 :: SBool = s259 ^ s1616-  s1618 :: SBool = if s1598 then s1617 else s1616-  s1619 :: SBool = s255 ^ s1618-  s1620 :: SBool = if s1608 then s1619 else s1618-  s1621 :: SBool = s52 ^ s309-  s1622 :: SBool = if s16 then s1621 else s52-  s1623 :: SBool = s295 ^ s1622-  s1624 :: SBool = if s1580 then s1623 else s1622-  s1625 :: SBool = s283 ^ s1624-  s1626 :: SBool = if s1584 then s1625 else s1624-  s1627 :: SBool = s273 ^ s1626-  s1628 :: SBool = if s1590 then s1627 else s1626-  s1629 :: SBool = s265 ^ s1628-  s1630 :: SBool = if s1598 then s1629 else s1628-  s1631 :: SBool = s259 ^ s1630-  s1632 :: SBool = if s1608 then s1631 else s1630-  s1633 :: SBool = s255 ^ s1632-  s1634 :: SBool = if s1620 then s1633 else s1632-  s1635 :: SBool = s57 ^ s325-  s1636 :: SBool = if s16 then s1635 else s57-  s1637 :: SBool = s309 ^ s1636-  s1638 :: SBool = if s1580 then s1637 else s1636-  s1639 :: SBool = s295 ^ s1638-  s1640 :: SBool = if s1584 then s1639 else s1638-  s1641 :: SBool = s283 ^ s1640-  s1642 :: SBool = if s1590 then s1641 else s1640-  s1643 :: SBool = s273 ^ s1642-  s1644 :: SBool = if s1598 then s1643 else s1642-  s1645 :: SBool = s265 ^ s1644-  s1646 :: SBool = if s1608 then s1645 else s1644-  s1647 :: SBool = s259 ^ s1646-  s1648 :: SBool = if s1620 then s1647 else s1646-  s1649 :: SBool = s255 ^ s1648-  s1650 :: SBool = if s1634 then s1649 else s1648-  s1651 :: SBool = s62 ^ s343-  s1652 :: SBool = if s16 then s1651 else s62-  s1653 :: SBool = s325 ^ s1652-  s1654 :: SBool = if s1580 then s1653 else s1652-  s1655 :: SBool = s309 ^ s1654-  s1656 :: SBool = if s1584 then s1655 else s1654-  s1657 :: SBool = s295 ^ s1656-  s1658 :: SBool = if s1590 then s1657 else s1656-  s1659 :: SBool = s283 ^ s1658-  s1660 :: SBool = if s1598 then s1659 else s1658-  s1661 :: SBool = s273 ^ s1660-  s1662 :: SBool = if s1608 then s1661 else s1660-  s1663 :: SBool = s265 ^ s1662-  s1664 :: SBool = if s1620 then s1663 else s1662-  s1665 :: SBool = s259 ^ s1664-  s1666 :: SBool = if s1634 then s1665 else s1664-  s1667 :: SBool = s255 ^ s1666-  s1668 :: SBool = if s1650 then s1667 else s1666-  s1669 :: SBool = s67 ^ s363-  s1670 :: SBool = if s16 then s1669 else s67-  s1671 :: SBool = s343 ^ s1670-  s1672 :: SBool = if s1580 then s1671 else s1670-  s1673 :: SBool = s325 ^ s1672-  s1674 :: SBool = if s1584 then s1673 else s1672-  s1675 :: SBool = s309 ^ s1674-  s1676 :: SBool = if s1590 then s1675 else s1674-  s1677 :: SBool = s295 ^ s1676-  s1678 :: SBool = if s1598 then s1677 else s1676-  s1679 :: SBool = s283 ^ s1678-  s1680 :: SBool = if s1608 then s1679 else s1678-  s1681 :: SBool = s273 ^ s1680-  s1682 :: SBool = if s1620 then s1681 else s1680-  s1683 :: SBool = s265 ^ s1682-  s1684 :: SBool = if s1634 then s1683 else s1682-  s1685 :: SBool = s259 ^ s1684-  s1686 :: SBool = if s1650 then s1685 else s1684-  s1687 :: SBool = s255 ^ s1686-  s1688 :: SBool = if s1668 then s1687 else s1686-  s1689 :: SBool = s72 ^ s385-  s1690 :: SBool = if s16 then s1689 else s72-  s1691 :: SBool = s363 ^ s1690-  s1692 :: SBool = if s1580 then s1691 else s1690-  s1693 :: SBool = s343 ^ s1692-  s1694 :: SBool = if s1584 then s1693 else s1692-  s1695 :: SBool = s325 ^ s1694-  s1696 :: SBool = if s1590 then s1695 else s1694-  s1697 :: SBool = s309 ^ s1696-  s1698 :: SBool = if s1598 then s1697 else s1696-  s1699 :: SBool = s295 ^ s1698-  s1700 :: SBool = if s1608 then s1699 else s1698-  s1701 :: SBool = s283 ^ s1700-  s1702 :: SBool = if s1620 then s1701 else s1700-  s1703 :: SBool = s273 ^ s1702-  s1704 :: SBool = if s1634 then s1703 else s1702-  s1705 :: SBool = s265 ^ s1704-  s1706 :: SBool = if s1650 then s1705 else s1704-  s1707 :: SBool = s259 ^ s1706-  s1708 :: SBool = if s1668 then s1707 else s1706-  s1709 :: SBool = s255 ^ s1708-  s1710 :: SBool = if s1688 then s1709 else s1708-  s1711 :: SBool = s77 ^ s409-  s1712 :: SBool = if s16 then s1711 else s77-  s1713 :: SBool = s385 ^ s1712-  s1714 :: SBool = if s1580 then s1713 else s1712-  s1715 :: SBool = s363 ^ s1714-  s1716 :: SBool = if s1584 then s1715 else s1714-  s1717 :: SBool = s343 ^ s1716-  s1718 :: SBool = if s1590 then s1717 else s1716-  s1719 :: SBool = s325 ^ s1718-  s1720 :: SBool = if s1598 then s1719 else s1718-  s1721 :: SBool = s309 ^ s1720-  s1722 :: SBool = if s1608 then s1721 else s1720-  s1723 :: SBool = s295 ^ s1722-  s1724 :: SBool = if s1620 then s1723 else s1722-  s1725 :: SBool = s283 ^ s1724-  s1726 :: SBool = if s1634 then s1725 else s1724-  s1727 :: SBool = s273 ^ s1726-  s1728 :: SBool = if s1650 then s1727 else s1726-  s1729 :: SBool = s265 ^ s1728-  s1730 :: SBool = if s1668 then s1729 else s1728-  s1731 :: SBool = s259 ^ s1730-  s1732 :: SBool = if s1688 then s1731 else s1730-  s1733 :: SBool = s255 ^ s1732-  s1734 :: SBool = if s1710 then s1733 else s1732-  s1735 :: SBool = s82 ^ s435-  s1736 :: SBool = if s16 then s1735 else s82-  s1737 :: SBool = s409 ^ s1736-  s1738 :: SBool = if s1580 then s1737 else s1736-  s1739 :: SBool = s385 ^ s1738-  s1740 :: SBool = if s1584 then s1739 else s1738-  s1741 :: SBool = s363 ^ s1740-  s1742 :: SBool = if s1590 then s1741 else s1740-  s1743 :: SBool = s343 ^ s1742-  s1744 :: SBool = if s1598 then s1743 else s1742-  s1745 :: SBool = s325 ^ s1744-  s1746 :: SBool = if s1608 then s1745 else s1744-  s1747 :: SBool = s309 ^ s1746-  s1748 :: SBool = if s1620 then s1747 else s1746-  s1749 :: SBool = s295 ^ s1748-  s1750 :: SBool = if s1634 then s1749 else s1748-  s1751 :: SBool = s283 ^ s1750-  s1752 :: SBool = if s1650 then s1751 else s1750-  s1753 :: SBool = s273 ^ s1752-  s1754 :: SBool = if s1668 then s1753 else s1752-  s1755 :: SBool = s265 ^ s1754-  s1756 :: SBool = if s1688 then s1755 else s1754-  s1757 :: SBool = s259 ^ s1756-  s1758 :: SBool = if s1710 then s1757 else s1756-  s1759 :: SBool = s255 ^ s1758-  s1760 :: SBool = if s1734 then s1759 else s1758-  s1761 :: SBool = s87 ^ s463-  s1762 :: SBool = if s16 then s1761 else s87-  s1763 :: SBool = s435 ^ s1762-  s1764 :: SBool = if s1580 then s1763 else s1762-  s1765 :: SBool = s409 ^ s1764-  s1766 :: SBool = if s1584 then s1765 else s1764-  s1767 :: SBool = s385 ^ s1766-  s1768 :: SBool = if s1590 then s1767 else s1766-  s1769 :: SBool = s363 ^ s1768-  s1770 :: SBool = if s1598 then s1769 else s1768-  s1771 :: SBool = s343 ^ s1770-  s1772 :: SBool = if s1608 then s1771 else s1770-  s1773 :: SBool = s325 ^ s1772-  s1774 :: SBool = if s1620 then s1773 else s1772-  s1775 :: SBool = s309 ^ s1774-  s1776 :: SBool = if s1634 then s1775 else s1774-  s1777 :: SBool = s295 ^ s1776-  s1778 :: SBool = if s1650 then s1777 else s1776-  s1779 :: SBool = s283 ^ s1778-  s1780 :: SBool = if s1668 then s1779 else s1778-  s1781 :: SBool = s273 ^ s1780-  s1782 :: SBool = if s1688 then s1781 else s1780-  s1783 :: SBool = s265 ^ s1782-  s1784 :: SBool = if s1710 then s1783 else s1782-  s1785 :: SBool = s259 ^ s1784-  s1786 :: SBool = if s1734 then s1785 else s1784-  s1787 :: SBool = s255 ^ s1786-  s1788 :: SBool = if s1760 then s1787 else s1786-  s1789 :: SBool = s92 ^ s493-  s1790 :: SBool = if s16 then s1789 else s92-  s1791 :: SBool = s463 ^ s1790-  s1792 :: SBool = if s1580 then s1791 else s1790-  s1793 :: SBool = s435 ^ s1792-  s1794 :: SBool = if s1584 then s1793 else s1792-  s1795 :: SBool = s409 ^ s1794-  s1796 :: SBool = if s1590 then s1795 else s1794-  s1797 :: SBool = s385 ^ s1796-  s1798 :: SBool = if s1598 then s1797 else s1796-  s1799 :: SBool = s363 ^ s1798-  s1800 :: SBool = if s1608 then s1799 else s1798-  s1801 :: SBool = s343 ^ s1800-  s1802 :: SBool = if s1620 then s1801 else s1800-  s1803 :: SBool = s325 ^ s1802-  s1804 :: SBool = if s1634 then s1803 else s1802-  s1805 :: SBool = s309 ^ s1804-  s1806 :: SBool = if s1650 then s1805 else s1804-  s1807 :: SBool = s295 ^ s1806-  s1808 :: SBool = if s1668 then s1807 else s1806-  s1809 :: SBool = s283 ^ s1808-  s1810 :: SBool = if s1688 then s1809 else s1808-  s1811 :: SBool = s273 ^ s1810-  s1812 :: SBool = if s1710 then s1811 else s1810-  s1813 :: SBool = s265 ^ s1812-  s1814 :: SBool = if s1734 then s1813 else s1812-  s1815 :: SBool = s259 ^ s1814-  s1816 :: SBool = if s1760 then s1815 else s1814-  s1817 :: SBool = s255 ^ s1816-  s1818 :: SBool = if s1788 then s1817 else s1816-  s1819 :: SBool = s7 ^ s97-  s1820 :: SBool = if s16 then s1819 else s97-  s1821 :: SBool = s493 ^ s1820-  s1822 :: SBool = if s1580 then s1821 else s1820-  s1823 :: SBool = s463 ^ s1822-  s1824 :: SBool = if s1584 then s1823 else s1822-  s1825 :: SBool = s435 ^ s1824-  s1826 :: SBool = if s1590 then s1825 else s1824-  s1827 :: SBool = s409 ^ s1826-  s1828 :: SBool = if s1598 then s1827 else s1826-  s1829 :: SBool = s385 ^ s1828-  s1830 :: SBool = if s1608 then s1829 else s1828-  s1831 :: SBool = s363 ^ s1830-  s1832 :: SBool = if s1620 then s1831 else s1830-  s1833 :: SBool = s343 ^ s1832-  s1834 :: SBool = if s1634 then s1833 else s1832-  s1835 :: SBool = s325 ^ s1834-  s1836 :: SBool = if s1650 then s1835 else s1834-  s1837 :: SBool = s309 ^ s1836-  s1838 :: SBool = if s1668 then s1837 else s1836-  s1839 :: SBool = s295 ^ s1838-  s1840 :: SBool = if s1688 then s1839 else s1838-  s1841 :: SBool = s283 ^ s1840-  s1842 :: SBool = if s1710 then s1841 else s1840-  s1843 :: SBool = s273 ^ s1842-  s1844 :: SBool = if s1734 then s1843 else s1842-  s1845 :: SBool = s265 ^ s1844-  s1846 :: SBool = if s1760 then s1845 else s1844-  s1847 :: SBool = s259 ^ s1846-  s1848 :: SBool = if s1788 then s1847 else s1846-  s1849 :: SBool = s255 ^ s1848-  s1850 :: SBool = if s1818 then s1849 else s1848-  s1851 :: SBool = s7 ^ s102-  s1852 :: SBool = if s1580 then s1851 else s102-  s1853 :: SBool = s493 ^ s1852-  s1854 :: SBool = if s1584 then s1853 else s1852-  s1855 :: SBool = s463 ^ s1854-  s1856 :: SBool = if s1590 then s1855 else s1854-  s1857 :: SBool = s435 ^ s1856-  s1858 :: SBool = if s1598 then s1857 else s1856-  s1859 :: SBool = s409 ^ s1858-  s1860 :: SBool = if s1608 then s1859 else s1858-  s1861 :: SBool = s385 ^ s1860-  s1862 :: SBool = if s1620 then s1861 else s1860-  s1863 :: SBool = s363 ^ s1862-  s1864 :: SBool = if s1634 then s1863 else s1862-  s1865 :: SBool = s343 ^ s1864-  s1866 :: SBool = if s1650 then s1865 else s1864-  s1867 :: SBool = s325 ^ s1866-  s1868 :: SBool = if s1668 then s1867 else s1866-  s1869 :: SBool = s309 ^ s1868-  s1870 :: SBool = if s1688 then s1869 else s1868-  s1871 :: SBool = s295 ^ s1870-  s1872 :: SBool = if s1710 then s1871 else s1870-  s1873 :: SBool = s283 ^ s1872-  s1874 :: SBool = if s1734 then s1873 else s1872-  s1875 :: SBool = s273 ^ s1874-  s1876 :: SBool = if s1760 then s1875 else s1874-  s1877 :: SBool = s265 ^ s1876-  s1878 :: SBool = if s1788 then s1877 else s1876-  s1879 :: SBool = s259 ^ s1878-  s1880 :: SBool = if s1818 then s1879 else s1878-  s1881 :: SBool = s255 ^ s1880-  s1882 :: SBool = if s1850 then s1881 else s1880-  s1883 :: SBool = s7 ^ s107-  s1884 :: SBool = if s1584 then s1883 else s107-  s1885 :: SBool = s493 ^ s1884-  s1886 :: SBool = if s1590 then s1885 else s1884-  s1887 :: SBool = s463 ^ s1886-  s1888 :: SBool = if s1598 then s1887 else s1886-  s1889 :: SBool = s435 ^ s1888-  s1890 :: SBool = if s1608 then s1889 else s1888-  s1891 :: SBool = s409 ^ s1890-  s1892 :: SBool = if s1620 then s1891 else s1890-  s1893 :: SBool = s385 ^ s1892-  s1894 :: SBool = if s1634 then s1893 else s1892-  s1895 :: SBool = s363 ^ s1894-  s1896 :: SBool = if s1650 then s1895 else s1894-  s1897 :: SBool = s343 ^ s1896-  s1898 :: SBool = if s1668 then s1897 else s1896-  s1899 :: SBool = s325 ^ s1898-  s1900 :: SBool = if s1688 then s1899 else s1898-  s1901 :: SBool = s309 ^ s1900-  s1902 :: SBool = if s1710 then s1901 else s1900-  s1903 :: SBool = s295 ^ s1902-  s1904 :: SBool = if s1734 then s1903 else s1902-  s1905 :: SBool = s283 ^ s1904-  s1906 :: SBool = if s1760 then s1905 else s1904-  s1907 :: SBool = s273 ^ s1906-  s1908 :: SBool = if s1788 then s1907 else s1906-  s1909 :: SBool = s265 ^ s1908-  s1910 :: SBool = if s1818 then s1909 else s1908-  s1911 :: SBool = s259 ^ s1910-  s1912 :: SBool = if s1850 then s1911 else s1910-  s1913 :: SBool = s255 ^ s1912-  s1914 :: SBool = if s1882 then s1913 else s1912-  s1915 :: SBool = s7 ^ s112-  s1916 :: SBool = if s1590 then s1915 else s112-  s1917 :: SBool = s493 ^ s1916-  s1918 :: SBool = if s1598 then s1917 else s1916-  s1919 :: SBool = s463 ^ s1918-  s1920 :: SBool = if s1608 then s1919 else s1918-  s1921 :: SBool = s435 ^ s1920-  s1922 :: SBool = if s1620 then s1921 else s1920-  s1923 :: SBool = s409 ^ s1922-  s1924 :: SBool = if s1634 then s1923 else s1922-  s1925 :: SBool = s385 ^ s1924-  s1926 :: SBool = if s1650 then s1925 else s1924-  s1927 :: SBool = s363 ^ s1926-  s1928 :: SBool = if s1668 then s1927 else s1926-  s1929 :: SBool = s343 ^ s1928-  s1930 :: SBool = if s1688 then s1929 else s1928-  s1931 :: SBool = s325 ^ s1930-  s1932 :: SBool = if s1710 then s1931 else s1930-  s1933 :: SBool = s309 ^ s1932-  s1934 :: SBool = if s1734 then s1933 else s1932-  s1935 :: SBool = s295 ^ s1934-  s1936 :: SBool = if s1760 then s1935 else s1934-  s1937 :: SBool = s283 ^ s1936-  s1938 :: SBool = if s1788 then s1937 else s1936-  s1939 :: SBool = s273 ^ s1938-  s1940 :: SBool = if s1818 then s1939 else s1938-  s1941 :: SBool = s265 ^ s1940-  s1942 :: SBool = if s1850 then s1941 else s1940-  s1943 :: SBool = s259 ^ s1942-  s1944 :: SBool = if s1882 then s1943 else s1942-  s1945 :: SBool = s255 ^ s1944-  s1946 :: SBool = if s1914 then s1945 else s1944-  s1947 :: SBool = s7 ^ s117-  s1948 :: SBool = if s1598 then s1947 else s117-  s1949 :: SBool = s493 ^ s1948-  s1950 :: SBool = if s1608 then s1949 else s1948-  s1951 :: SBool = s463 ^ s1950-  s1952 :: SBool = if s1620 then s1951 else s1950-  s1953 :: SBool = s435 ^ s1952-  s1954 :: SBool = if s1634 then s1953 else s1952-  s1955 :: SBool = s409 ^ s1954-  s1956 :: SBool = if s1650 then s1955 else s1954-  s1957 :: SBool = s385 ^ s1956-  s1958 :: SBool = if s1668 then s1957 else s1956-  s1959 :: SBool = s363 ^ s1958-  s1960 :: SBool = if s1688 then s1959 else s1958-  s1961 :: SBool = s343 ^ s1960-  s1962 :: SBool = if s1710 then s1961 else s1960-  s1963 :: SBool = s325 ^ s1962-  s1964 :: SBool = if s1734 then s1963 else s1962-  s1965 :: SBool = s309 ^ s1964-  s1966 :: SBool = if s1760 then s1965 else s1964-  s1967 :: SBool = s295 ^ s1966-  s1968 :: SBool = if s1788 then s1967 else s1966-  s1969 :: SBool = s283 ^ s1968-  s1970 :: SBool = if s1818 then s1969 else s1968-  s1971 :: SBool = s273 ^ s1970-  s1972 :: SBool = if s1850 then s1971 else s1970-  s1973 :: SBool = s265 ^ s1972-  s1974 :: SBool = if s1882 then s1973 else s1972-  s1975 :: SBool = s259 ^ s1974-  s1976 :: SBool = if s1914 then s1975 else s1974-  s1977 :: SBool = s255 ^ s1976-  s1978 :: SBool = if s1946 then s1977 else s1976-  s1979 :: SBool = s7 ^ s122-  s1980 :: SBool = if s1608 then s1979 else s122-  s1981 :: SBool = s493 ^ s1980-  s1982 :: SBool = if s1620 then s1981 else s1980-  s1983 :: SBool = s463 ^ s1982-  s1984 :: SBool = if s1634 then s1983 else s1982-  s1985 :: SBool = s435 ^ s1984-  s1986 :: SBool = if s1650 then s1985 else s1984-  s1987 :: SBool = s409 ^ s1986-  s1988 :: SBool = if s1668 then s1987 else s1986-  s1989 :: SBool = s385 ^ s1988-  s1990 :: SBool = if s1688 then s1989 else s1988-  s1991 :: SBool = s363 ^ s1990-  s1992 :: SBool = if s1710 then s1991 else s1990-  s1993 :: SBool = s343 ^ s1992-  s1994 :: SBool = if s1734 then s1993 else s1992-  s1995 :: SBool = s325 ^ s1994-  s1996 :: SBool = if s1760 then s1995 else s1994-  s1997 :: SBool = s309 ^ s1996-  s1998 :: SBool = if s1788 then s1997 else s1996-  s1999 :: SBool = s295 ^ s1998-  s2000 :: SBool = if s1818 then s1999 else s1998-  s2001 :: SBool = s283 ^ s2000-  s2002 :: SBool = if s1850 then s2001 else s2000-  s2003 :: SBool = s273 ^ s2002-  s2004 :: SBool = if s1882 then s2003 else s2002-  s2005 :: SBool = s265 ^ s2004-  s2006 :: SBool = if s1914 then s2005 else s2004-  s2007 :: SBool = s259 ^ s2006-  s2008 :: SBool = if s1946 then s2007 else s2006-  s2009 :: SBool = s255 ^ s2008-  s2010 :: SBool = if s1978 then s2009 else s2008-  s2011 :: SBool = s7 ^ s127-  s2012 :: SBool = if s1620 then s2011 else s127-  s2013 :: SBool = s493 ^ s2012-  s2014 :: SBool = if s1634 then s2013 else s2012-  s2015 :: SBool = s463 ^ s2014-  s2016 :: SBool = if s1650 then s2015 else s2014-  s2017 :: SBool = s435 ^ s2016-  s2018 :: SBool = if s1668 then s2017 else s2016-  s2019 :: SBool = s409 ^ s2018-  s2020 :: SBool = if s1688 then s2019 else s2018-  s2021 :: SBool = s385 ^ s2020-  s2022 :: SBool = if s1710 then s2021 else s2020-  s2023 :: SBool = s363 ^ s2022-  s2024 :: SBool = if s1734 then s2023 else s2022-  s2025 :: SBool = s343 ^ s2024-  s2026 :: SBool = if s1760 then s2025 else s2024-  s2027 :: SBool = s325 ^ s2026-  s2028 :: SBool = if s1788 then s2027 else s2026-  s2029 :: SBool = s309 ^ s2028-  s2030 :: SBool = if s1818 then s2029 else s2028-  s2031 :: SBool = s295 ^ s2030-  s2032 :: SBool = if s1850 then s2031 else s2030-  s2033 :: SBool = s283 ^ s2032-  s2034 :: SBool = if s1882 then s2033 else s2032-  s2035 :: SBool = s273 ^ s2034-  s2036 :: SBool = if s1914 then s2035 else s2034-  s2037 :: SBool = s265 ^ s2036-  s2038 :: SBool = if s1946 then s2037 else s2036-  s2039 :: SBool = s259 ^ s2038-  s2040 :: SBool = if s1978 then s2039 else s2038-  s2041 :: SBool = s255 ^ s2040-  s2042 :: SBool = if s2010 then s2041 else s2040-  s2043 :: SBool = s7 ^ s132-  s2044 :: SBool = if s1634 then s2043 else s132-  s2045 :: SBool = s493 ^ s2044-  s2046 :: SBool = if s1650 then s2045 else s2044-  s2047 :: SBool = s463 ^ s2046-  s2048 :: SBool = if s1668 then s2047 else s2046-  s2049 :: SBool = s435 ^ s2048-  s2050 :: SBool = if s1688 then s2049 else s2048-  s2051 :: SBool = s409 ^ s2050-  s2052 :: SBool = if s1710 then s2051 else s2050-  s2053 :: SBool = s385 ^ s2052-  s2054 :: SBool = if s1734 then s2053 else s2052-  s2055 :: SBool = s363 ^ s2054-  s2056 :: SBool = if s1760 then s2055 else s2054-  s2057 :: SBool = s343 ^ s2056-  s2058 :: SBool = if s1788 then s2057 else s2056-  s2059 :: SBool = s325 ^ s2058-  s2060 :: SBool = if s1818 then s2059 else s2058-  s2061 :: SBool = s309 ^ s2060-  s2062 :: SBool = if s1850 then s2061 else s2060-  s2063 :: SBool = s295 ^ s2062-  s2064 :: SBool = if s1882 then s2063 else s2062-  s2065 :: SBool = s283 ^ s2064-  s2066 :: SBool = if s1914 then s2065 else s2064-  s2067 :: SBool = s273 ^ s2066-  s2068 :: SBool = if s1946 then s2067 else s2066-  s2069 :: SBool = s265 ^ s2068-  s2070 :: SBool = if s1978 then s2069 else s2068-  s2071 :: SBool = s259 ^ s2070-  s2072 :: SBool = if s2010 then s2071 else s2070-  s2073 :: SBool = s255 ^ s2072-  s2074 :: SBool = if s2042 then s2073 else s2072-  s2075 :: SBool = s7 ^ s137-  s2076 :: SBool = if s1650 then s2075 else s137-  s2077 :: SBool = s493 ^ s2076-  s2078 :: SBool = if s1668 then s2077 else s2076-  s2079 :: SBool = s463 ^ s2078-  s2080 :: SBool = if s1688 then s2079 else s2078-  s2081 :: SBool = s435 ^ s2080-  s2082 :: SBool = if s1710 then s2081 else s2080-  s2083 :: SBool = s409 ^ s2082-  s2084 :: SBool = if s1734 then s2083 else s2082-  s2085 :: SBool = s385 ^ s2084-  s2086 :: SBool = if s1760 then s2085 else s2084-  s2087 :: SBool = s363 ^ s2086-  s2088 :: SBool = if s1788 then s2087 else s2086-  s2089 :: SBool = s343 ^ s2088-  s2090 :: SBool = if s1818 then s2089 else s2088-  s2091 :: SBool = s325 ^ s2090-  s2092 :: SBool = if s1850 then s2091 else s2090-  s2093 :: SBool = s309 ^ s2092-  s2094 :: SBool = if s1882 then s2093 else s2092-  s2095 :: SBool = s295 ^ s2094-  s2096 :: SBool = if s1914 then s2095 else s2094-  s2097 :: SBool = s283 ^ s2096-  s2098 :: SBool = if s1946 then s2097 else s2096-  s2099 :: SBool = s273 ^ s2098-  s2100 :: SBool = if s1978 then s2099 else s2098-  s2101 :: SBool = s265 ^ s2100-  s2102 :: SBool = if s2010 then s2101 else s2100-  s2103 :: SBool = s259 ^ s2102-  s2104 :: SBool = if s2042 then s2103 else s2102-  s2105 :: SBool = s255 ^ s2104-  s2106 :: SBool = if s2074 then s2105 else s2104-  s2107 :: SBool = s7 ^ s142-  s2108 :: SBool = if s1668 then s2107 else s142-  s2109 :: SBool = s493 ^ s2108-  s2110 :: SBool = if s1688 then s2109 else s2108-  s2111 :: SBool = s463 ^ s2110-  s2112 :: SBool = if s1710 then s2111 else s2110-  s2113 :: SBool = s435 ^ s2112-  s2114 :: SBool = if s1734 then s2113 else s2112-  s2115 :: SBool = s409 ^ s2114-  s2116 :: SBool = if s1760 then s2115 else s2114-  s2117 :: SBool = s385 ^ s2116-  s2118 :: SBool = if s1788 then s2117 else s2116-  s2119 :: SBool = s363 ^ s2118-  s2120 :: SBool = if s1818 then s2119 else s2118-  s2121 :: SBool = s343 ^ s2120-  s2122 :: SBool = if s1850 then s2121 else s2120-  s2123 :: SBool = s325 ^ s2122-  s2124 :: SBool = if s1882 then s2123 else s2122-  s2125 :: SBool = s309 ^ s2124-  s2126 :: SBool = if s1914 then s2125 else s2124-  s2127 :: SBool = s295 ^ s2126-  s2128 :: SBool = if s1946 then s2127 else s2126-  s2129 :: SBool = s283 ^ s2128-  s2130 :: SBool = if s1978 then s2129 else s2128-  s2131 :: SBool = s273 ^ s2130-  s2132 :: SBool = if s2010 then s2131 else s2130-  s2133 :: SBool = s265 ^ s2132-  s2134 :: SBool = if s2042 then s2133 else s2132-  s2135 :: SBool = s259 ^ s2134-  s2136 :: SBool = if s2074 then s2135 else s2134-  s2137 :: SBool = s255 ^ s2136-  s2138 :: SBool = if s2106 then s2137 else s2136-  s2139 :: SBool = s7 ^ s147-  s2140 :: SBool = if s1688 then s2139 else s147-  s2141 :: SBool = s493 ^ s2140-  s2142 :: SBool = if s1710 then s2141 else s2140-  s2143 :: SBool = s463 ^ s2142-  s2144 :: SBool = if s1734 then s2143 else s2142-  s2145 :: SBool = s435 ^ s2144-  s2146 :: SBool = if s1760 then s2145 else s2144-  s2147 :: SBool = s409 ^ s2146-  s2148 :: SBool = if s1788 then s2147 else s2146-  s2149 :: SBool = s385 ^ s2148-  s2150 :: SBool = if s1818 then s2149 else s2148-  s2151 :: SBool = s363 ^ s2150-  s2152 :: SBool = if s1850 then s2151 else s2150-  s2153 :: SBool = s343 ^ s2152-  s2154 :: SBool = if s1882 then s2153 else s2152-  s2155 :: SBool = s325 ^ s2154-  s2156 :: SBool = if s1914 then s2155 else s2154-  s2157 :: SBool = s309 ^ s2156-  s2158 :: SBool = if s1946 then s2157 else s2156-  s2159 :: SBool = s295 ^ s2158-  s2160 :: SBool = if s1978 then s2159 else s2158-  s2161 :: SBool = s283 ^ s2160-  s2162 :: SBool = if s2010 then s2161 else s2160-  s2163 :: SBool = s273 ^ s2162-  s2164 :: SBool = if s2042 then s2163 else s2162-  s2165 :: SBool = s265 ^ s2164-  s2166 :: SBool = if s2074 then s2165 else s2164-  s2167 :: SBool = s259 ^ s2166-  s2168 :: SBool = if s2106 then s2167 else s2166-  s2169 :: SBool = s255 ^ s2168-  s2170 :: SBool = if s2138 then s2169 else s2168-  s2171 :: SBool = s7 ^ s152-  s2172 :: SBool = if s1710 then s2171 else s152-  s2173 :: SBool = s493 ^ s2172-  s2174 :: SBool = if s1734 then s2173 else s2172-  s2175 :: SBool = s463 ^ s2174-  s2176 :: SBool = if s1760 then s2175 else s2174-  s2177 :: SBool = s435 ^ s2176-  s2178 :: SBool = if s1788 then s2177 else s2176-  s2179 :: SBool = s409 ^ s2178-  s2180 :: SBool = if s1818 then s2179 else s2178-  s2181 :: SBool = s385 ^ s2180-  s2182 :: SBool = if s1850 then s2181 else s2180-  s2183 :: SBool = s363 ^ s2182-  s2184 :: SBool = if s1882 then s2183 else s2182-  s2185 :: SBool = s343 ^ s2184-  s2186 :: SBool = if s1914 then s2185 else s2184-  s2187 :: SBool = s325 ^ s2186-  s2188 :: SBool = if s1946 then s2187 else s2186-  s2189 :: SBool = s309 ^ s2188-  s2190 :: SBool = if s1978 then s2189 else s2188-  s2191 :: SBool = s295 ^ s2190-  s2192 :: SBool = if s2010 then s2191 else s2190-  s2193 :: SBool = s283 ^ s2192-  s2194 :: SBool = if s2042 then s2193 else s2192-  s2195 :: SBool = s273 ^ s2194-  s2196 :: SBool = if s2074 then s2195 else s2194-  s2197 :: SBool = s265 ^ s2196-  s2198 :: SBool = if s2106 then s2197 else s2196-  s2199 :: SBool = s259 ^ s2198-  s2200 :: SBool = if s2138 then s2199 else s2198-  s2201 :: SBool = s255 ^ s2200-  s2202 :: SBool = if s2170 then s2201 else s2200-  s2203 :: SBool = s7 ^ s157-  s2204 :: SBool = if s1734 then s2203 else s157-  s2205 :: SBool = s493 ^ s2204-  s2206 :: SBool = if s1760 then s2205 else s2204-  s2207 :: SBool = s463 ^ s2206-  s2208 :: SBool = if s1788 then s2207 else s2206-  s2209 :: SBool = s435 ^ s2208-  s2210 :: SBool = if s1818 then s2209 else s2208-  s2211 :: SBool = s409 ^ s2210-  s2212 :: SBool = if s1850 then s2211 else s2210-  s2213 :: SBool = s385 ^ s2212-  s2214 :: SBool = if s1882 then s2213 else s2212-  s2215 :: SBool = s363 ^ s2214-  s2216 :: SBool = if s1914 then s2215 else s2214-  s2217 :: SBool = s343 ^ s2216-  s2218 :: SBool = if s1946 then s2217 else s2216-  s2219 :: SBool = s325 ^ s2218-  s2220 :: SBool = if s1978 then s2219 else s2218-  s2221 :: SBool = s309 ^ s2220-  s2222 :: SBool = if s2010 then s2221 else s2220-  s2223 :: SBool = s295 ^ s2222-  s2224 :: SBool = if s2042 then s2223 else s2222-  s2225 :: SBool = s283 ^ s2224-  s2226 :: SBool = if s2074 then s2225 else s2224-  s2227 :: SBool = s273 ^ s2226-  s2228 :: SBool = if s2106 then s2227 else s2226-  s2229 :: SBool = s265 ^ s2228-  s2230 :: SBool = if s2138 then s2229 else s2228-  s2231 :: SBool = s259 ^ s2230-  s2232 :: SBool = if s2170 then s2231 else s2230-  s2233 :: SBool = s255 ^ s2232-  s2234 :: SBool = if s2202 then s2233 else s2232-  s2235 :: SBool = s7 ^ s162-  s2236 :: SBool = if s1760 then s2235 else s162-  s2237 :: SBool = s493 ^ s2236-  s2238 :: SBool = if s1788 then s2237 else s2236-  s2239 :: SBool = s463 ^ s2238-  s2240 :: SBool = if s1818 then s2239 else s2238-  s2241 :: SBool = s435 ^ s2240-  s2242 :: SBool = if s1850 then s2241 else s2240-  s2243 :: SBool = s409 ^ s2242-  s2244 :: SBool = if s1882 then s2243 else s2242-  s2245 :: SBool = s385 ^ s2244-  s2246 :: SBool = if s1914 then s2245 else s2244-  s2247 :: SBool = s363 ^ s2246-  s2248 :: SBool = if s1946 then s2247 else s2246-  s2249 :: SBool = s343 ^ s2248-  s2250 :: SBool = if s1978 then s2249 else s2248-  s2251 :: SBool = s325 ^ s2250-  s2252 :: SBool = if s2010 then s2251 else s2250-  s2253 :: SBool = s309 ^ s2252-  s2254 :: SBool = if s2042 then s2253 else s2252-  s2255 :: SBool = s295 ^ s2254-  s2256 :: SBool = if s2074 then s2255 else s2254-  s2257 :: SBool = s283 ^ s2256-  s2258 :: SBool = if s2106 then s2257 else s2256-  s2259 :: SBool = s273 ^ s2258-  s2260 :: SBool = if s2138 then s2259 else s2258-  s2261 :: SBool = s265 ^ s2260-  s2262 :: SBool = if s2170 then s2261 else s2260-  s2263 :: SBool = s259 ^ s2262-  s2264 :: SBool = if s2202 then s2263 else s2262-  s2265 :: SBool = s255 ^ s2264-  s2266 :: SBool = if s2234 then s2265 else s2264-  s2267 :: SBool = s7 ^ s167-  s2268 :: SBool = if s1788 then s2267 else s167-  s2269 :: SBool = s493 ^ s2268-  s2270 :: SBool = if s1818 then s2269 else s2268-  s2271 :: SBool = s463 ^ s2270-  s2272 :: SBool = if s1850 then s2271 else s2270-  s2273 :: SBool = s435 ^ s2272-  s2274 :: SBool = if s1882 then s2273 else s2272-  s2275 :: SBool = s409 ^ s2274-  s2276 :: SBool = if s1914 then s2275 else s2274-  s2277 :: SBool = s385 ^ s2276-  s2278 :: SBool = if s1946 then s2277 else s2276-  s2279 :: SBool = s363 ^ s2278-  s2280 :: SBool = if s1978 then s2279 else s2278-  s2281 :: SBool = s343 ^ s2280-  s2282 :: SBool = if s2010 then s2281 else s2280-  s2283 :: SBool = s325 ^ s2282-  s2284 :: SBool = if s2042 then s2283 else s2282-  s2285 :: SBool = s309 ^ s2284-  s2286 :: SBool = if s2074 then s2285 else s2284-  s2287 :: SBool = s295 ^ s2286-  s2288 :: SBool = if s2106 then s2287 else s2286-  s2289 :: SBool = s283 ^ s2288-  s2290 :: SBool = if s2138 then s2289 else s2288-  s2291 :: SBool = s273 ^ s2290-  s2292 :: SBool = if s2170 then s2291 else s2290-  s2293 :: SBool = s265 ^ s2292-  s2294 :: SBool = if s2202 then s2293 else s2292-  s2295 :: SBool = s259 ^ s2294-  s2296 :: SBool = if s2234 then s2295 else s2294-  s2297 :: SBool = s255 ^ s2296-  s2298 :: SBool = if s2266 then s2297 else s2296-  s2299 :: SBool = s7 ^ s172-  s2300 :: SBool = if s1818 then s2299 else s172-  s2301 :: SBool = s493 ^ s2300-  s2302 :: SBool = if s1850 then s2301 else s2300-  s2303 :: SBool = s463 ^ s2302-  s2304 :: SBool = if s1882 then s2303 else s2302-  s2305 :: SBool = s435 ^ s2304-  s2306 :: SBool = if s1914 then s2305 else s2304-  s2307 :: SBool = s409 ^ s2306-  s2308 :: SBool = if s1946 then s2307 else s2306-  s2309 :: SBool = s385 ^ s2308-  s2310 :: SBool = if s1978 then s2309 else s2308-  s2311 :: SBool = s363 ^ s2310-  s2312 :: SBool = if s2010 then s2311 else s2310-  s2313 :: SBool = s343 ^ s2312-  s2314 :: SBool = if s2042 then s2313 else s2312-  s2315 :: SBool = s325 ^ s2314-  s2316 :: SBool = if s2074 then s2315 else s2314-  s2317 :: SBool = s309 ^ s2316-  s2318 :: SBool = if s2106 then s2317 else s2316-  s2319 :: SBool = s295 ^ s2318-  s2320 :: SBool = if s2138 then s2319 else s2318-  s2321 :: SBool = s283 ^ s2320-  s2322 :: SBool = if s2170 then s2321 else s2320-  s2323 :: SBool = s273 ^ s2322-  s2324 :: SBool = if s2202 then s2323 else s2322-  s2325 :: SBool = s265 ^ s2324-  s2326 :: SBool = if s2234 then s2325 else s2324-  s2327 :: SBool = s259 ^ s2326-  s2328 :: SBool = if s2266 then s2327 else s2326-  s2329 :: SBool = s255 ^ s2328-  s2330 :: SBool = if s2298 then s2329 else s2328-  s2331 :: SBool = s7 ^ s177-  s2332 :: SBool = if s1850 then s2331 else s177-  s2333 :: SBool = s493 ^ s2332-  s2334 :: SBool = if s1882 then s2333 else s2332-  s2335 :: SBool = s463 ^ s2334-  s2336 :: SBool = if s1914 then s2335 else s2334-  s2337 :: SBool = s435 ^ s2336-  s2338 :: SBool = if s1946 then s2337 else s2336-  s2339 :: SBool = s409 ^ s2338-  s2340 :: SBool = if s1978 then s2339 else s2338-  s2341 :: SBool = s385 ^ s2340-  s2342 :: SBool = if s2010 then s2341 else s2340-  s2343 :: SBool = s363 ^ s2342-  s2344 :: SBool = if s2042 then s2343 else s2342-  s2345 :: SBool = s343 ^ s2344-  s2346 :: SBool = if s2074 then s2345 else s2344-  s2347 :: SBool = s325 ^ s2346-  s2348 :: SBool = if s2106 then s2347 else s2346-  s2349 :: SBool = s309 ^ s2348-  s2350 :: SBool = if s2138 then s2349 else s2348-  s2351 :: SBool = s295 ^ s2350-  s2352 :: SBool = if s2170 then s2351 else s2350-  s2353 :: SBool = s283 ^ s2352-  s2354 :: SBool = if s2202 then s2353 else s2352-  s2355 :: SBool = s273 ^ s2354-  s2356 :: SBool = if s2234 then s2355 else s2354-  s2357 :: SBool = s265 ^ s2356-  s2358 :: SBool = if s2266 then s2357 else s2356-  s2359 :: SBool = s259 ^ s2358-  s2360 :: SBool = if s2298 then s2359 else s2358-  s2361 :: SBool = s255 ^ s2360-  s2362 :: SBool = if s2330 then s2361 else s2360-  s2363 :: SBool = s7 ^ s182-  s2364 :: SBool = if s1882 then s2363 else s182-  s2365 :: SBool = s493 ^ s2364-  s2366 :: SBool = if s1914 then s2365 else s2364-  s2367 :: SBool = s463 ^ s2366-  s2368 :: SBool = if s1946 then s2367 else s2366-  s2369 :: SBool = s435 ^ s2368-  s2370 :: SBool = if s1978 then s2369 else s2368-  s2371 :: SBool = s409 ^ s2370-  s2372 :: SBool = if s2010 then s2371 else s2370-  s2373 :: SBool = s385 ^ s2372-  s2374 :: SBool = if s2042 then s2373 else s2372-  s2375 :: SBool = s363 ^ s2374-  s2376 :: SBool = if s2074 then s2375 else s2374-  s2377 :: SBool = s343 ^ s2376-  s2378 :: SBool = if s2106 then s2377 else s2376-  s2379 :: SBool = s325 ^ s2378-  s2380 :: SBool = if s2138 then s2379 else s2378-  s2381 :: SBool = s309 ^ s2380-  s2382 :: SBool = if s2170 then s2381 else s2380-  s2383 :: SBool = s295 ^ s2382-  s2384 :: SBool = if s2202 then s2383 else s2382-  s2385 :: SBool = s283 ^ s2384-  s2386 :: SBool = if s2234 then s2385 else s2384-  s2387 :: SBool = s273 ^ s2386-  s2388 :: SBool = if s2266 then s2387 else s2386-  s2389 :: SBool = s265 ^ s2388-  s2390 :: SBool = if s2298 then s2389 else s2388-  s2391 :: SBool = s259 ^ s2390-  s2392 :: SBool = if s2330 then s2391 else s2390-  s2393 :: SBool = s255 ^ s2392-  s2394 :: SBool = if s2362 then s2393 else s2392-  s2395 :: SBool = s7 ^ s187-  s2396 :: SBool = if s1914 then s2395 else s187-  s2397 :: SBool = s493 ^ s2396-  s2398 :: SBool = if s1946 then s2397 else s2396-  s2399 :: SBool = s463 ^ s2398-  s2400 :: SBool = if s1978 then s2399 else s2398-  s2401 :: SBool = s435 ^ s2400-  s2402 :: SBool = if s2010 then s2401 else s2400-  s2403 :: SBool = s409 ^ s2402-  s2404 :: SBool = if s2042 then s2403 else s2402-  s2405 :: SBool = s385 ^ s2404-  s2406 :: SBool = if s2074 then s2405 else s2404-  s2407 :: SBool = s363 ^ s2406-  s2408 :: SBool = if s2106 then s2407 else s2406-  s2409 :: SBool = s343 ^ s2408-  s2410 :: SBool = if s2138 then s2409 else s2408-  s2411 :: SBool = s325 ^ s2410-  s2412 :: SBool = if s2170 then s2411 else s2410-  s2413 :: SBool = s309 ^ s2412-  s2414 :: SBool = if s2202 then s2413 else s2412-  s2415 :: SBool = s295 ^ s2414-  s2416 :: SBool = if s2234 then s2415 else s2414-  s2417 :: SBool = s283 ^ s2416-  s2418 :: SBool = if s2266 then s2417 else s2416-  s2419 :: SBool = s273 ^ s2418-  s2420 :: SBool = if s2298 then s2419 else s2418-  s2421 :: SBool = s265 ^ s2420-  s2422 :: SBool = if s2330 then s2421 else s2420-  s2423 :: SBool = s259 ^ s2422-  s2424 :: SBool = if s2362 then s2423 else s2422-  s2425 :: SBool = s255 ^ s2424-  s2426 :: SBool = if s2394 then s2425 else s2424-  s2427 :: SBool = s7 ^ s192-  s2428 :: SBool = if s1946 then s2427 else s192-  s2429 :: SBool = s493 ^ s2428-  s2430 :: SBool = if s1978 then s2429 else s2428-  s2431 :: SBool = s463 ^ s2430-  s2432 :: SBool = if s2010 then s2431 else s2430-  s2433 :: SBool = s435 ^ s2432-  s2434 :: SBool = if s2042 then s2433 else s2432-  s2435 :: SBool = s409 ^ s2434-  s2436 :: SBool = if s2074 then s2435 else s2434-  s2437 :: SBool = s385 ^ s2436-  s2438 :: SBool = if s2106 then s2437 else s2436-  s2439 :: SBool = s363 ^ s2438-  s2440 :: SBool = if s2138 then s2439 else s2438-  s2441 :: SBool = s343 ^ s2440-  s2442 :: SBool = if s2170 then s2441 else s2440-  s2443 :: SBool = s325 ^ s2442-  s2444 :: SBool = if s2202 then s2443 else s2442-  s2445 :: SBool = s309 ^ s2444-  s2446 :: SBool = if s2234 then s2445 else s2444-  s2447 :: SBool = s295 ^ s2446-  s2448 :: SBool = if s2266 then s2447 else s2446-  s2449 :: SBool = s283 ^ s2448-  s2450 :: SBool = if s2298 then s2449 else s2448-  s2451 :: SBool = s273 ^ s2450-  s2452 :: SBool = if s2330 then s2451 else s2450-  s2453 :: SBool = s265 ^ s2452-  s2454 :: SBool = if s2362 then s2453 else s2452-  s2455 :: SBool = s259 ^ s2454-  s2456 :: SBool = if s2394 then s2455 else s2454-  s2457 :: SBool = s255 ^ s2456-  s2458 :: SBool = if s2426 then s2457 else s2456-  s2459 :: SBool = s7 ^ s197-  s2460 :: SBool = if s1978 then s2459 else s197-  s2461 :: SBool = s493 ^ s2460-  s2462 :: SBool = if s2010 then s2461 else s2460-  s2463 :: SBool = s463 ^ s2462-  s2464 :: SBool = if s2042 then s2463 else s2462-  s2465 :: SBool = s435 ^ s2464-  s2466 :: SBool = if s2074 then s2465 else s2464-  s2467 :: SBool = s409 ^ s2466-  s2468 :: SBool = if s2106 then s2467 else s2466-  s2469 :: SBool = s385 ^ s2468-  s2470 :: SBool = if s2138 then s2469 else s2468-  s2471 :: SBool = s363 ^ s2470-  s2472 :: SBool = if s2170 then s2471 else s2470-  s2473 :: SBool = s343 ^ s2472-  s2474 :: SBool = if s2202 then s2473 else s2472-  s2475 :: SBool = s325 ^ s2474-  s2476 :: SBool = if s2234 then s2475 else s2474-  s2477 :: SBool = s309 ^ s2476-  s2478 :: SBool = if s2266 then s2477 else s2476-  s2479 :: SBool = s295 ^ s2478-  s2480 :: SBool = if s2298 then s2479 else s2478-  s2481 :: SBool = s283 ^ s2480-  s2482 :: SBool = if s2330 then s2481 else s2480-  s2483 :: SBool = s273 ^ s2482-  s2484 :: SBool = if s2362 then s2483 else s2482-  s2485 :: SBool = s265 ^ s2484-  s2486 :: SBool = if s2394 then s2485 else s2484-  s2487 :: SBool = s259 ^ s2486-  s2488 :: SBool = if s2426 then s2487 else s2486-  s2489 :: SBool = s255 ^ s2488-  s2490 :: SBool = if s2458 then s2489 else s2488-  s2491 :: SBool = s7 ^ s202-  s2492 :: SBool = if s2010 then s2491 else s202-  s2493 :: SBool = s493 ^ s2492-  s2494 :: SBool = if s2042 then s2493 else s2492-  s2495 :: SBool = s463 ^ s2494-  s2496 :: SBool = if s2074 then s2495 else s2494-  s2497 :: SBool = s435 ^ s2496-  s2498 :: SBool = if s2106 then s2497 else s2496-  s2499 :: SBool = s409 ^ s2498-  s2500 :: SBool = if s2138 then s2499 else s2498-  s2501 :: SBool = s385 ^ s2500-  s2502 :: SBool = if s2170 then s2501 else s2500-  s2503 :: SBool = s363 ^ s2502-  s2504 :: SBool = if s2202 then s2503 else s2502-  s2505 :: SBool = s343 ^ s2504-  s2506 :: SBool = if s2234 then s2505 else s2504-  s2507 :: SBool = s325 ^ s2506-  s2508 :: SBool = if s2266 then s2507 else s2506-  s2509 :: SBool = s309 ^ s2508-  s2510 :: SBool = if s2298 then s2509 else s2508-  s2511 :: SBool = s295 ^ s2510-  s2512 :: SBool = if s2330 then s2511 else s2510-  s2513 :: SBool = s283 ^ s2512-  s2514 :: SBool = if s2362 then s2513 else s2512-  s2515 :: SBool = s273 ^ s2514-  s2516 :: SBool = if s2394 then s2515 else s2514-  s2517 :: SBool = s265 ^ s2516-  s2518 :: SBool = if s2426 then s2517 else s2516-  s2519 :: SBool = s259 ^ s2518-  s2520 :: SBool = if s2458 then s2519 else s2518-  s2521 :: SBool = s255 ^ s2520-  s2522 :: SBool = if s2490 then s2521 else s2520-  s2523 :: SBool = s7 ^ s207-  s2524 :: SBool = if s2042 then s2523 else s207-  s2525 :: SBool = s493 ^ s2524-  s2526 :: SBool = if s2074 then s2525 else s2524-  s2527 :: SBool = s463 ^ s2526-  s2528 :: SBool = if s2106 then s2527 else s2526-  s2529 :: SBool = s435 ^ s2528-  s2530 :: SBool = if s2138 then s2529 else s2528-  s2531 :: SBool = s409 ^ s2530-  s2532 :: SBool = if s2170 then s2531 else s2530-  s2533 :: SBool = s385 ^ s2532-  s2534 :: SBool = if s2202 then s2533 else s2532-  s2535 :: SBool = s363 ^ s2534-  s2536 :: SBool = if s2234 then s2535 else s2534-  s2537 :: SBool = s343 ^ s2536-  s2538 :: SBool = if s2266 then s2537 else s2536-  s2539 :: SBool = s325 ^ s2538-  s2540 :: SBool = if s2298 then s2539 else s2538-  s2541 :: SBool = s309 ^ s2540-  s2542 :: SBool = if s2330 then s2541 else s2540-  s2543 :: SBool = s295 ^ s2542-  s2544 :: SBool = if s2362 then s2543 else s2542-  s2545 :: SBool = s283 ^ s2544-  s2546 :: SBool = if s2394 then s2545 else s2544-  s2547 :: SBool = s273 ^ s2546-  s2548 :: SBool = if s2426 then s2547 else s2546-  s2549 :: SBool = s265 ^ s2548-  s2550 :: SBool = if s2458 then s2549 else s2548-  s2551 :: SBool = s259 ^ s2550-  s2552 :: SBool = if s2490 then s2551 else s2550-  s2553 :: SBool = s255 ^ s2552-  s2554 :: SBool = if s2522 then s2553 else s2552-  s2555 :: SBool = s7 ^ s212-  s2556 :: SBool = if s2074 then s2555 else s212-  s2557 :: SBool = s493 ^ s2556-  s2558 :: SBool = if s2106 then s2557 else s2556-  s2559 :: SBool = s463 ^ s2558-  s2560 :: SBool = if s2138 then s2559 else s2558-  s2561 :: SBool = s435 ^ s2560-  s2562 :: SBool = if s2170 then s2561 else s2560-  s2563 :: SBool = s409 ^ s2562-  s2564 :: SBool = if s2202 then s2563 else s2562-  s2565 :: SBool = s385 ^ s2564-  s2566 :: SBool = if s2234 then s2565 else s2564-  s2567 :: SBool = s363 ^ s2566-  s2568 :: SBool = if s2266 then s2567 else s2566-  s2569 :: SBool = s343 ^ s2568-  s2570 :: SBool = if s2298 then s2569 else s2568-  s2571 :: SBool = s325 ^ s2570-  s2572 :: SBool = if s2330 then s2571 else s2570-  s2573 :: SBool = s309 ^ s2572-  s2574 :: SBool = if s2362 then s2573 else s2572-  s2575 :: SBool = s295 ^ s2574-  s2576 :: SBool = if s2394 then s2575 else s2574-  s2577 :: SBool = s283 ^ s2576-  s2578 :: SBool = if s2426 then s2577 else s2576-  s2579 :: SBool = s273 ^ s2578-  s2580 :: SBool = if s2458 then s2579 else s2578-  s2581 :: SBool = s265 ^ s2580-  s2582 :: SBool = if s2490 then s2581 else s2580-  s2583 :: SBool = s259 ^ s2582-  s2584 :: SBool = if s2522 then s2583 else s2582-  s2585 :: SBool = s255 ^ s2584-  s2586 :: SBool = if s2554 then s2585 else s2584-  s2587 :: SBool = s7 ^ s217-  s2588 :: SBool = if s2106 then s2587 else s217-  s2589 :: SBool = s493 ^ s2588-  s2590 :: SBool = if s2138 then s2589 else s2588-  s2591 :: SBool = s463 ^ s2590-  s2592 :: SBool = if s2170 then s2591 else s2590-  s2593 :: SBool = s435 ^ s2592-  s2594 :: SBool = if s2202 then s2593 else s2592-  s2595 :: SBool = s409 ^ s2594-  s2596 :: SBool = if s2234 then s2595 else s2594-  s2597 :: SBool = s385 ^ s2596-  s2598 :: SBool = if s2266 then s2597 else s2596-  s2599 :: SBool = s363 ^ s2598-  s2600 :: SBool = if s2298 then s2599 else s2598-  s2601 :: SBool = s343 ^ s2600-  s2602 :: SBool = if s2330 then s2601 else s2600-  s2603 :: SBool = s325 ^ s2602-  s2604 :: SBool = if s2362 then s2603 else s2602-  s2605 :: SBool = s309 ^ s2604-  s2606 :: SBool = if s2394 then s2605 else s2604-  s2607 :: SBool = s295 ^ s2606-  s2608 :: SBool = if s2426 then s2607 else s2606-  s2609 :: SBool = s283 ^ s2608-  s2610 :: SBool = if s2458 then s2609 else s2608-  s2611 :: SBool = s273 ^ s2610-  s2612 :: SBool = if s2490 then s2611 else s2610-  s2613 :: SBool = s265 ^ s2612-  s2614 :: SBool = if s2522 then s2613 else s2612-  s2615 :: SBool = s259 ^ s2614-  s2616 :: SBool = if s2554 then s2615 else s2614-  s2617 :: SBool = s255 ^ s2616-  s2618 :: SBool = if s2586 then s2617 else s2616-  s2619 :: SBool = s7 ^ s222-  s2620 :: SBool = if s2138 then s2619 else s222-  s2621 :: SBool = s493 ^ s2620-  s2622 :: SBool = if s2170 then s2621 else s2620-  s2623 :: SBool = s463 ^ s2622-  s2624 :: SBool = if s2202 then s2623 else s2622-  s2625 :: SBool = s435 ^ s2624-  s2626 :: SBool = if s2234 then s2625 else s2624-  s2627 :: SBool = s409 ^ s2626-  s2628 :: SBool = if s2266 then s2627 else s2626-  s2629 :: SBool = s385 ^ s2628-  s2630 :: SBool = if s2298 then s2629 else s2628-  s2631 :: SBool = s363 ^ s2630-  s2632 :: SBool = if s2330 then s2631 else s2630-  s2633 :: SBool = s343 ^ s2632-  s2634 :: SBool = if s2362 then s2633 else s2632-  s2635 :: SBool = s325 ^ s2634-  s2636 :: SBool = if s2394 then s2635 else s2634-  s2637 :: SBool = s309 ^ s2636-  s2638 :: SBool = if s2426 then s2637 else s2636-  s2639 :: SBool = s295 ^ s2638-  s2640 :: SBool = if s2458 then s2639 else s2638-  s2641 :: SBool = s283 ^ s2640-  s2642 :: SBool = if s2490 then s2641 else s2640-  s2643 :: SBool = s273 ^ s2642-  s2644 :: SBool = if s2522 then s2643 else s2642-  s2645 :: SBool = s265 ^ s2644-  s2646 :: SBool = if s2554 then s2645 else s2644-  s2647 :: SBool = s259 ^ s2646-  s2648 :: SBool = if s2586 then s2647 else s2646-  s2649 :: SBool = s255 ^ s2648-  s2650 :: SBool = if s2618 then s2649 else s2648-  s2651 :: SBool = s7 ^ s227-  s2652 :: SBool = if s2170 then s2651 else s227-  s2653 :: SBool = s493 ^ s2652-  s2654 :: SBool = if s2202 then s2653 else s2652-  s2655 :: SBool = s463 ^ s2654-  s2656 :: SBool = if s2234 then s2655 else s2654-  s2657 :: SBool = s435 ^ s2656-  s2658 :: SBool = if s2266 then s2657 else s2656-  s2659 :: SBool = s409 ^ s2658-  s2660 :: SBool = if s2298 then s2659 else s2658-  s2661 :: SBool = s385 ^ s2660-  s2662 :: SBool = if s2330 then s2661 else s2660-  s2663 :: SBool = s363 ^ s2662-  s2664 :: SBool = if s2362 then s2663 else s2662-  s2665 :: SBool = s343 ^ s2664-  s2666 :: SBool = if s2394 then s2665 else s2664-  s2667 :: SBool = s325 ^ s2666-  s2668 :: SBool = if s2426 then s2667 else s2666-  s2669 :: SBool = s309 ^ s2668-  s2670 :: SBool = if s2458 then s2669 else s2668-  s2671 :: SBool = s295 ^ s2670-  s2672 :: SBool = if s2490 then s2671 else s2670-  s2673 :: SBool = s283 ^ s2672-  s2674 :: SBool = if s2522 then s2673 else s2672-  s2675 :: SBool = s273 ^ s2674-  s2676 :: SBool = if s2554 then s2675 else s2674-  s2677 :: SBool = s265 ^ s2676-  s2678 :: SBool = if s2586 then s2677 else s2676-  s2679 :: SBool = s259 ^ s2678-  s2680 :: SBool = if s2618 then s2679 else s2678-  s2681 :: SBool = s255 ^ s2680-  s2682 :: SBool = if s2650 then s2681 else s2680-  s2683 :: SBool = s7 ^ s232-  s2684 :: SBool = if s2202 then s2683 else s232-  s2685 :: SBool = s493 ^ s2684-  s2686 :: SBool = if s2234 then s2685 else s2684-  s2687 :: SBool = s463 ^ s2686-  s2688 :: SBool = if s2266 then s2687 else s2686-  s2689 :: SBool = s435 ^ s2688-  s2690 :: SBool = if s2298 then s2689 else s2688-  s2691 :: SBool = s409 ^ s2690-  s2692 :: SBool = if s2330 then s2691 else s2690-  s2693 :: SBool = s385 ^ s2692-  s2694 :: SBool = if s2362 then s2693 else s2692-  s2695 :: SBool = s363 ^ s2694-  s2696 :: SBool = if s2394 then s2695 else s2694-  s2697 :: SBool = s343 ^ s2696-  s2698 :: SBool = if s2426 then s2697 else s2696-  s2699 :: SBool = s325 ^ s2698-  s2700 :: SBool = if s2458 then s2699 else s2698-  s2701 :: SBool = s309 ^ s2700-  s2702 :: SBool = if s2490 then s2701 else s2700-  s2703 :: SBool = s295 ^ s2702-  s2704 :: SBool = if s2522 then s2703 else s2702-  s2705 :: SBool = s283 ^ s2704-  s2706 :: SBool = if s2554 then s2705 else s2704-  s2707 :: SBool = s273 ^ s2706-  s2708 :: SBool = if s2586 then s2707 else s2706-  s2709 :: SBool = s265 ^ s2708-  s2710 :: SBool = if s2618 then s2709 else s2708-  s2711 :: SBool = s259 ^ s2710-  s2712 :: SBool = if s2650 then s2711 else s2710-  s2713 :: SBool = s255 ^ s2712-  s2714 :: SBool = if s2682 then s2713 else s2712-  s2715 :: SBool = s7 ^ s237-  s2716 :: SBool = if s2234 then s2715 else s237-  s2717 :: SBool = s493 ^ s2716-  s2718 :: SBool = if s2266 then s2717 else s2716-  s2719 :: SBool = s463 ^ s2718-  s2720 :: SBool = if s2298 then s2719 else s2718-  s2721 :: SBool = s435 ^ s2720-  s2722 :: SBool = if s2330 then s2721 else s2720-  s2723 :: SBool = s409 ^ s2722-  s2724 :: SBool = if s2362 then s2723 else s2722-  s2725 :: SBool = s385 ^ s2724-  s2726 :: SBool = if s2394 then s2725 else s2724-  s2727 :: SBool = s363 ^ s2726-  s2728 :: SBool = if s2426 then s2727 else s2726-  s2729 :: SBool = s343 ^ s2728-  s2730 :: SBool = if s2458 then s2729 else s2728-  s2731 :: SBool = s325 ^ s2730-  s2732 :: SBool = if s2490 then s2731 else s2730-  s2733 :: SBool = s309 ^ s2732-  s2734 :: SBool = if s2522 then s2733 else s2732-  s2735 :: SBool = s295 ^ s2734-  s2736 :: SBool = if s2554 then s2735 else s2734-  s2737 :: SBool = s283 ^ s2736-  s2738 :: SBool = if s2586 then s2737 else s2736-  s2739 :: SBool = s273 ^ s2738-  s2740 :: SBool = if s2618 then s2739 else s2738-  s2741 :: SBool = s265 ^ s2740-  s2742 :: SBool = if s2650 then s2741 else s2740-  s2743 :: SBool = s259 ^ s2742-  s2744 :: SBool = if s2682 then s2743 else s2742-  s2745 :: SBool = s255 ^ s2744-  s2746 :: SBool = if s2714 then s2745 else s2744-  s2747 :: SBool = s7 ^ s242-  s2748 :: SBool = if s2266 then s2747 else s242-  s2749 :: SBool = s493 ^ s2748-  s2750 :: SBool = if s2298 then s2749 else s2748-  s2751 :: SBool = s463 ^ s2750-  s2752 :: SBool = if s2330 then s2751 else s2750-  s2753 :: SBool = s435 ^ s2752-  s2754 :: SBool = if s2362 then s2753 else s2752-  s2755 :: SBool = s409 ^ s2754-  s2756 :: SBool = if s2394 then s2755 else s2754-  s2757 :: SBool = s385 ^ s2756-  s2758 :: SBool = if s2426 then s2757 else s2756-  s2759 :: SBool = s363 ^ s2758-  s2760 :: SBool = if s2458 then s2759 else s2758-  s2761 :: SBool = s343 ^ s2760-  s2762 :: SBool = if s2490 then s2761 else s2760-  s2763 :: SBool = s325 ^ s2762-  s2764 :: SBool = if s2522 then s2763 else s2762-  s2765 :: SBool = s309 ^ s2764-  s2766 :: SBool = if s2554 then s2765 else s2764-  s2767 :: SBool = s295 ^ s2766-  s2768 :: SBool = if s2586 then s2767 else s2766-  s2769 :: SBool = s283 ^ s2768-  s2770 :: SBool = if s2618 then s2769 else s2768-  s2771 :: SBool = s273 ^ s2770-  s2772 :: SBool = if s2650 then s2771 else s2770-  s2773 :: SBool = s265 ^ s2772-  s2774 :: SBool = if s2682 then s2773 else s2772-  s2775 :: SBool = s259 ^ s2774-  s2776 :: SBool = if s2714 then s2775 else s2774-  s2777 :: SBool = s255 ^ s2776-  s2778 :: SBool = if s2746 then s2777 else s2776-  s2779 :: SBool = s7 ^ s247-  s2780 :: SBool = if s2298 then s2779 else s247-  s2781 :: SBool = s493 ^ s2780-  s2782 :: SBool = if s2330 then s2781 else s2780-  s2783 :: SBool = s463 ^ s2782-  s2784 :: SBool = if s2362 then s2783 else s2782-  s2785 :: SBool = s435 ^ s2784-  s2786 :: SBool = if s2394 then s2785 else s2784-  s2787 :: SBool = s409 ^ s2786-  s2788 :: SBool = if s2426 then s2787 else s2786-  s2789 :: SBool = s385 ^ s2788-  s2790 :: SBool = if s2458 then s2789 else s2788-  s2791 :: SBool = s363 ^ s2790-  s2792 :: SBool = if s2490 then s2791 else s2790-  s2793 :: SBool = s343 ^ s2792-  s2794 :: SBool = if s2522 then s2793 else s2792-  s2795 :: SBool = s325 ^ s2794-  s2796 :: SBool = if s2554 then s2795 else s2794-  s2797 :: SBool = s309 ^ s2796-  s2798 :: SBool = if s2586 then s2797 else s2796-  s2799 :: SBool = s295 ^ s2798-  s2800 :: SBool = if s2618 then s2799 else s2798-  s2801 :: SBool = s283 ^ s2800-  s2802 :: SBool = if s2650 then s2801 else s2800-  s2803 :: SBool = s273 ^ s2802-  s2804 :: SBool = if s2682 then s2803 else s2802-  s2805 :: SBool = s265 ^ s2804-  s2806 :: SBool = if s2714 then s2805 else s2804-  s2807 :: SBool = s259 ^ s2806-  s2808 :: SBool = if s2746 then s2807 else s2806-  s2809 :: SBool = s255 ^ s2808-  s2810 :: SBool = if s2778 then s2809 else s2808-  s2811 :: SBool = s7 ^ s252-  s2812 :: SBool = if s2330 then s2811 else s252-  s2813 :: SBool = s493 ^ s2812-  s2814 :: SBool = if s2362 then s2813 else s2812-  s2815 :: SBool = s463 ^ s2814-  s2816 :: SBool = if s2394 then s2815 else s2814-  s2817 :: SBool = s435 ^ s2816-  s2818 :: SBool = if s2426 then s2817 else s2816-  s2819 :: SBool = s409 ^ s2818-  s2820 :: SBool = if s2458 then s2819 else s2818-  s2821 :: SBool = s385 ^ s2820-  s2822 :: SBool = if s2490 then s2821 else s2820-  s2823 :: SBool = s363 ^ s2822-  s2824 :: SBool = if s2522 then s2823 else s2822-  s2825 :: SBool = s343 ^ s2824-  s2826 :: SBool = if s2554 then s2825 else s2824-  s2827 :: SBool = s325 ^ s2826-  s2828 :: SBool = if s2586 then s2827 else s2826-  s2829 :: SBool = s309 ^ s2828-  s2830 :: SBool = if s2618 then s2829 else s2828-  s2831 :: SBool = s295 ^ s2830-  s2832 :: SBool = if s2650 then s2831 else s2830-  s2833 :: SBool = s283 ^ s2832-  s2834 :: SBool = if s2682 then s2833 else s2832-  s2835 :: SBool = s273 ^ s2834-  s2836 :: SBool = if s2714 then s2835 else s2834-  s2837 :: SBool = s265 ^ s2836-  s2838 :: SBool = if s2746 then s2837 else s2836-  s2839 :: SBool = s259 ^ s2838-  s2840 :: SBool = if s2778 then s2839 else s2838-  s2841 :: SBool = s255 ^ s2840-  s2842 :: SBool = if s2810 then s2841 else s2840-  s2843 :: SBool = if s2362 then s7 else s_2-  s2844 :: SBool = s493 ^ s2843-  s2845 :: SBool = if s2394 then s2844 else s2843-  s2846 :: SBool = s463 ^ s2845-  s2847 :: SBool = if s2426 then s2846 else s2845-  s2848 :: SBool = s435 ^ s2847-  s2849 :: SBool = if s2458 then s2848 else s2847-  s2850 :: SBool = s409 ^ s2849-  s2851 :: SBool = if s2490 then s2850 else s2849-  s2852 :: SBool = s385 ^ s2851-  s2853 :: SBool = if s2522 then s2852 else s2851-  s2854 :: SBool = s363 ^ s2853-  s2855 :: SBool = if s2554 then s2854 else s2853-  s2856 :: SBool = s343 ^ s2855-  s2857 :: SBool = if s2586 then s2856 else s2855-  s2858 :: SBool = s325 ^ s2857-  s2859 :: SBool = if s2618 then s2858 else s2857-  s2860 :: SBool = s309 ^ s2859-  s2861 :: SBool = if s2650 then s2860 else s2859-  s2862 :: SBool = s295 ^ s2861-  s2863 :: SBool = if s2682 then s2862 else s2861-  s2864 :: SBool = s283 ^ s2863-  s2865 :: SBool = if s2714 then s2864 else s2863-  s2866 :: SBool = s273 ^ s2865-  s2867 :: SBool = if s2746 then s2866 else s2865-  s2868 :: SBool = s265 ^ s2867-  s2869 :: SBool = if s2778 then s2868 else s2867-  s2870 :: SBool = s259 ^ s2869-  s2871 :: SBool = if s2810 then s2870 else s2869-  s2872 :: SBool = s255 ^ s2871-  s2873 :: SBool = if s2842 then s2872 else s2871-  s2874 :: SBool = s1578 ^ s2873-  s2875 :: SBool = if s1099 then s7 else s_2-  s2876 :: SBool = s493 ^ s2875-  s2877 :: SBool = if s1131 then s2876 else s2875-  s2878 :: SBool = s463 ^ s2877-  s2879 :: SBool = if s1163 then s2878 else s2877-  s2880 :: SBool = s435 ^ s2879-  s2881 :: SBool = if s1195 then s2880 else s2879-  s2882 :: SBool = s409 ^ s2881-  s2883 :: SBool = if s1227 then s2882 else s2881-  s2884 :: SBool = s385 ^ s2883-  s2885 :: SBool = if s1259 then s2884 else s2883-  s2886 :: SBool = s363 ^ s2885-  s2887 :: SBool = if s1291 then s2886 else s2885-  s2888 :: SBool = s343 ^ s2887-  s2889 :: SBool = if s1323 then s2888 else s2887-  s2890 :: SBool = s325 ^ s2889-  s2891 :: SBool = if s1355 then s2890 else s2889-  s2892 :: SBool = s309 ^ s2891-  s2893 :: SBool = if s1387 then s2892 else s2891-  s2894 :: SBool = s295 ^ s2893-  s2895 :: SBool = if s1419 then s2894 else s2893-  s2896 :: SBool = s283 ^ s2895-  s2897 :: SBool = if s1451 then s2896 else s2895-  s2898 :: SBool = s273 ^ s2897-  s2899 :: SBool = if s1483 then s2898 else s2897-  s2900 :: SBool = s265 ^ s2899-  s2901 :: SBool = if s1515 then s2900 else s2899-  s2902 :: SBool = s259 ^ s2901-  s2903 :: SBool = if s1547 then s2902 else s2901-  s2904 :: SBool = if s2394 then s7 else s_2-  s2905 :: SBool = s493 ^ s2904-  s2906 :: SBool = if s2426 then s2905 else s2904-  s2907 :: SBool = s463 ^ s2906-  s2908 :: SBool = if s2458 then s2907 else s2906-  s2909 :: SBool = s435 ^ s2908-  s2910 :: SBool = if s2490 then s2909 else s2908-  s2911 :: SBool = s409 ^ s2910-  s2912 :: SBool = if s2522 then s2911 else s2910-  s2913 :: SBool = s385 ^ s2912-  s2914 :: SBool = if s2554 then s2913 else s2912-  s2915 :: SBool = s363 ^ s2914-  s2916 :: SBool = if s2586 then s2915 else s2914-  s2917 :: SBool = s343 ^ s2916-  s2918 :: SBool = if s2618 then s2917 else s2916-  s2919 :: SBool = s325 ^ s2918-  s2920 :: SBool = if s2650 then s2919 else s2918-  s2921 :: SBool = s309 ^ s2920-  s2922 :: SBool = if s2682 then s2921 else s2920-  s2923 :: SBool = s295 ^ s2922-  s2924 :: SBool = if s2714 then s2923 else s2922-  s2925 :: SBool = s283 ^ s2924-  s2926 :: SBool = if s2746 then s2925 else s2924-  s2927 :: SBool = s273 ^ s2926-  s2928 :: SBool = if s2778 then s2927 else s2926-  s2929 :: SBool = s265 ^ s2928-  s2930 :: SBool = if s2810 then s2929 else s2928-  s2931 :: SBool = s259 ^ s2930-  s2932 :: SBool = if s2842 then s2931 else s2930-  s2933 :: SBool = s2903 ^ s2932-  s2934 :: SBool = if s1131 then s7 else s_2-  s2935 :: SBool = s493 ^ s2934-  s2936 :: SBool = if s1163 then s2935 else s2934-  s2937 :: SBool = s463 ^ s2936-  s2938 :: SBool = if s1195 then s2937 else s2936-  s2939 :: SBool = s435 ^ s2938-  s2940 :: SBool = if s1227 then s2939 else s2938-  s2941 :: SBool = s409 ^ s2940-  s2942 :: SBool = if s1259 then s2941 else s2940-  s2943 :: SBool = s385 ^ s2942-  s2944 :: SBool = if s1291 then s2943 else s2942-  s2945 :: SBool = s363 ^ s2944-  s2946 :: SBool = if s1323 then s2945 else s2944-  s2947 :: SBool = s343 ^ s2946-  s2948 :: SBool = if s1355 then s2947 else s2946-  s2949 :: SBool = s325 ^ s2948-  s2950 :: SBool = if s1387 then s2949 else s2948-  s2951 :: SBool = s309 ^ s2950-  s2952 :: SBool = if s1419 then s2951 else s2950-  s2953 :: SBool = s295 ^ s2952-  s2954 :: SBool = if s1451 then s2953 else s2952-  s2955 :: SBool = s283 ^ s2954-  s2956 :: SBool = if s1483 then s2955 else s2954-  s2957 :: SBool = s273 ^ s2956-  s2958 :: SBool = if s1515 then s2957 else s2956-  s2959 :: SBool = s265 ^ s2958-  s2960 :: SBool = if s1547 then s2959 else s2958-  s2961 :: SBool = if s2426 then s7 else s_2-  s2962 :: SBool = s493 ^ s2961-  s2963 :: SBool = if s2458 then s2962 else s2961-  s2964 :: SBool = s463 ^ s2963-  s2965 :: SBool = if s2490 then s2964 else s2963-  s2966 :: SBool = s435 ^ s2965-  s2967 :: SBool = if s2522 then s2966 else s2965-  s2968 :: SBool = s409 ^ s2967-  s2969 :: SBool = if s2554 then s2968 else s2967-  s2970 :: SBool = s385 ^ s2969-  s2971 :: SBool = if s2586 then s2970 else s2969-  s2972 :: SBool = s363 ^ s2971-  s2973 :: SBool = if s2618 then s2972 else s2971-  s2974 :: SBool = s343 ^ s2973-  s2975 :: SBool = if s2650 then s2974 else s2973-  s2976 :: SBool = s325 ^ s2975-  s2977 :: SBool = if s2682 then s2976 else s2975-  s2978 :: SBool = s309 ^ s2977-  s2979 :: SBool = if s2714 then s2978 else s2977-  s2980 :: SBool = s295 ^ s2979-  s2981 :: SBool = if s2746 then s2980 else s2979-  s2982 :: SBool = s283 ^ s2981-  s2983 :: SBool = if s2778 then s2982 else s2981-  s2984 :: SBool = s273 ^ s2983-  s2985 :: SBool = if s2810 then s2984 else s2983-  s2986 :: SBool = s265 ^ s2985-  s2987 :: SBool = if s2842 then s2986 else s2985-  s2988 :: SBool = s2960 ^ s2987-  s2989 :: SBool = if s1163 then s7 else s_2-  s2990 :: SBool = s493 ^ s2989-  s2991 :: SBool = if s1195 then s2990 else s2989-  s2992 :: SBool = s463 ^ s2991-  s2993 :: SBool = if s1227 then s2992 else s2991-  s2994 :: SBool = s435 ^ s2993-  s2995 :: SBool = if s1259 then s2994 else s2993-  s2996 :: SBool = s409 ^ s2995-  s2997 :: SBool = if s1291 then s2996 else s2995-  s2998 :: SBool = s385 ^ s2997-  s2999 :: SBool = if s1323 then s2998 else s2997-  s3000 :: SBool = s363 ^ s2999-  s3001 :: SBool = if s1355 then s3000 else s2999-  s3002 :: SBool = s343 ^ s3001-  s3003 :: SBool = if s1387 then s3002 else s3001-  s3004 :: SBool = s325 ^ s3003-  s3005 :: SBool = if s1419 then s3004 else s3003-  s3006 :: SBool = s309 ^ s3005-  s3007 :: SBool = if s1451 then s3006 else s3005-  s3008 :: SBool = s295 ^ s3007-  s3009 :: SBool = if s1483 then s3008 else s3007-  s3010 :: SBool = s283 ^ s3009-  s3011 :: SBool = if s1515 then s3010 else s3009-  s3012 :: SBool = s273 ^ s3011-  s3013 :: SBool = if s1547 then s3012 else s3011-  s3014 :: SBool = if s2458 then s7 else s_2-  s3015 :: SBool = s493 ^ s3014-  s3016 :: SBool = if s2490 then s3015 else s3014-  s3017 :: SBool = s463 ^ s3016-  s3018 :: SBool = if s2522 then s3017 else s3016-  s3019 :: SBool = s435 ^ s3018-  s3020 :: SBool = if s2554 then s3019 else s3018-  s3021 :: SBool = s409 ^ s3020-  s3022 :: SBool = if s2586 then s3021 else s3020-  s3023 :: SBool = s385 ^ s3022-  s3024 :: SBool = if s2618 then s3023 else s3022-  s3025 :: SBool = s363 ^ s3024-  s3026 :: SBool = if s2650 then s3025 else s3024-  s3027 :: SBool = s343 ^ s3026-  s3028 :: SBool = if s2682 then s3027 else s3026-  s3029 :: SBool = s325 ^ s3028-  s3030 :: SBool = if s2714 then s3029 else s3028-  s3031 :: SBool = s309 ^ s3030-  s3032 :: SBool = if s2746 then s3031 else s3030-  s3033 :: SBool = s295 ^ s3032-  s3034 :: SBool = if s2778 then s3033 else s3032-  s3035 :: SBool = s283 ^ s3034-  s3036 :: SBool = if s2810 then s3035 else s3034-  s3037 :: SBool = s273 ^ s3036-  s3038 :: SBool = if s2842 then s3037 else s3036-  s3039 :: SBool = s3013 ^ s3038-  s3040 :: SBool = if s1195 then s7 else s_2-  s3041 :: SBool = s493 ^ s3040-  s3042 :: SBool = if s1227 then s3041 else s3040-  s3043 :: SBool = s463 ^ s3042-  s3044 :: SBool = if s1259 then s3043 else s3042-  s3045 :: SBool = s435 ^ s3044-  s3046 :: SBool = if s1291 then s3045 else s3044-  s3047 :: SBool = s409 ^ s3046-  s3048 :: SBool = if s1323 then s3047 else s3046-  s3049 :: SBool = s385 ^ s3048-  s3050 :: SBool = if s1355 then s3049 else s3048-  s3051 :: SBool = s363 ^ s3050-  s3052 :: SBool = if s1387 then s3051 else s3050-  s3053 :: SBool = s343 ^ s3052-  s3054 :: SBool = if s1419 then s3053 else s3052-  s3055 :: SBool = s325 ^ s3054-  s3056 :: SBool = if s1451 then s3055 else s3054-  s3057 :: SBool = s309 ^ s3056-  s3058 :: SBool = if s1483 then s3057 else s3056-  s3059 :: SBool = s295 ^ s3058-  s3060 :: SBool = if s1515 then s3059 else s3058-  s3061 :: SBool = s283 ^ s3060-  s3062 :: SBool = if s1547 then s3061 else s3060-  s3063 :: SBool = if s2490 then s7 else s_2-  s3064 :: SBool = s493 ^ s3063-  s3065 :: SBool = if s2522 then s3064 else s3063-  s3066 :: SBool = s463 ^ s3065-  s3067 :: SBool = if s2554 then s3066 else s3065-  s3068 :: SBool = s435 ^ s3067-  s3069 :: SBool = if s2586 then s3068 else s3067-  s3070 :: SBool = s409 ^ s3069-  s3071 :: SBool = if s2618 then s3070 else s3069-  s3072 :: SBool = s385 ^ s3071-  s3073 :: SBool = if s2650 then s3072 else s3071-  s3074 :: SBool = s363 ^ s3073-  s3075 :: SBool = if s2682 then s3074 else s3073-  s3076 :: SBool = s343 ^ s3075-  s3077 :: SBool = if s2714 then s3076 else s3075-  s3078 :: SBool = s325 ^ s3077-  s3079 :: SBool = if s2746 then s3078 else s3077-  s3080 :: SBool = s309 ^ s3079-  s3081 :: SBool = if s2778 then s3080 else s3079-  s3082 :: SBool = s295 ^ s3081-  s3083 :: SBool = if s2810 then s3082 else s3081-  s3084 :: SBool = s283 ^ s3083-  s3085 :: SBool = if s2842 then s3084 else s3083-  s3086 :: SBool = s3062 ^ s3085-  s3087 :: SBool = if s1227 then s7 else s_2-  s3088 :: SBool = s493 ^ s3087-  s3089 :: SBool = if s1259 then s3088 else s3087-  s3090 :: SBool = s463 ^ s3089-  s3091 :: SBool = if s1291 then s3090 else s3089-  s3092 :: SBool = s435 ^ s3091-  s3093 :: SBool = if s1323 then s3092 else s3091-  s3094 :: SBool = s409 ^ s3093-  s3095 :: SBool = if s1355 then s3094 else s3093-  s3096 :: SBool = s385 ^ s3095-  s3097 :: SBool = if s1387 then s3096 else s3095-  s3098 :: SBool = s363 ^ s3097-  s3099 :: SBool = if s1419 then s3098 else s3097-  s3100 :: SBool = s343 ^ s3099-  s3101 :: SBool = if s1451 then s3100 else s3099-  s3102 :: SBool = s325 ^ s3101-  s3103 :: SBool = if s1483 then s3102 else s3101-  s3104 :: SBool = s309 ^ s3103-  s3105 :: SBool = if s1515 then s3104 else s3103-  s3106 :: SBool = s295 ^ s3105-  s3107 :: SBool = if s1547 then s3106 else s3105-  s3108 :: SBool = if s2522 then s7 else s_2-  s3109 :: SBool = s493 ^ s3108-  s3110 :: SBool = if s2554 then s3109 else s3108-  s3111 :: SBool = s463 ^ s3110-  s3112 :: SBool = if s2586 then s3111 else s3110-  s3113 :: SBool = s435 ^ s3112-  s3114 :: SBool = if s2618 then s3113 else s3112-  s3115 :: SBool = s409 ^ s3114-  s3116 :: SBool = if s2650 then s3115 else s3114-  s3117 :: SBool = s385 ^ s3116-  s3118 :: SBool = if s2682 then s3117 else s3116-  s3119 :: SBool = s363 ^ s3118-  s3120 :: SBool = if s2714 then s3119 else s3118-  s3121 :: SBool = s343 ^ s3120-  s3122 :: SBool = if s2746 then s3121 else s3120-  s3123 :: SBool = s325 ^ s3122-  s3124 :: SBool = if s2778 then s3123 else s3122-  s3125 :: SBool = s309 ^ s3124-  s3126 :: SBool = if s2810 then s3125 else s3124-  s3127 :: SBool = s295 ^ s3126-  s3128 :: SBool = if s2842 then s3127 else s3126-  s3129 :: SBool = s3107 ^ s3128-  s3130 :: SBool = if s1259 then s7 else s_2-  s3131 :: SBool = s493 ^ s3130-  s3132 :: SBool = if s1291 then s3131 else s3130-  s3133 :: SBool = s463 ^ s3132-  s3134 :: SBool = if s1323 then s3133 else s3132-  s3135 :: SBool = s435 ^ s3134-  s3136 :: SBool = if s1355 then s3135 else s3134-  s3137 :: SBool = s409 ^ s3136-  s3138 :: SBool = if s1387 then s3137 else s3136-  s3139 :: SBool = s385 ^ s3138-  s3140 :: SBool = if s1419 then s3139 else s3138-  s3141 :: SBool = s363 ^ s3140-  s3142 :: SBool = if s1451 then s3141 else s3140-  s3143 :: SBool = s343 ^ s3142-  s3144 :: SBool = if s1483 then s3143 else s3142-  s3145 :: SBool = s325 ^ s3144-  s3146 :: SBool = if s1515 then s3145 else s3144-  s3147 :: SBool = s309 ^ s3146-  s3148 :: SBool = if s1547 then s3147 else s3146-  s3149 :: SBool = if s2554 then s7 else s_2-  s3150 :: SBool = s493 ^ s3149-  s3151 :: SBool = if s2586 then s3150 else s3149-  s3152 :: SBool = s463 ^ s3151-  s3153 :: SBool = if s2618 then s3152 else s3151-  s3154 :: SBool = s435 ^ s3153-  s3155 :: SBool = if s2650 then s3154 else s3153-  s3156 :: SBool = s409 ^ s3155-  s3157 :: SBool = if s2682 then s3156 else s3155-  s3158 :: SBool = s385 ^ s3157-  s3159 :: SBool = if s2714 then s3158 else s3157-  s3160 :: SBool = s363 ^ s3159-  s3161 :: SBool = if s2746 then s3160 else s3159-  s3162 :: SBool = s343 ^ s3161-  s3163 :: SBool = if s2778 then s3162 else s3161-  s3164 :: SBool = s325 ^ s3163-  s3165 :: SBool = if s2810 then s3164 else s3163-  s3166 :: SBool = s309 ^ s3165-  s3167 :: SBool = if s2842 then s3166 else s3165-  s3168 :: SBool = s3148 ^ s3167-  s3169 :: SBool = if s1291 then s7 else s_2-  s3170 :: SBool = s493 ^ s3169-  s3171 :: SBool = if s1323 then s3170 else s3169-  s3172 :: SBool = s463 ^ s3171-  s3173 :: SBool = if s1355 then s3172 else s3171-  s3174 :: SBool = s435 ^ s3173-  s3175 :: SBool = if s1387 then s3174 else s3173-  s3176 :: SBool = s409 ^ s3175-  s3177 :: SBool = if s1419 then s3176 else s3175-  s3178 :: SBool = s385 ^ s3177-  s3179 :: SBool = if s1451 then s3178 else s3177-  s3180 :: SBool = s363 ^ s3179-  s3181 :: SBool = if s1483 then s3180 else s3179-  s3182 :: SBool = s343 ^ s3181-  s3183 :: SBool = if s1515 then s3182 else s3181-  s3184 :: SBool = s325 ^ s3183-  s3185 :: SBool = if s1547 then s3184 else s3183-  s3186 :: SBool = if s2586 then s7 else s_2-  s3187 :: SBool = s493 ^ s3186-  s3188 :: SBool = if s2618 then s3187 else s3186-  s3189 :: SBool = s463 ^ s3188-  s3190 :: SBool = if s2650 then s3189 else s3188-  s3191 :: SBool = s435 ^ s3190-  s3192 :: SBool = if s2682 then s3191 else s3190-  s3193 :: SBool = s409 ^ s3192-  s3194 :: SBool = if s2714 then s3193 else s3192-  s3195 :: SBool = s385 ^ s3194-  s3196 :: SBool = if s2746 then s3195 else s3194-  s3197 :: SBool = s363 ^ s3196-  s3198 :: SBool = if s2778 then s3197 else s3196-  s3199 :: SBool = s343 ^ s3198-  s3200 :: SBool = if s2810 then s3199 else s3198-  s3201 :: SBool = s325 ^ s3200-  s3202 :: SBool = if s2842 then s3201 else s3200-  s3203 :: SBool = s3185 ^ s3202-  s3204 :: SBool = if s1323 then s7 else s_2-  s3205 :: SBool = s493 ^ s3204-  s3206 :: SBool = if s1355 then s3205 else s3204-  s3207 :: SBool = s463 ^ s3206-  s3208 :: SBool = if s1387 then s3207 else s3206-  s3209 :: SBool = s435 ^ s3208-  s3210 :: SBool = if s1419 then s3209 else s3208-  s3211 :: SBool = s409 ^ s3210-  s3212 :: SBool = if s1451 then s3211 else s3210-  s3213 :: SBool = s385 ^ s3212-  s3214 :: SBool = if s1483 then s3213 else s3212-  s3215 :: SBool = s363 ^ s3214-  s3216 :: SBool = if s1515 then s3215 else s3214-  s3217 :: SBool = s343 ^ s3216-  s3218 :: SBool = if s1547 then s3217 else s3216-  s3219 :: SBool = if s2618 then s7 else s_2-  s3220 :: SBool = s493 ^ s3219-  s3221 :: SBool = if s2650 then s3220 else s3219-  s3222 :: SBool = s463 ^ s3221-  s3223 :: SBool = if s2682 then s3222 else s3221-  s3224 :: SBool = s435 ^ s3223-  s3225 :: SBool = if s2714 then s3224 else s3223-  s3226 :: SBool = s409 ^ s3225-  s3227 :: SBool = if s2746 then s3226 else s3225-  s3228 :: SBool = s385 ^ s3227-  s3229 :: SBool = if s2778 then s3228 else s3227-  s3230 :: SBool = s363 ^ s3229-  s3231 :: SBool = if s2810 then s3230 else s3229-  s3232 :: SBool = s343 ^ s3231-  s3233 :: SBool = if s2842 then s3232 else s3231-  s3234 :: SBool = s3218 ^ s3233-  s3235 :: SBool = if s1355 then s7 else s_2-  s3236 :: SBool = s493 ^ s3235-  s3237 :: SBool = if s1387 then s3236 else s3235-  s3238 :: SBool = s463 ^ s3237-  s3239 :: SBool = if s1419 then s3238 else s3237-  s3240 :: SBool = s435 ^ s3239-  s3241 :: SBool = if s1451 then s3240 else s3239-  s3242 :: SBool = s409 ^ s3241-  s3243 :: SBool = if s1483 then s3242 else s3241-  s3244 :: SBool = s385 ^ s3243-  s3245 :: SBool = if s1515 then s3244 else s3243-  s3246 :: SBool = s363 ^ s3245-  s3247 :: SBool = if s1547 then s3246 else s3245-  s3248 :: SBool = if s2650 then s7 else s_2-  s3249 :: SBool = s493 ^ s3248-  s3250 :: SBool = if s2682 then s3249 else s3248-  s3251 :: SBool = s463 ^ s3250-  s3252 :: SBool = if s2714 then s3251 else s3250-  s3253 :: SBool = s435 ^ s3252-  s3254 :: SBool = if s2746 then s3253 else s3252-  s3255 :: SBool = s409 ^ s3254-  s3256 :: SBool = if s2778 then s3255 else s3254-  s3257 :: SBool = s385 ^ s3256-  s3258 :: SBool = if s2810 then s3257 else s3256-  s3259 :: SBool = s363 ^ s3258-  s3260 :: SBool = if s2842 then s3259 else s3258-  s3261 :: SBool = s3247 ^ s3260-  s3262 :: SBool = if s1387 then s7 else s_2-  s3263 :: SBool = s493 ^ s3262-  s3264 :: SBool = if s1419 then s3263 else s3262-  s3265 :: SBool = s463 ^ s3264-  s3266 :: SBool = if s1451 then s3265 else s3264-  s3267 :: SBool = s435 ^ s3266-  s3268 :: SBool = if s1483 then s3267 else s3266-  s3269 :: SBool = s409 ^ s3268-  s3270 :: SBool = if s1515 then s3269 else s3268-  s3271 :: SBool = s385 ^ s3270-  s3272 :: SBool = if s1547 then s3271 else s3270-  s3273 :: SBool = if s2682 then s7 else s_2-  s3274 :: SBool = s493 ^ s3273-  s3275 :: SBool = if s2714 then s3274 else s3273-  s3276 :: SBool = s463 ^ s3275-  s3277 :: SBool = if s2746 then s3276 else s3275-  s3278 :: SBool = s435 ^ s3277-  s3279 :: SBool = if s2778 then s3278 else s3277-  s3280 :: SBool = s409 ^ s3279-  s3281 :: SBool = if s2810 then s3280 else s3279-  s3282 :: SBool = s385 ^ s3281-  s3283 :: SBool = if s2842 then s3282 else s3281-  s3284 :: SBool = s3272 ^ s3283-  s3285 :: SBool = if s1419 then s7 else s_2-  s3286 :: SBool = s493 ^ s3285-  s3287 :: SBool = if s1451 then s3286 else s3285-  s3288 :: SBool = s463 ^ s3287-  s3289 :: SBool = if s1483 then s3288 else s3287-  s3290 :: SBool = s435 ^ s3289-  s3291 :: SBool = if s1515 then s3290 else s3289-  s3292 :: SBool = s409 ^ s3291-  s3293 :: SBool = if s1547 then s3292 else s3291-  s3294 :: SBool = if s2714 then s7 else s_2-  s3295 :: SBool = s493 ^ s3294-  s3296 :: SBool = if s2746 then s3295 else s3294-  s3297 :: SBool = s463 ^ s3296-  s3298 :: SBool = if s2778 then s3297 else s3296-  s3299 :: SBool = s435 ^ s3298-  s3300 :: SBool = if s2810 then s3299 else s3298-  s3301 :: SBool = s409 ^ s3300-  s3302 :: SBool = if s2842 then s3301 else s3300-  s3303 :: SBool = s3293 ^ s3302-  s3304 :: SBool = if s1451 then s7 else s_2-  s3305 :: SBool = s493 ^ s3304-  s3306 :: SBool = if s1483 then s3305 else s3304-  s3307 :: SBool = s463 ^ s3306-  s3308 :: SBool = if s1515 then s3307 else s3306-  s3309 :: SBool = s435 ^ s3308-  s3310 :: SBool = if s1547 then s3309 else s3308-  s3311 :: SBool = if s2746 then s7 else s_2-  s3312 :: SBool = s493 ^ s3311-  s3313 :: SBool = if s2778 then s3312 else s3311-  s3314 :: SBool = s463 ^ s3313-  s3315 :: SBool = if s2810 then s3314 else s3313-  s3316 :: SBool = s435 ^ s3315-  s3317 :: SBool = if s2842 then s3316 else s3315-  s3318 :: SBool = s3310 ^ s3317-  s3319 :: SBool = if s1483 then s7 else s_2-  s3320 :: SBool = s493 ^ s3319-  s3321 :: SBool = if s1515 then s3320 else s3319-  s3322 :: SBool = s463 ^ s3321-  s3323 :: SBool = if s1547 then s3322 else s3321-  s3324 :: SBool = if s2778 then s7 else s_2-  s3325 :: SBool = s493 ^ s3324-  s3326 :: SBool = if s2810 then s3325 else s3324-  s3327 :: SBool = s463 ^ s3326-  s3328 :: SBool = if s2842 then s3327 else s3326-  s3329 :: SBool = s3323 ^ s3328-  s3330 :: SBool = if s1515 then s7 else s_2-  s3331 :: SBool = s493 ^ s3330-  s3332 :: SBool = if s1547 then s3331 else s3330-  s3333 :: SBool = if s2810 then s7 else s_2-  s3334 :: SBool = s493 ^ s3333-  s3335 :: SBool = if s2842 then s3334 else s3333-  s3336 :: SBool = s3332 ^ s3335-  s3337 :: SBool = if s1547 then s7 else s_2-  s3338 :: SBool = if s2842 then s7 else s_2-  s3339 :: SBool = s3337 ^ s3338-  s3341 :: SWord8 = if s3339 then s18 else s3340-  s3342 :: SWord8 = s18 + s3341-  s3343 :: SWord8 = if s3336 then s3342 else s3341-  s3344 :: SWord8 = s18 + s3343-  s3345 :: SWord8 = if s3329 then s3344 else s3343-  s3346 :: SWord8 = s18 + s3345-  s3347 :: SWord8 = if s3318 then s3346 else s3345-  s3348 :: SWord8 = s18 + s3347-  s3349 :: SWord8 = if s3303 then s3348 else s3347-  s3350 :: SWord8 = s18 + s3349-  s3351 :: SWord8 = if s3284 then s3350 else s3349-  s3352 :: SWord8 = s18 + s3351-  s3353 :: SWord8 = if s3261 then s3352 else s3351-  s3354 :: SWord8 = s18 + s3353-  s3355 :: SWord8 = if s3234 then s3354 else s3353-  s3356 :: SWord8 = s18 + s3355-  s3357 :: SWord8 = if s3203 then s3356 else s3355-  s3358 :: SWord8 = s18 + s3357-  s3359 :: SWord8 = if s3168 then s3358 else s3357-  s3360 :: SWord8 = s18 + s3359-  s3361 :: SWord8 = if s3129 then s3360 else s3359-  s3362 :: SWord8 = s18 + s3361-  s3363 :: SWord8 = if s3086 then s3362 else s3361-  s3364 :: SWord8 = s18 + s3363-  s3365 :: SWord8 = if s3039 then s3364 else s3363-  s3366 :: SWord8 = s18 + s3365-  s3367 :: SWord8 = if s2988 then s3366 else s3365-  s3368 :: SWord8 = s18 + s3367-  s3369 :: SWord8 = if s2933 then s3368 else s3367-  s3370 :: SWord8 = s18 + s3369-  s3371 :: SWord8 = if s2874 then s3370 else s3369-  s3372 :: SWord8 = s18 + s3371-  s3373 :: SWord8 = if s253 then s3372 else s3371-  s3374 :: SWord8 = s18 + s3373-  s3375 :: SWord8 = if s248 then s3374 else s3373-  s3376 :: SWord8 = s18 + s3375-  s3377 :: SWord8 = if s243 then s3376 else s3375-  s3378 :: SWord8 = s18 + s3377-  s3379 :: SWord8 = if s238 then s3378 else s3377-  s3380 :: SWord8 = s18 + s3379-  s3381 :: SWord8 = if s233 then s3380 else s3379-  s3382 :: SWord8 = s18 + s3381-  s3383 :: SWord8 = if s228 then s3382 else s3381-  s3384 :: SWord8 = s18 + s3383-  s3385 :: SWord8 = if s223 then s3384 else s3383-  s3386 :: SWord8 = s18 + s3385-  s3387 :: SWord8 = if s218 then s3386 else s3385-  s3388 :: SWord8 = s18 + s3387-  s3389 :: SWord8 = if s213 then s3388 else s3387-  s3390 :: SWord8 = s18 + s3389-  s3391 :: SWord8 = if s208 then s3390 else s3389-  s3392 :: SWord8 = s18 + s3391-  s3393 :: SWord8 = if s203 then s3392 else s3391-  s3394 :: SWord8 = s18 + s3393-  s3395 :: SWord8 = if s198 then s3394 else s3393-  s3396 :: SWord8 = s18 + s3395-  s3397 :: SWord8 = if s193 then s3396 else s3395-  s3398 :: SWord8 = s18 + s3397-  s3399 :: SWord8 = if s188 then s3398 else s3397-  s3400 :: SWord8 = s18 + s3399-  s3401 :: SWord8 = if s183 then s3400 else s3399-  s3402 :: SWord8 = s18 + s3401-  s3403 :: SWord8 = if s178 then s3402 else s3401-  s3404 :: SWord8 = s18 + s3403-  s3405 :: SWord8 = if s173 then s3404 else s3403-  s3406 :: SWord8 = s18 + s3405-  s3407 :: SWord8 = if s168 then s3406 else s3405-  s3408 :: SWord8 = s18 + s3407-  s3409 :: SWord8 = if s163 then s3408 else s3407-  s3410 :: SWord8 = s18 + s3409-  s3411 :: SWord8 = if s158 then s3410 else s3409-  s3412 :: SWord8 = s18 + s3411-  s3413 :: SWord8 = if s153 then s3412 else s3411-  s3414 :: SWord8 = s18 + s3413-  s3415 :: SWord8 = if s148 then s3414 else s3413-  s3416 :: SWord8 = s18 + s3415-  s3417 :: SWord8 = if s143 then s3416 else s3415-  s3418 :: SWord8 = s18 + s3417-  s3419 :: SWord8 = if s138 then s3418 else s3417-  s3420 :: SWord8 = s18 + s3419-  s3421 :: SWord8 = if s133 then s3420 else s3419-  s3422 :: SWord8 = s18 + s3421-  s3423 :: SWord8 = if s128 then s3422 else s3421-  s3424 :: SWord8 = s18 + s3423-  s3425 :: SWord8 = if s123 then s3424 else s3423-  s3426 :: SWord8 = s18 + s3425-  s3427 :: SWord8 = if s118 then s3426 else s3425-  s3428 :: SWord8 = s18 + s3427-  s3429 :: SWord8 = if s113 then s3428 else s3427-  s3430 :: SWord8 = s18 + s3429-  s3431 :: SWord8 = if s108 then s3430 else s3429-  s3432 :: SWord8 = s18 + s3431-  s3433 :: SWord8 = if s103 then s3432 else s3431-  s3434 :: SWord8 = s18 + s3433-  s3435 :: SWord8 = if s98 then s3434 else s3433-  s3436 :: SWord8 = s18 + s3435-  s3437 :: SWord8 = if s93 then s3436 else s3435-  s3438 :: SWord8 = s18 + s3437-  s3439 :: SWord8 = if s88 then s3438 else s3437-  s3440 :: SWord8 = s18 + s3439-  s3441 :: SWord8 = if s83 then s3440 else s3439-  s3442 :: SWord8 = s18 + s3441-  s3443 :: SWord8 = if s78 then s3442 else s3441-  s3444 :: SWord8 = s18 + s3443-  s3445 :: SWord8 = if s73 then s3444 else s3443-  s3446 :: SWord8 = s18 + s3445-  s3447 :: SWord8 = if s68 then s3446 else s3445-  s3448 :: SWord8 = s18 + s3447-  s3449 :: SWord8 = if s63 then s3448 else s3447-  s3450 :: SWord8 = s18 + s3449-  s3451 :: SWord8 = if s58 then s3450 else s3449-  s3452 :: SWord8 = s18 + s3451-  s3453 :: SWord8 = if s53 then s3452 else s3451-  s3454 :: SWord8 = s18 + s3453-  s3455 :: SWord8 = if s48 then s3454 else s3453-  s3456 :: SWord8 = s18 + s3455-  s3457 :: SWord8 = if s43 then s3456 else s3455-  s3458 :: SWord8 = s18 + s3457-  s3459 :: SWord8 = if s38 then s3458 else s3457-  s3460 :: SWord8 = s18 + s3459-  s3461 :: SWord8 = if s33 then s3460 else s3459-  s3462 :: SWord8 = s18 + s3461-  s3463 :: SWord8 = if s28 then s3462 else s3461-  s3464 :: SWord8 = s18 + s3463-  s3465 :: SWord8 = if s23 then s3464 else s3463-  s3466 :: SWord8 = s18 + s3465-  s3467 :: SWord8 = if s17 then s3466 else s3465-  s3469 :: SBool = s3467 >= s3468-  s3470 :: SBool = s12 | s3469-  s3471 :: SBool = s7 & s3470-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s3471
− SBVUnitTest/GoldFiles/crcUSB5_1.gold 
@@ -1,181 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for crcUSB5. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: crcUSB5_driver--crcUSB5.o: crcUSB5.c crcUSB5.h-	${CC} ${CCFLAGS} -c $< -o $@--crcUSB5_driver.o: crcUSB5_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--crcUSB5_driver: crcUSB5.o crcUSB5_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f crcUSB5_driver-== END: "Makefile" ==================-== BEGIN: "crcUSB5.h" ================-/* Header file for crcUSB5. Automatically generated by SBV. Do not edit! */--#ifndef __crcUSB5__HEADER_INCLUDED__-#define __crcUSB5__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-SWord16 crcUSB5(const SWord16 msg);--#endif /* __crcUSB5__HEADER_INCLUDED__ */-== END: "crcUSB5.h" ==================-== BEGIN: "crcUSB5_driver.c" ================-/* Example driver program for crcUSB5. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "crcUSB5.h"--int main(void)-{-  const SWord16 __result = crcUSB5(0xfedcU);--  printf("crcUSB5(0xfedcU) = 0x%04"PRIx16"U\n", __result);--  return 0;-}-== END: "crcUSB5_driver.c" ==================-== BEGIN: "crcUSB5.c" ================-/* File: "crcUSB5.c". Automatically generated by SBV. Do not edit! */--#include "crcUSB5.h"--SWord16 crcUSB5(const SWord16 msg)-{-  const SWord16 s0 = msg;-  const SBool   s1 = (SBool) ((s0 >> 10) & 1);-  const SBool   s3 = s1 != false;-  const SBool   s4 = (SBool) ((s0 >> 9) & 1);-  const SBool   s5 = false != s4;-  const SBool   s6 = (SBool) ((s0 >> 8) & 1);-  const SBool   s7 = false != s6;-  const SBool   s8 = (SBool) ((s0 >> 7) & 1);-  const SBool   s9 = false != s8;-  const SBool   s10 = (SBool) ((s0 >> 6) & 1);-  const SBool   s11 = false != s10;-  const SBool   s12 = (SBool) ((s0 >> 5) & 1);-  const SBool   s13 = false != s12;-  const SBool   s14 = (SBool) ((s0 >> 4) & 1);-  const SBool   s15 = false != s14;-  const SBool   s16 = (SBool) ((s0 >> 3) & 1);-  const SBool   s17 = false != s16;-  const SBool   s18 = (SBool) ((s0 >> 2) & 1);-  const SBool   s19 = false != s18;-  const SBool   s20 = (SBool) ((s0 >> 1) & 1);-  const SBool   s21 = false != s20;-  const SBool   s22 = (SBool) ((s0 >> 0) & 1);-  const SBool   s23 = false != s22;-  const SBool   s24 = !s9;-  const SBool   s25 = s3 ? s24 : s9;-  const SBool   s26 = !s11;-  const SBool   s27 = s5 ? s26 : s11;-  const SBool   s28 = !s13;-  const SBool   s29 = s3 ? s28 : s13;-  const SBool   s30 = !s29;-  const SBool   s31 = s7 ? s30 : s29;-  const SBool   s32 = !s15;-  const SBool   s33 = s5 ? s32 : s15;-  const SBool   s34 = !s33;-  const SBool   s35 = s25 ? s34 : s33;-  const SBool   s36 = !s17;-  const SBool   s37 = s7 ? s36 : s17;-  const SBool   s38 = !s37;-  const SBool   s39 = s27 ? s38 : s37;-  const SBool   s40 = !s19;-  const SBool   s41 = s25 ? s40 : s19;-  const SBool   s42 = !s41;-  const SBool   s43 = s31 ? s42 : s41;-  const SBool   s44 = !s21;-  const SBool   s45 = s27 ? s44 : s21;-  const SBool   s46 = !s45;-  const SBool   s47 = s35 ? s46 : s45;-  const SBool   s48 = !s23;-  const SBool   s49 = s31 ? s48 : s23;-  const SBool   s50 = !s49;-  const SBool   s51 = s39 ? s50 : s49;-  const SBool   s52 = !s35;-  const SBool   s53 = s43 ? s52 : s35;-  const SBool   s54 = !s39;-  const SBool   s55 = s47 ? s54 : s39;-  const SBool   s56 = !s43;-  const SBool   s57 = s51 ? s56 : s43;-  const SWord16 s60 = s51 ? 0x0001U : 0x0000U;-  const SWord16 s62 = s60 | 0x0002U;-  const SWord16 s63 = s47 ? s62 : s60;-  const SWord16 s65 = s63 | 0x0004U;-  const SWord16 s66 = s57 ? s65 : s63;-  const SWord16 s68 = s66 | 0x0008U;-  const SWord16 s69 = s55 ? s68 : s66;-  const SWord16 s71 = s69 | 0x0010U;-  const SWord16 s72 = s53 ? s71 : s69;-  const SWord16 s74 = s72 | 0x0020U;-  const SWord16 s75 = s23 ? s74 : s72;-  const SWord16 s77 = s75 | 0x0040U;-  const SWord16 s78 = s21 ? s77 : s75;-  const SWord16 s80 = s78 | 0x0080U;-  const SWord16 s81 = s19 ? s80 : s78;-  const SWord16 s83 = s81 | 0x0100U;-  const SWord16 s84 = s17 ? s83 : s81;-  const SWord16 s86 = s84 | 0x0200U;-  const SWord16 s87 = s15 ? s86 : s84;-  const SWord16 s89 = s87 | 0x0400U;-  const SWord16 s90 = s13 ? s89 : s87;-  const SWord16 s92 = s90 | 0x0800U;-  const SWord16 s93 = s11 ? s92 : s90;-  const SWord16 s95 = s93 | 0x1000U;-  const SWord16 s96 = s9 ? s95 : s93;-  const SWord16 s98 = s96 | 0x2000U;-  const SWord16 s99 = s7 ? s98 : s96;-  const SWord16 s101 = s99 | 0x4000U;-  const SWord16 s102 = s5 ? s101 : s99;-  const SWord16 s104 = s102 | 0x8000U;-  const SWord16 s105 = s3 ? s104 : s102;--  return s105;-}-== END: "crcUSB5.c" ==================
− SBVUnitTest/GoldFiles/crcUSB5_2.gold 
@@ -1,225 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for crcUSB5. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: crcUSB5_driver--crcUSB5.o: crcUSB5.c crcUSB5.h-	${CC} ${CCFLAGS} -c $< -o $@--crcUSB5_driver.o: crcUSB5_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--crcUSB5_driver: crcUSB5.o crcUSB5_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f crcUSB5_driver-== END: "Makefile" ==================-== BEGIN: "crcUSB5.h" ================-/* Header file for crcUSB5. Automatically generated by SBV. Do not edit! */--#ifndef __crcUSB5__HEADER_INCLUDED__-#define __crcUSB5__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-SWord16 crcUSB5(const SWord16 msg);--#endif /* __crcUSB5__HEADER_INCLUDED__ */-== END: "crcUSB5.h" ==================-== BEGIN: "crcUSB5_driver.c" ================-/* Example driver program for crcUSB5. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "crcUSB5.h"--int main(void)-{-  const SWord16 __result = crcUSB5(0xfedcU);--  printf("crcUSB5(0xfedcU) = 0x%04"PRIx16"U\n", __result);--  return 0;-}-== END: "crcUSB5_driver.c" ==================-== BEGIN: "crcUSB5.c" ================-/* File: "crcUSB5.c". Automatically generated by SBV. Do not edit! */--#include "crcUSB5.h"--SWord16 crcUSB5(const SWord16 msg)-{-  const SWord16 s0 = msg;-  const SWord16 s1 = s0 << 5;-  const SBool   s2 = (SBool) ((s1 >> 15) & 1);-  const SBool   s4 = s2 != false;-  const SBool   s5 = (SBool) ((s1 >> 14) & 1);-  const SBool   s6 = false != s5;-  const SBool   s7 = (SBool) ((s1 >> 13) & 1);-  const SBool   s8 = false != s7;-  const SBool   s9 = (SBool) ((s1 >> 12) & 1);-  const SBool   s10 = false != s9;-  const SBool   s11 = !s10;-  const SBool   s12 = s4 ? s11 : s10;-  const SBool   s13 = (SBool) ((s1 >> 11) & 1);-  const SBool   s14 = false != s13;-  const SBool   s15 = !s14;-  const SBool   s16 = s6 ? s15 : s14;-  const SBool   s17 = (SBool) ((s1 >> 10) & 1);-  const SBool   s18 = false != s17;-  const SBool   s19 = !s18;-  const SBool   s20 = s4 ? s19 : s18;-  const SBool   s21 = !s20;-  const SBool   s22 = s8 ? s21 : s20;-  const SBool   s23 = (SBool) ((s1 >> 9) & 1);-  const SBool   s24 = false != s23;-  const SBool   s25 = !s24;-  const SBool   s26 = s6 ? s25 : s24;-  const SBool   s27 = !s26;-  const SBool   s28 = s12 ? s27 : s26;-  const SBool   s29 = (SBool) ((s1 >> 8) & 1);-  const SBool   s30 = false != s29;-  const SBool   s31 = !s30;-  const SBool   s32 = s8 ? s31 : s30;-  const SBool   s33 = !s32;-  const SBool   s34 = s16 ? s33 : s32;-  const SBool   s35 = (SBool) ((s1 >> 7) & 1);-  const SBool   s36 = false != s35;-  const SBool   s37 = !s36;-  const SBool   s38 = s12 ? s37 : s36;-  const SBool   s39 = !s38;-  const SBool   s40 = s22 ? s39 : s38;-  const SBool   s41 = (SBool) ((s1 >> 6) & 1);-  const SBool   s42 = false != s41;-  const SBool   s43 = !s42;-  const SBool   s44 = s16 ? s43 : s42;-  const SBool   s45 = !s44;-  const SBool   s46 = s28 ? s45 : s44;-  const SBool   s47 = (SBool) ((s1 >> 5) & 1);-  const SBool   s48 = false != s47;-  const SBool   s49 = !s48;-  const SBool   s50 = s22 ? s49 : s48;-  const SBool   s51 = !s50;-  const SBool   s52 = s34 ? s51 : s50;-  const SBool   s53 = !s4;-  const SBool   s54 = s4 ? s53 : s4;-  const SBool   s55 = !s6;-  const SBool   s56 = s6 ? s55 : s6;-  const SBool   s57 = !s8;-  const SBool   s58 = s8 ? s57 : s8;-  const SBool   s59 = !s12;-  const SBool   s60 = s12 ? s59 : s12;-  const SBool   s61 = !s16;-  const SBool   s62 = s16 ? s61 : s16;-  const SBool   s63 = !s22;-  const SBool   s64 = s22 ? s63 : s22;-  const SBool   s65 = !s28;-  const SBool   s66 = s28 ? s65 : s28;-  const SBool   s67 = !s34;-  const SBool   s68 = s34 ? s67 : s34;-  const SBool   s69 = !s40;-  const SBool   s70 = s40 ? s69 : s40;-  const SBool   s71 = !s46;-  const SBool   s72 = s46 ? s71 : s46;-  const SBool   s73 = !s52;-  const SBool   s74 = s52 ? s73 : s52;-  const SBool   s75 = (SBool) ((s1 >> 4) & 1);-  const SBool   s76 = false != s75;-  const SBool   s77 = !s76;-  const SBool   s78 = s28 ? s77 : s76;-  const SBool   s79 = !s78;-  const SBool   s80 = s40 ? s79 : s78;-  const SBool   s81 = (SBool) ((s1 >> 3) & 1);-  const SBool   s82 = false != s81;-  const SBool   s83 = !s82;-  const SBool   s84 = s34 ? s83 : s82;-  const SBool   s85 = !s84;-  const SBool   s86 = s46 ? s85 : s84;-  const SBool   s87 = (SBool) ((s1 >> 2) & 1);-  const SBool   s88 = false != s87;-  const SBool   s89 = !s88;-  const SBool   s90 = s40 ? s89 : s88;-  const SBool   s91 = !s90;-  const SBool   s92 = s52 ? s91 : s90;-  const SBool   s93 = (SBool) ((s1 >> 1) & 1);-  const SBool   s94 = false != s93;-  const SBool   s95 = !s94;-  const SBool   s96 = s46 ? s95 : s94;-  const SBool   s97 = (SBool) ((s1 >> 0) & 1);-  const SBool   s98 = false != s97;-  const SBool   s99 = !s98;-  const SBool   s100 = s52 ? s99 : s98;-  const SWord16 s103 = s100 ? 0x0001U : 0x0000U;-  const SWord16 s105 = s103 | 0x0002U;-  const SWord16 s106 = s96 ? s105 : s103;-  const SWord16 s108 = s106 | 0x0004U;-  const SWord16 s109 = s92 ? s108 : s106;-  const SWord16 s111 = s109 | 0x0008U;-  const SWord16 s112 = s86 ? s111 : s109;-  const SWord16 s114 = s112 | 0x0010U;-  const SWord16 s115 = s80 ? s114 : s112;-  const SWord16 s117 = s115 | 0x0020U;-  const SWord16 s118 = s74 ? s117 : s115;-  const SWord16 s120 = s118 | 0x0040U;-  const SWord16 s121 = s72 ? s120 : s118;-  const SWord16 s123 = s121 | 0x0080U;-  const SWord16 s124 = s70 ? s123 : s121;-  const SWord16 s126 = s124 | 0x0100U;-  const SWord16 s127 = s68 ? s126 : s124;-  const SWord16 s129 = s127 | 0x0200U;-  const SWord16 s130 = s66 ? s129 : s127;-  const SWord16 s132 = s130 | 0x0400U;-  const SWord16 s133 = s64 ? s132 : s130;-  const SWord16 s135 = s133 | 0x0800U;-  const SWord16 s136 = s62 ? s135 : s133;-  const SWord16 s138 = s136 | 0x1000U;-  const SWord16 s139 = s60 ? s138 : s136;-  const SWord16 s141 = s139 | 0x2000U;-  const SWord16 s142 = s58 ? s141 : s139;-  const SWord16 s144 = s142 | 0x4000U;-  const SWord16 s145 = s56 ? s144 : s142;-  const SWord16 s147 = s145 | 0x8000U;-  const SWord16 s148 = s54 ? s147 : s145;-  const SWord16 s149 = s1 | s148;--  return s149;-}-== END: "crcUSB5.c" ==================
− SBVUnitTest/GoldFiles/dogCatMouse.gold 
@@ -1,5 +0,0 @@-Solution #1:-  dog   =  3 :: Integer-  cat   = 41 :: Integer-  mouse = 56 :: Integer-This is the only solution.
− SBVUnitTest/GoldFiles/euler185.gold 
@@ -1,18 +0,0 @@-Solution #1:-  s0  = 4 :: Word8-  s1  = 6 :: Word8-  s2  = 4 :: Word8-  s3  = 0 :: Word8-  s4  = 2 :: Word8-  s5  = 6 :: Word8-  s6  = 1 :: Word8-  s7  = 5 :: Word8-  s8  = 7 :: Word8-  s9  = 1 :: Word8-  s10 = 8 :: Word8-  s11 = 4 :: Word8-  s12 = 9 :: Word8-  s13 = 5 :: Word8-  s14 = 3 :: Word8-  s15 = 3 :: Word8-This is the only solution.
− SBVUnitTest/GoldFiles/fib1.gold 
@@ -1,222 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for fib1. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: fib1_driver--fib1.o: fib1.c fib1.h-	${CC} ${CCFLAGS} -c $< -o $@--fib1_driver.o: fib1_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--fib1_driver: fib1.o fib1_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f fib1_driver-== END: "Makefile" ==================-== BEGIN: "fib1.h" ================-/* Header file for fib1. Automatically generated by SBV. Do not edit! */--#ifndef __fib1__HEADER_INCLUDED__-#define __fib1__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-SWord64 fib1(const SWord64 n);--#endif /* __fib1__HEADER_INCLUDED__ */-== END: "fib1.h" ==================-== BEGIN: "fib1_driver.c" ================-/* Example driver program for fib1. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "fib1.h"--int main(void)-{-  const SWord64 __result = fib1(0x000000000000000cULL);--  printf("fib1(0x000000000000000cULL) = 0x%016"PRIx64"ULL\n", __result);--  return 0;-}-== END: "fib1_driver.c" ==================-== BEGIN: "fib1.c" ================-/* File: "fib1.c". Automatically generated by SBV. Do not edit! */--#include "fib1.h"--SWord64 fib1(const SWord64 n)-{-  const SWord64 s0 = n;-  const SBool   s2 = s0 == 0x0000000000000000ULL;-  const SBool   s4 = s0 == 0x0000000000000001ULL;-  const SBool   s6 = s0 == 0x0000000000000002ULL;-  const SBool   s8 = s0 == 0x0000000000000003ULL;-  const SBool   s10 = s0 == 0x0000000000000004ULL;-  const SBool   s12 = s0 == 0x0000000000000005ULL;-  const SBool   s14 = s0 == 0x0000000000000006ULL;-  const SBool   s17 = s0 == 0x0000000000000007ULL;-  const SBool   s19 = s0 == 0x0000000000000008ULL;-  const SBool   s22 = s0 == 0x0000000000000009ULL;-  const SBool   s25 = s0 == 0x000000000000000aULL;-  const SBool   s28 = s0 == 0x000000000000000bULL;-  const SBool   s31 = s0 == 0x000000000000000cULL;-  const SBool   s33 = s0 == 0x000000000000000dULL;-  const SBool   s36 = s0 == 0x000000000000000eULL;-  const SBool   s39 = s0 == 0x000000000000000fULL;-  const SBool   s42 = s0 == 0x0000000000000010ULL;-  const SBool   s45 = s0 == 0x0000000000000011ULL;-  const SBool   s48 = s0 == 0x0000000000000012ULL;-  const SBool   s51 = s0 == 0x0000000000000013ULL;-  const SBool   s54 = s0 == 0x0000000000000014ULL;-  const SBool   s56 = s0 == 0x0000000000000015ULL;-  const SBool   s59 = s0 == 0x0000000000000016ULL;-  const SBool   s62 = s0 == 0x0000000000000017ULL;-  const SBool   s65 = s0 == 0x0000000000000018ULL;-  const SBool   s68 = s0 == 0x0000000000000019ULL;-  const SBool   s71 = s0 == 0x000000000000001aULL;-  const SBool   s74 = s0 == 0x000000000000001bULL;-  const SBool   s77 = s0 == 0x000000000000001cULL;-  const SBool   s80 = s0 == 0x000000000000001dULL;-  const SBool   s83 = s0 == 0x000000000000001eULL;-  const SBool   s86 = s0 == 0x000000000000001fULL;-  const SBool   s89 = s0 == 0x0000000000000020ULL;-  const SBool   s92 = s0 == 0x0000000000000021ULL;-  const SBool   s94 = s0 == 0x0000000000000022ULL;-  const SBool   s97 = s0 == 0x0000000000000023ULL;-  const SBool   s100 = s0 == 0x0000000000000024ULL;-  const SBool   s103 = s0 == 0x0000000000000025ULL;-  const SBool   s106 = s0 == 0x0000000000000026ULL;-  const SBool   s109 = s0 == 0x0000000000000027ULL;-  const SBool   s112 = s0 == 0x0000000000000028ULL;-  const SBool   s115 = s0 == 0x0000000000000029ULL;-  const SBool   s118 = s0 == 0x000000000000002aULL;-  const SBool   s121 = s0 == 0x000000000000002bULL;-  const SBool   s124 = s0 == 0x000000000000002cULL;-  const SBool   s127 = s0 == 0x000000000000002dULL;-  const SBool   s130 = s0 == 0x000000000000002eULL;-  const SBool   s133 = s0 == 0x000000000000002fULL;-  const SBool   s136 = s0 == 0x0000000000000030ULL;-  const SBool   s139 = s0 == 0x0000000000000031ULL;-  const SBool   s142 = s0 == 0x0000000000000032ULL;-  const SBool   s145 = s0 == 0x0000000000000033ULL;-  const SBool   s148 = s0 == 0x0000000000000034ULL;-  const SBool   s151 = s0 == 0x0000000000000035ULL;-  const SBool   s154 = s0 == 0x0000000000000036ULL;-  const SBool   s156 = s0 == 0x0000000000000037ULL;-  const SBool   s159 = s0 == 0x0000000000000038ULL;-  const SBool   s162 = s0 == 0x0000000000000039ULL;-  const SBool   s165 = s0 == 0x000000000000003aULL;-  const SBool   s168 = s0 == 0x000000000000003bULL;-  const SBool   s171 = s0 == 0x000000000000003cULL;-  const SBool   s174 = s0 == 0x000000000000003dULL;-  const SBool   s177 = s0 == 0x000000000000003eULL;-  const SBool   s180 = s0 == 0x000000000000003fULL;-  const SWord64 s183 = s180 ? 0x000005f6c7b064e2ULL : 0x000009a661ca20bbULL;-  const SWord64 s184 = s177 ? 0x000003af9a19bbd9ULL : s183;-  const SWord64 s185 = s174 ? 0x000002472d96a909ULL : s184;-  const SWord64 s186 = s171 ? 0x000001686c8312d0ULL : s185;-  const SWord64 s187 = s168 ? 0x000000dec1139639ULL : s186;-  const SWord64 s188 = s165 ? 0x00000089ab6f7c97ULL : s187;-  const SWord64 s189 = s162 ? 0x0000005515a419a2ULL : s188;-  const SWord64 s190 = s159 ? 0x0000003495cb62f5ULL : s189;-  const SWord64 s191 = s156 ? 0x000000207fd8b6adULL : s190;-  const SWord64 s192 = s154 ? 0x0000001415f2ac48ULL : s191;-  const SWord64 s193 = s151 ? 0x0000000c69e60a65ULL : s192;-  const SWord64 s194 = s148 ? 0x00000007ac0ca1e3ULL : s193;-  const SWord64 s195 = s145 ? 0x00000004bdd96882ULL : s194;-  const SWord64 s196 = s142 ? 0x00000002ee333961ULL : s195;-  const SWord64 s197 = s139 ? 0x00000001cfa62f21ULL : s196;-  const SWord64 s198 = s136 ? 0x000000011e8d0a40ULL : s197;-  const SWord64 s199 = s133 ? 0x00000000b11924e1ULL : s198;-  const SWord64 s200 = s130 ? 0x000000006d73e55fULL : s199;-  const SWord64 s201 = s127 ? 0x0000000043a53f82ULL : s200;-  const SWord64 s202 = s124 ? 0x0000000029cea5ddULL : s201;-  const SWord64 s203 = s121 ? 0x0000000019d699a5ULL : s202;-  const SWord64 s204 = s118 ? 0x000000000ff80c38ULL : s203;-  const SWord64 s205 = s115 ? 0x0000000009de8d6dULL : s204;-  const SWord64 s206 = s112 ? 0x0000000006197ecbULL : s205;-  const SWord64 s207 = s109 ? 0x0000000003c50ea2ULL : s206;-  const SWord64 s208 = s106 ? 0x0000000002547029ULL : s207;-  const SWord64 s209 = s103 ? 0x0000000001709e79ULL : s208;-  const SWord64 s210 = s100 ? 0x0000000000e3d1b0ULL : s209;-  const SWord64 s211 = s97 ? 0x00000000008cccc9ULL : s210;-  const SWord64 s212 = s94 ? 0x00000000005704e7ULL : s211;-  const SWord64 s213 = s92 ? 0x000000000035c7e2ULL : s212;-  const SWord64 s214 = s89 ? 0x0000000000213d05ULL : s213;-  const SWord64 s215 = s86 ? 0x0000000000148addULL : s214;-  const SWord64 s216 = s83 ? 0x00000000000cb228ULL : s215;-  const SWord64 s217 = s80 ? 0x000000000007d8b5ULL : s216;-  const SWord64 s218 = s77 ? 0x000000000004d973ULL : s217;-  const SWord64 s219 = s74 ? 0x000000000002ff42ULL : s218;-  const SWord64 s220 = s71 ? 0x000000000001da31ULL : s219;-  const SWord64 s221 = s68 ? 0x0000000000012511ULL : s220;-  const SWord64 s222 = s65 ? 0x000000000000b520ULL : s221;-  const SWord64 s223 = s62 ? 0x0000000000006ff1ULL : s222;-  const SWord64 s224 = s59 ? 0x000000000000452fULL : s223;-  const SWord64 s225 = s56 ? 0x0000000000002ac2ULL : s224;-  const SWord64 s226 = s54 ? 0x0000000000001a6dULL : s225;-  const SWord64 s227 = s51 ? 0x0000000000001055ULL : s226;-  const SWord64 s228 = s48 ? 0x0000000000000a18ULL : s227;-  const SWord64 s229 = s45 ? 0x000000000000063dULL : s228;-  const SWord64 s230 = s42 ? 0x00000000000003dbULL : s229;-  const SWord64 s231 = s39 ? 0x0000000000000262ULL : s230;-  const SWord64 s232 = s36 ? 0x0000000000000179ULL : s231;-  const SWord64 s233 = s33 ? 0x00000000000000e9ULL : s232;-  const SWord64 s234 = s31 ? 0x0000000000000090ULL : s233;-  const SWord64 s235 = s28 ? 0x0000000000000059ULL : s234;-  const SWord64 s236 = s25 ? 0x0000000000000037ULL : s235;-  const SWord64 s237 = s22 ? 0x0000000000000022ULL : s236;-  const SWord64 s238 = s19 ? 0x0000000000000015ULL : s237;-  const SWord64 s239 = s17 ? 0x000000000000000dULL : s238;-  const SWord64 s240 = s14 ? 0x0000000000000008ULL : s239;-  const SWord64 s241 = s12 ? 0x0000000000000005ULL : s240;-  const SWord64 s242 = s10 ? 0x0000000000000003ULL : s241;-  const SWord64 s243 = s8 ? 0x0000000000000002ULL : s242;-  const SWord64 s244 = s6 ? 0x0000000000000001ULL : s243;-  const SWord64 s245 = s4 ? 0x0000000000000001ULL : s244;-  const SWord64 s246 = s2 ? 0x0000000000000000ULL : s245;--  return s246;-}-== END: "fib1.c" ==================
− SBVUnitTest/GoldFiles/fib2.gold 
@@ -1,129 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for fib2. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: fib2_driver--fib2.o: fib2.c fib2.h-	${CC} ${CCFLAGS} -c $< -o $@--fib2_driver.o: fib2_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--fib2_driver: fib2.o fib2_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f fib2_driver-== END: "Makefile" ==================-== BEGIN: "fib2.h" ================-/* Header file for fib2. Automatically generated by SBV. Do not edit! */--#ifndef __fib2__HEADER_INCLUDED__-#define __fib2__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-SWord64 fib2(const SWord64 n);--#endif /* __fib2__HEADER_INCLUDED__ */-== END: "fib2.h" ==================-== BEGIN: "fib2_driver.c" ================-/* Example driver program for fib2. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "fib2.h"--int main(void)-{-  const SWord64 __result = fib2(0x0000000000000014ULL);--  printf("fib2(0x0000000000000014ULL) = 0x%016"PRIx64"ULL\n", __result);--  return 0;-}-== END: "fib2_driver.c" ==================-== BEGIN: "fib2.c" ================-/* File: "fib2.c". Automatically generated by SBV. Do not edit! */--#include "fib2.h"--SWord64 fib2(const SWord64 n)-{-  const SWord64 s0 = n;-  static const SWord64 table0[] = {-      0x0000000000000000ULL, 0x0000000000000001ULL,-      0x0000000000000001ULL, 0x0000000000000002ULL,-      0x0000000000000003ULL, 0x0000000000000005ULL,-      0x0000000000000008ULL, 0x000000000000000dULL,-      0x0000000000000015ULL, 0x0000000000000022ULL,-      0x0000000000000037ULL, 0x0000000000000059ULL,-      0x0000000000000090ULL, 0x00000000000000e9ULL,-      0x0000000000000179ULL, 0x0000000000000262ULL,-      0x00000000000003dbULL, 0x000000000000063dULL,-      0x0000000000000a18ULL, 0x0000000000001055ULL,-      0x0000000000001a6dULL, 0x0000000000002ac2ULL,-      0x000000000000452fULL, 0x0000000000006ff1ULL,-      0x000000000000b520ULL, 0x0000000000012511ULL,-      0x000000000001da31ULL, 0x000000000002ff42ULL,-      0x000000000004d973ULL, 0x000000000007d8b5ULL,-      0x00000000000cb228ULL, 0x0000000000148addULL,-      0x0000000000213d05ULL, 0x000000000035c7e2ULL,-      0x00000000005704e7ULL, 0x00000000008cccc9ULL,-      0x0000000000e3d1b0ULL, 0x0000000001709e79ULL,-      0x0000000002547029ULL, 0x0000000003c50ea2ULL,-      0x0000000006197ecbULL, 0x0000000009de8d6dULL,-      0x000000000ff80c38ULL, 0x0000000019d699a5ULL,-      0x0000000029cea5ddULL, 0x0000000043a53f82ULL,-      0x000000006d73e55fULL, 0x00000000b11924e1ULL,-      0x000000011e8d0a40ULL, 0x00000001cfa62f21ULL,-      0x00000002ee333961ULL, 0x00000004bdd96882ULL,-      0x00000007ac0ca1e3ULL, 0x0000000c69e60a65ULL,-      0x0000001415f2ac48ULL, 0x000000207fd8b6adULL,-      0x0000003495cb62f5ULL, 0x0000005515a419a2ULL,-      0x00000089ab6f7c97ULL, 0x000000dec1139639ULL,-      0x000001686c8312d0ULL, 0x000002472d96a909ULL,-      0x000003af9a19bbd9ULL, 0x000005f6c7b064e2ULL, 0x000009a661ca20bbULL-  };-  const SWord64 s65 = s0 >= 65 ? 0x0000000000000000ULL : table0[s0];--  return s65;-}-== END: "fib2.c" ==================
− SBVUnitTest/GoldFiles/floats_cgen.gold 
@@ -1,2869 +0,0 @@-== BEGIN: "toFP_Int8_ToFloat.c" ================-/* File: "toFP_Int8_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Int8_ToFloat(const SInt8 a)-{-  const SInt8  s0 = a;-  const SFloat s2 = (SFloat) s0;--  return s2;-}-== END: "toFP_Int8_ToFloat.c" ==================-== BEGIN: "toFP_Int16_ToFloat.c" ================-/* File: "toFP_Int16_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Int16_ToFloat(const SInt16 a)-{-  const SInt16 s0 = a;-  const SFloat s2 = (SFloat) s0;--  return s2;-}-== END: "toFP_Int16_ToFloat.c" ==================-== BEGIN: "toFP_Int32_ToFloat.c" ================-/* File: "toFP_Int32_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Int32_ToFloat(const SInt32 a)-{-  const SInt32 s0 = a;-  const SFloat s2 = (SFloat) s0;--  return s2;-}-== END: "toFP_Int32_ToFloat.c" ==================-== BEGIN: "toFP_Int64_ToFloat.c" ================-/* File: "toFP_Int64_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Int64_ToFloat(const SInt64 a)-{-  const SInt64 s0 = a;-  const SFloat s2 = (SFloat) s0;--  return s2;-}-== END: "toFP_Int64_ToFloat.c" ==================-== BEGIN: "toFP_Word8_ToFloat.c" ================-/* File: "toFP_Word8_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Word8_ToFloat(const SWord8 a)-{-  const SWord8 s0 = a;-  const SFloat s2 = (SFloat) s0;--  return s2;-}-== END: "toFP_Word8_ToFloat.c" ==================-== BEGIN: "toFP_Word16_ToFloat.c" ================-/* File: "toFP_Word16_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Word16_ToFloat(const SWord16 a)-{-  const SWord16 s0 = a;-  const SFloat  s2 = (SFloat) s0;--  return s2;-}-== END: "toFP_Word16_ToFloat.c" ==================-== BEGIN: "toFP_Word32_ToFloat.c" ================-/* File: "toFP_Word32_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Word32_ToFloat(const SWord32 a)-{-  const SWord32 s0 = a;-  const SFloat  s2 = (SFloat) s0;--  return s2;-}-== END: "toFP_Word32_ToFloat.c" ==================-== BEGIN: "toFP_Word64_ToFloat.c" ================-/* File: "toFP_Word64_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Word64_ToFloat(const SWord64 a)-{-  const SWord64 s0 = a;-  const SFloat  s2 = (SFloat) s0;--  return s2;-}-== END: "toFP_Word64_ToFloat.c" ==================-== BEGIN: "toFP_Float_ToFloat.c" ================-/* File: "toFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Float_ToFloat(const SFloat a)-{-  const SFloat s0 = a;-  return s0;-}-== END: "toFP_Float_ToFloat.c" ==================-== BEGIN: "toFP_Double_ToFloat.c" ================-/* File: "toFP_Double_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Double_ToFloat(const SDouble a)-{-  const SDouble s0 = a;-  const SFloat  s2 = (SFloat) s0;--  return s2;-}-== END: "toFP_Double_ToFloat.c" ==================-== BEGIN: "toFP_Integer_ToFloat.c" ================-/* File: "toFP_Integer_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Integer_ToFloat(const SInteger a)-{-  const SInteger s0 = a;-  const SFloat   s2 = (SFloat) s0;--  return s2;-}-== END: "toFP_Integer_ToFloat.c" ==================-== BEGIN: "toFP_Real_ToFloat.c" ================-/* File: "toFP_Real_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat toFP_Real_ToFloat(const SReal a)-{-  const SReal  s0 = a;-  const SFloat s2 = (SFloat) s0;--  return s2;-}-== END: "toFP_Real_ToFloat.c" ==================-== BEGIN: "toFP_Int8_ToDouble.c" ================-/* File: "toFP_Int8_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Int8_ToDouble(const SInt8 a)-{-  const SInt8   s0 = a;-  const SDouble s2 = (SDouble) s0;--  return s2;-}-== END: "toFP_Int8_ToDouble.c" ==================-== BEGIN: "toFP_Int16_ToDouble.c" ================-/* File: "toFP_Int16_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Int16_ToDouble(const SInt16 a)-{-  const SInt16  s0 = a;-  const SDouble s2 = (SDouble) s0;--  return s2;-}-== END: "toFP_Int16_ToDouble.c" ==================-== BEGIN: "toFP_Int32_ToDouble.c" ================-/* File: "toFP_Int32_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Int32_ToDouble(const SInt32 a)-{-  const SInt32  s0 = a;-  const SDouble s2 = (SDouble) s0;--  return s2;-}-== END: "toFP_Int32_ToDouble.c" ==================-== BEGIN: "toFP_Int64_ToDouble.c" ================-/* File: "toFP_Int64_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Int64_ToDouble(const SInt64 a)-{-  const SInt64  s0 = a;-  const SDouble s2 = (SDouble) s0;--  return s2;-}-== END: "toFP_Int64_ToDouble.c" ==================-== BEGIN: "toFP_Word8_ToDouble.c" ================-/* File: "toFP_Word8_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Word8_ToDouble(const SWord8 a)-{-  const SWord8  s0 = a;-  const SDouble s2 = (SDouble) s0;--  return s2;-}-== END: "toFP_Word8_ToDouble.c" ==================-== BEGIN: "toFP_Word16_ToDouble.c" ================-/* File: "toFP_Word16_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Word16_ToDouble(const SWord16 a)-{-  const SWord16 s0 = a;-  const SDouble s2 = (SDouble) s0;--  return s2;-}-== END: "toFP_Word16_ToDouble.c" ==================-== BEGIN: "toFP_Word32_ToDouble.c" ================-/* File: "toFP_Word32_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Word32_ToDouble(const SWord32 a)-{-  const SWord32 s0 = a;-  const SDouble s2 = (SDouble) s0;--  return s2;-}-== END: "toFP_Word32_ToDouble.c" ==================-== BEGIN: "toFP_Word64_ToDouble.c" ================-/* File: "toFP_Word64_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Word64_ToDouble(const SWord64 a)-{-  const SWord64 s0 = a;-  const SDouble s2 = (SDouble) s0;--  return s2;-}-== END: "toFP_Word64_ToDouble.c" ==================-== BEGIN: "toFP_Float_ToDouble.c" ================-/* File: "toFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Float_ToDouble(const SFloat a)-{-  const SFloat  s0 = a;-  const SDouble s2 = (SDouble) s0;--  return s2;-}-== END: "toFP_Float_ToDouble.c" ==================-== BEGIN: "toFP_Double_ToDouble.c" ================-/* File: "toFP_Double_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Double_ToDouble(const SDouble a)-{-  const SDouble s0 = a;-  return s0;-}-== END: "toFP_Double_ToDouble.c" ==================-== BEGIN: "toFP_Integer_ToDouble.c" ================-/* File: "toFP_Integer_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Integer_ToDouble(const SInteger a)-{-  const SInteger s0 = a;-  const SDouble  s2 = (SDouble) s0;--  return s2;-}-== END: "toFP_Integer_ToDouble.c" ==================-== BEGIN: "toFP_Real_ToDouble.c" ================-/* File: "toFP_Real_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble toFP_Real_ToDouble(const SReal a)-{-  const SReal   s0 = a;-  const SDouble s2 = (SDouble) s0;--  return s2;-}-== END: "toFP_Real_ToDouble.c" ==================-== BEGIN: "fromFP_Float_ToInt8.c" ================-/* File: "fromFP_Float_ToInt8.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SInt8 fromFP_Float_ToInt8(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = isnan(s0);-  const SBool  s2 = isinf(s0);-  const SBool  s3 = s1 || s2;-  const SBool  s4 = !s3;-  const SInt8  s6 = (SInt8) s0;-  const SInt8  s8 = s4 ? s6 : 0;--  return s8;-}-== END: "fromFP_Float_ToInt8.c" ==================-== BEGIN: "fromFP_Float_ToInt16.c" ================-/* File: "fromFP_Float_ToInt16.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SInt16 fromFP_Float_ToInt16(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = isnan(s0);-  const SBool  s2 = isinf(s0);-  const SBool  s3 = s1 || s2;-  const SBool  s4 = !s3;-  const SInt16 s6 = (SInt16) s0;-  const SInt16 s8 = s4 ? s6 : 0x0000;--  return s8;-}-== END: "fromFP_Float_ToInt16.c" ==================-== BEGIN: "fromFP_Float_ToInt32.c" ================-/* File: "fromFP_Float_ToInt32.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SInt32 fromFP_Float_ToInt32(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = isnan(s0);-  const SBool  s2 = isinf(s0);-  const SBool  s3 = s1 || s2;-  const SBool  s4 = !s3;-  const SInt32 s6 = (SInt32) s0;-  const SInt32 s8 = s4 ? s6 : 0x00000000L;--  return s8;-}-== END: "fromFP_Float_ToInt32.c" ==================-== BEGIN: "fromFP_Float_ToInt64.c" ================-/* File: "fromFP_Float_ToInt64.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SInt64 fromFP_Float_ToInt64(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = isnan(s0);-  const SBool  s2 = isinf(s0);-  const SBool  s3 = s1 || s2;-  const SBool  s4 = !s3;-  const SInt64 s6 = (SInt64) s0;-  const SInt64 s8 = s4 ? s6 : 0x0000000000000000LL;--  return s8;-}-== END: "fromFP_Float_ToInt64.c" ==================-== BEGIN: "fromFP_Float_ToWord8.c" ================-/* File: "fromFP_Float_ToWord8.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SWord8 fromFP_Float_ToWord8(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = isnan(s0);-  const SBool  s2 = isinf(s0);-  const SBool  s3 = s1 || s2;-  const SBool  s4 = !s3;-  const SWord8 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord8) fabsf(s0))) : ((SWord8) s0);-  const SWord8 s8 = s4 ? s6 : 0;--  return s8;-}-== END: "fromFP_Float_ToWord8.c" ==================-== BEGIN: "fromFP_Float_ToWord16.c" ================-/* File: "fromFP_Float_ToWord16.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SWord16 fromFP_Float_ToWord16(const SFloat a)-{-  const SFloat  s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SWord16 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord16) fabsf(s0))) : ((SWord16) s0);-  const SWord16 s8 = s4 ? s6 : 0x0000U;--  return s8;-}-== END: "fromFP_Float_ToWord16.c" ==================-== BEGIN: "fromFP_Float_ToWord32.c" ================-/* File: "fromFP_Float_ToWord32.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SWord32 fromFP_Float_ToWord32(const SFloat a)-{-  const SFloat  s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SWord32 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord32) fabsf(s0))) : ((SWord32) s0);-  const SWord32 s8 = s4 ? s6 : 0x00000000UL;--  return s8;-}-== END: "fromFP_Float_ToWord32.c" ==================-== BEGIN: "fromFP_Float_ToWord64.c" ================-/* File: "fromFP_Float_ToWord64.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SWord64 fromFP_Float_ToWord64(const SFloat a)-{-  const SFloat  s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SWord64 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord64) fabsf(s0))) : ((SWord64) s0);-  const SWord64 s8 = s4 ? s6 : 0x0000000000000000ULL;--  return s8;-}-== END: "fromFP_Float_ToWord64.c" ==================-== BEGIN: "fromFP_Float_ToFloat.c" ================-/* File: "fromFP_Float_ToFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat fromFP_Float_ToFloat(const SFloat a)-{-  const SFloat s0 = a;-  return s0;-}-== END: "fromFP_Float_ToFloat.c" ==================-== BEGIN: "fromFP_Float_ToDouble.c" ================-/* File: "fromFP_Float_ToDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble fromFP_Float_ToDouble(const SFloat a)-{-  const SFloat  s0 = a;-  const SDouble s2 = (SDouble) s0;--  return s2;-}-== END: "fromFP_Float_ToDouble.c" ==================-== BEGIN: "fromFP_Float_ToInteger.c" ================-/* File: "fromFP_Float_ToInteger.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SInteger fromFP_Float_ToInteger(const SFloat a)-{-  const SFloat   s0 = a;-  const SBool    s1 = isnan(s0);-  const SBool    s2 = isinf(s0);-  const SBool    s3 = s1 || s2;-  const SBool    s4 = !s3;-  const SInteger s6 = (SInteger) s0;-  const SInteger s8 = s4 ? s6 : 0x0000000000000000LL;--  return s8;-}-== END: "fromFP_Float_ToInteger.c" ==================-== BEGIN: "fromFP_Float_ToReal.c" ================-/* File: "fromFP_Float_ToReal.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SReal fromFP_Float_ToReal(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = isnan(s0);-  const SBool  s2 = isinf(s0);-  const SBool  s3 = s1 || s2;-  const SBool  s4 = !s3;-  const SReal  s6 = (SReal) s0;-  const SReal  s8 = s4 ? s6 : 0.0L;--  return s8;-}-== END: "fromFP_Float_ToReal.c" ==================-== BEGIN: "fromFP_DoubleTo_Int8.c" ================-/* File: "fromFP_DoubleTo_Int8.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SInt8 fromFP_DoubleTo_Int8(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SInt8   s6 = (SInt8) s0;-  const SInt8   s8 = s4 ? s6 : 0;--  return s8;-}-== END: "fromFP_DoubleTo_Int8.c" ==================-== BEGIN: "fromFP_DoubleTo_Int16.c" ================-/* File: "fromFP_DoubleTo_Int16.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SInt16 fromFP_DoubleTo_Int16(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SInt16  s6 = (SInt16) s0;-  const SInt16  s8 = s4 ? s6 : 0x0000;--  return s8;-}-== END: "fromFP_DoubleTo_Int16.c" ==================-== BEGIN: "fromFP_DoubleTo_Int32.c" ================-/* File: "fromFP_DoubleTo_Int32.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SInt32 fromFP_DoubleTo_Int32(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SInt32  s6 = (SInt32) s0;-  const SInt32  s8 = s4 ? s6 : 0x00000000L;--  return s8;-}-== END: "fromFP_DoubleTo_Int32.c" ==================-== BEGIN: "fromFP_DoubleTo_Int64.c" ================-/* File: "fromFP_DoubleTo_Int64.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SInt64 fromFP_DoubleTo_Int64(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SInt64  s6 = (SInt64) s0;-  const SInt64  s8 = s4 ? s6 : 0x0000000000000000LL;--  return s8;-}-== END: "fromFP_DoubleTo_Int64.c" ==================-== BEGIN: "fromFP_DoubleTo_Word8.c" ================-/* File: "fromFP_DoubleTo_Word8.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SWord8 fromFP_DoubleTo_Word8(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SWord8  s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord8) fabs(s0))) : ((SWord8) s0);-  const SWord8  s8 = s4 ? s6 : 0;--  return s8;-}-== END: "fromFP_DoubleTo_Word8.c" ==================-== BEGIN: "fromFP_DoubleTo_Word16.c" ================-/* File: "fromFP_DoubleTo_Word16.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SWord16 fromFP_DoubleTo_Word16(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SWord16 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord16) fabs(s0))) : ((SWord16) s0);-  const SWord16 s8 = s4 ? s6 : 0x0000U;--  return s8;-}-== END: "fromFP_DoubleTo_Word16.c" ==================-== BEGIN: "fromFP_DoubleTo_Word32.c" ================-/* File: "fromFP_DoubleTo_Word32.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SWord32 fromFP_DoubleTo_Word32(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SWord32 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord32) fabs(s0))) : ((SWord32) s0);-  const SWord32 s8 = s4 ? s6 : 0x00000000UL;--  return s8;-}-== END: "fromFP_DoubleTo_Word32.c" ==================-== BEGIN: "fromFP_DoubleTo_Word64.c" ================-/* File: "fromFP_DoubleTo_Word64.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SWord64 fromFP_DoubleTo_Word64(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SWord64 s6 = (!isnan(s0) && signbit(s0)) ? (- ((SWord64) fabs(s0))) : ((SWord64) s0);-  const SWord64 s8 = s4 ? s6 : 0x0000000000000000ULL;--  return s8;-}-== END: "fromFP_DoubleTo_Word64.c" ==================-== BEGIN: "fromFP_DoubleTo_Float.c" ================-/* File: "fromFP_DoubleTo_Float.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat fromFP_DoubleTo_Float(const SDouble a)-{-  const SDouble s0 = a;-  const SFloat  s2 = (SFloat) s0;--  return s2;-}-== END: "fromFP_DoubleTo_Float.c" ==================-== BEGIN: "fromFP_DoubleTo_Double.c" ================-/* File: "fromFP_DoubleTo_Double.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble fromFP_DoubleTo_Double(const SDouble a)-{-  const SDouble s0 = a;-  return s0;-}-== END: "fromFP_DoubleTo_Double.c" ==================-== BEGIN: "fromFP_DoubleTo_Integer.c" ================-/* File: "fromFP_DoubleTo_Integer.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SInteger fromFP_DoubleTo_Integer(const SDouble a)-{-  const SDouble  s0 = a;-  const SBool    s1 = isnan(s0);-  const SBool    s2 = isinf(s0);-  const SBool    s3 = s1 || s2;-  const SBool    s4 = !s3;-  const SInteger s6 = (SInteger) s0;-  const SInteger s8 = s4 ? s6 : 0x0000000000000000LL;--  return s8;-}-== END: "fromFP_DoubleTo_Integer.c" ==================-== BEGIN: "fromFP_DoubleTo_Real.c" ================-/* File: "fromFP_DoubleTo_Real.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SReal fromFP_DoubleTo_Real(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isnan(s0);-  const SBool   s2 = isinf(s0);-  const SBool   s3 = s1 || s2;-  const SBool   s4 = !s3;-  const SReal   s6 = (SReal) s0;-  const SReal   s8 = s4 ? s6 : 0.0L;--  return s8;-}-== END: "fromFP_DoubleTo_Real.c" ==================-== BEGIN: "fromFP_SWord32_SFloat.c" ================-/* File: "fromFP_SWord32_SFloat.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat fromFP_SWord32_SFloat(const SWord32 a)-{-  const SWord32 s0 = a;-        SFloat  s1; memcpy(&s1, &s0, sizeof(SFloat));--  return s1;-}-== END: "fromFP_SWord32_SFloat.c" ==================-== BEGIN: "fromFP_SWord64_SDouble.c" ================-/* File: "fromFP_SWord64_SDouble.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble fromFP_SWord64_SDouble(const SWord64 a)-{-  const SWord64 s0 = a;-        SDouble s1; memcpy(&s1, &s0, sizeof(SDouble));--  return s1;-}-== END: "fromFP_SWord64_SDouble.c" ==================-== BEGIN: "fromFP_SFloat_SWord32.c" ================-/* File: "fromFP_SFloat_SWord32.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SWord32 fromFP_SFloat_SWord32(const SFloat a)-{-  const SFloat  s0 = a;-        SWord32 s1; memcpy(&s1, &s0, sizeof(SWord32));--  return s1;-}-== END: "fromFP_SFloat_SWord32.c" ==================-== BEGIN: "fromFP_SDouble_SWord64.c" ================-/* File: "fromFP_SDouble_SWord64.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SWord64 fromFP_SDouble_SWord64(const SDouble a)-{-  const SDouble s0 = a;-        SWord64 s1; memcpy(&s1, &s0, sizeof(SWord64));--  return s1;-}-== END: "fromFP_SDouble_SWord64.c" ==================-== BEGIN: "f_FP_Abs.c" ================-/* File: "f_FP_Abs.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_Abs(const SFloat a)-{-  const SFloat s0 = a;-  const SFloat s1 = fabsf(s0);--  return s1;-}-== END: "f_FP_Abs.c" ==================-== BEGIN: "d_FP_Abs.c" ================-/* File: "d_FP_Abs.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_Abs(const SDouble a)-{-  const SDouble s0 = a;-  const SDouble s1 = fabs(s0);--  return s1;-}-== END: "d_FP_Abs.c" ==================-== BEGIN: "f_FP_Neg.c" ================-/* File: "f_FP_Neg.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_Neg(const SFloat a)-{-  const SFloat s0 = a;-  const SFloat s1 = (- s0);--  return s1;-}-== END: "f_FP_Neg.c" ==================-== BEGIN: "d_FP_Neg.c" ================-/* File: "d_FP_Neg.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_Neg(const SDouble a)-{-  const SDouble s0 = a;-  const SDouble s1 = (- s0);--  return s1;-}-== END: "d_FP_Neg.c" ==================-== BEGIN: "f_FP_Add.c" ================-/* File: "f_FP_Add.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_Add(const SFloat a, const SFloat b)-{-  const SFloat s0 = a;-  const SFloat s1 = b;-  const SFloat s3 = s0 + s1;--  return s3;-}-== END: "f_FP_Add.c" ==================-== BEGIN: "d_FP_Add.c" ================-/* File: "d_FP_Add.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_Add(const SDouble a, const SDouble b)-{-  const SDouble s0 = a;-  const SDouble s1 = b;-  const SDouble s3 = s0 + s1;--  return s3;-}-== END: "d_FP_Add.c" ==================-== BEGIN: "f_FP_Sub.c" ================-/* File: "f_FP_Sub.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_Sub(const SFloat a, const SFloat b)-{-  const SFloat s0 = a;-  const SFloat s1 = b;-  const SFloat s3 = s0 - s1;--  return s3;-}-== END: "f_FP_Sub.c" ==================-== BEGIN: "d_FP_Sub.c" ================-/* File: "d_FP_Sub.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_Sub(const SDouble a, const SDouble b)-{-  const SDouble s0 = a;-  const SDouble s1 = b;-  const SDouble s3 = s0 - s1;--  return s3;-}-== END: "d_FP_Sub.c" ==================-== BEGIN: "f_FP_Mul.c" ================-/* File: "f_FP_Mul.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_Mul(const SFloat a, const SFloat b)-{-  const SFloat s0 = a;-  const SFloat s1 = b;-  const SFloat s3 = s0 * s1;--  return s3;-}-== END: "f_FP_Mul.c" ==================-== BEGIN: "d_FP_Mul.c" ================-/* File: "d_FP_Mul.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_Mul(const SDouble a, const SDouble b)-{-  const SDouble s0 = a;-  const SDouble s1 = b;-  const SDouble s3 = s0 * s1;--  return s3;-}-== END: "d_FP_Mul.c" ==================-== BEGIN: "f_FP_Div.c" ================-/* File: "f_FP_Div.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_Div(const SFloat a, const SFloat b)-{-  const SFloat s0 = a;-  const SFloat s1 = b;-  const SFloat s3 = s0 / s1;--  return s3;-}-== END: "f_FP_Div.c" ==================-== BEGIN: "d_FP_Div.c" ================-/* File: "d_FP_Div.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_Div(const SDouble a, const SDouble b)-{-  const SDouble s0 = a;-  const SDouble s1 = b;-  const SDouble s3 = s0 / s1;--  return s3;-}-== END: "d_FP_Div.c" ==================-== BEGIN: "f_FP_FMA.c" ================-/* File: "f_FP_FMA.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_FMA(const SFloat a, const SFloat b, const SFloat c)-{-  const SFloat s0 = a;-  const SFloat s1 = b;-  const SFloat s2 = c;-  const SFloat s4 = fmaf(s0, s1, s2);--  return s4;-}-== END: "f_FP_FMA.c" ==================-== BEGIN: "d_FP_FMA.c" ================-/* File: "d_FP_FMA.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_FMA(const SDouble a, const SDouble b, const SDouble c)-{-  const SDouble s0 = a;-  const SDouble s1 = b;-  const SDouble s2 = c;-  const SDouble s4 = fma(s0, s1, s2);--  return s4;-}-== END: "d_FP_FMA.c" ==================-== BEGIN: "f_FP_Sqrt.c" ================-/* File: "f_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_Sqrt(const SFloat a)-{-  const SFloat s0 = a;-  const SFloat s2 = sqrtf(s0);--  return s2;-}-== END: "f_FP_Sqrt.c" ==================-== BEGIN: "d_FP_Sqrt.c" ================-/* File: "d_FP_Sqrt.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_Sqrt(const SDouble a)-{-  const SDouble s0 = a;-  const SDouble s2 = sqrt(s0);--  return s2;-}-== END: "d_FP_Sqrt.c" ==================-== BEGIN: "f_FP_Rem.c" ================-/* File: "f_FP_Rem.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_Rem(const SFloat a, const SFloat b)-{-  const SFloat s0 = a;-  const SFloat s1 = b;-  const SFloat s2 = fmodf(s0, s1);--  return s2;-}-== END: "f_FP_Rem.c" ==================-== BEGIN: "d_FP_Rem.c" ================-/* File: "d_FP_Rem.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_Rem(const SDouble a, const SDouble b)-{-  const SDouble s0 = a;-  const SDouble s1 = b;-  const SDouble s2 = fmod(s0, s1);--  return s2;-}-== END: "d_FP_Rem.c" ==================-== BEGIN: "f_FP_RoundToIntegral.c" ================-/* File: "f_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_RoundToIntegral(const SFloat a)-{-  const SFloat s0 = a;-  const SFloat s2 = rintf(s0);--  return s2;-}-== END: "f_FP_RoundToIntegral.c" ==================-== BEGIN: "d_FP_RoundToIntegral.c" ================-/* File: "d_FP_RoundToIntegral.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_RoundToIntegral(const SDouble a)-{-  const SDouble s0 = a;-  const SDouble s2 = rint(s0);--  return s2;-}-== END: "d_FP_RoundToIntegral.c" ==================-== BEGIN: "f_FP_Min.c" ================-/* File: "f_FP_Min.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_Min(const SFloat a, const SFloat b)-{-  const SFloat s0 = a;-  const SFloat s1 = b;-  const SFloat s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0F : fminf(s0,-                                                                                                                                s1);--  return s2;-}-== END: "f_FP_Min.c" ==================-== BEGIN: "d_FP_Min.c" ================-/* File: "d_FP_Min.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_Min(const SDouble a, const SDouble b)-{-  const SDouble s0 = a;-  const SDouble s1 = b;-  const SDouble s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0 : fmin(s0,-                                                                                                                               s1);--  return s2;-}-== END: "d_FP_Min.c" ==================-== BEGIN: "f_FP_Max.c" ================-/* File: "f_FP_Max.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SFloat f_FP_Max(const SFloat a, const SFloat b)-{-  const SFloat s0 = a;-  const SFloat s1 = b;-  const SFloat s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0F : fmaxf(s0,-                                                                                                                                s1);--  return s2;-}-== END: "f_FP_Max.c" ==================-== BEGIN: "d_FP_Max.c" ================-/* File: "d_FP_Max.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SDouble d_FP_Max(const SDouble a, const SDouble b)-{-  const SDouble s0 = a;-  const SDouble s1 = b;-  const SDouble s2 = ((FP_ZERO == fpclassify(s0)) && (FP_ZERO == fpclassify(s1)) && (signbit(s0) != signbit(s1))) ? 0.0 : fmax(s0,-                                                                                                                               s1);--  return s2;-}-== END: "d_FP_Max.c" ==================-== BEGIN: "f_FP_IsEqualObject.c" ================-/* File: "f_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool f_FP_IsEqualObject(const SFloat a, const SFloat b)-{-  const SFloat s0 = a;-  const SFloat s1 = b;-  const SBool  s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1);--  return s2;-}-== END: "f_FP_IsEqualObject.c" ==================-== BEGIN: "d_FP_IsEqualObject.c" ================-/* File: "d_FP_IsEqualObject.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool d_FP_IsEqualObject(const SDouble a, const SDouble b)-{-  const SDouble s0 = a;-  const SDouble s1 = b;-  const SBool   s2 = isnan(s0) ? isnan(s1) : (signbit(s0) && (s0 == 0)) ? (signbit(s1) && (s1 == 0)) : (signbit(s1) && (s1 == 0)) ? (signbit(s0) && (s0 == 0)) : (s0 == s1);--  return s2;-}-== END: "d_FP_IsEqualObject.c" ==================-== BEGIN: "f_FP_IsNormal.c" ================-/* File: "f_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool f_FP_IsNormal(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = isnormal(s0);--  return s1;-}-== END: "f_FP_IsNormal.c" ==================-== BEGIN: "d_FP_IsNormal.c" ================-/* File: "d_FP_IsNormal.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool d_FP_IsNormal(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isnormal(s0);--  return s1;-}-== END: "d_FP_IsNormal.c" ==================-== BEGIN: "f_FP_IsZero.c" ================-/* File: "f_FP_IsZero.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool f_FP_IsZero(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = FP_ZERO == fpclassify(s0);--  return s1;-}-== END: "f_FP_IsZero.c" ==================-== BEGIN: "d_FP_IsZero.c" ================-/* File: "d_FP_IsZero.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool d_FP_IsZero(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = FP_ZERO == fpclassify(s0);--  return s1;-}-== END: "d_FP_IsZero.c" ==================-== BEGIN: "f_FP_IsSubnormal.c" ================-/* File: "f_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool f_FP_IsSubnormal(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = FP_SUBNORMAL == fpclassify(s0);--  return s1;-}-== END: "f_FP_IsSubnormal.c" ==================-== BEGIN: "d_FP_IsSubnormal.c" ================-/* File: "d_FP_IsSubnormal.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool d_FP_IsSubnormal(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = FP_SUBNORMAL == fpclassify(s0);--  return s1;-}-== END: "d_FP_IsSubnormal.c" ==================-== BEGIN: "f_FP_IsInfinite.c" ================-/* File: "f_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool f_FP_IsInfinite(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = isinf(s0);--  return s1;-}-== END: "f_FP_IsInfinite.c" ==================-== BEGIN: "d_FP_IsInfinite.c" ================-/* File: "d_FP_IsInfinite.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool d_FP_IsInfinite(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isinf(s0);--  return s1;-}-== END: "d_FP_IsInfinite.c" ==================-== BEGIN: "f_FP_IsNaN.c" ================-/* File: "f_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool f_FP_IsNaN(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = isnan(s0);--  return s1;-}-== END: "f_FP_IsNaN.c" ==================-== BEGIN: "d_FP_IsNaN.c" ================-/* File: "d_FP_IsNaN.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool d_FP_IsNaN(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = isnan(s0);--  return s1;-}-== END: "d_FP_IsNaN.c" ==================-== BEGIN: "f_FP_IsNegative.c" ================-/* File: "f_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool f_FP_IsNegative(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = !isnan(s0) && signbit(s0);--  return s1;-}-== END: "f_FP_IsNegative.c" ==================-== BEGIN: "d_FP_IsNegative.c" ================-/* File: "d_FP_IsNegative.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool d_FP_IsNegative(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = !isnan(s0) && signbit(s0);--  return s1;-}-== END: "d_FP_IsNegative.c" ==================-== BEGIN: "f_FP_IsPositive.c" ================-/* File: "f_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool f_FP_IsPositive(const SFloat a)-{-  const SFloat s0 = a;-  const SBool  s1 = !isnan(s0) && !signbit(s0);--  return s1;-}-== END: "f_FP_IsPositive.c" ==================-== BEGIN: "d_FP_IsPositive.c" ================-/* File: "d_FP_IsPositive.c". Automatically generated by SBV. Do not edit! */--#include "floatCodeGen.h"--SBool d_FP_IsPositive(const SDouble a)-{-  const SDouble s0 = a;-  const SBool   s1 = !isnan(s0) && !signbit(s0);--  return s1;-}-== END: "d_FP_IsPositive.c" ==================-== BEGIN: "floatCodeGen.h" ================-/* Header file for floatCodeGen. Automatically generated by SBV. Do not edit! */--#ifndef __floatCodeGen__HEADER_INCLUDED__-#define __floatCodeGen__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* User requested mapping for SInteger.                                 */-/* NB. Loss of precision: Target type is subject to modular arithmetic. */-typedef SInt64 SInteger;--/* User requested mapping for SReal.                          */-/* NB. Loss of precision: Target type is subject to rounding. */-typedef long double SReal;--/* Entry point prototypes: */-SFloat toFP_Int8_ToFloat(const SInt8 a);-SFloat toFP_Int16_ToFloat(const SInt16 a);-SFloat toFP_Int32_ToFloat(const SInt32 a);-SFloat toFP_Int64_ToFloat(const SInt64 a);-SFloat toFP_Word8_ToFloat(const SWord8 a);-SFloat toFP_Word16_ToFloat(const SWord16 a);-SFloat toFP_Word32_ToFloat(const SWord32 a);-SFloat toFP_Word64_ToFloat(const SWord64 a);-SFloat toFP_Float_ToFloat(const SFloat a);-SFloat toFP_Double_ToFloat(const SDouble a);-SFloat toFP_Integer_ToFloat(const SInteger a);-SFloat toFP_Real_ToFloat(const SReal a);-SDouble toFP_Int8_ToDouble(const SInt8 a);-SDouble toFP_Int16_ToDouble(const SInt16 a);-SDouble toFP_Int32_ToDouble(const SInt32 a);-SDouble toFP_Int64_ToDouble(const SInt64 a);-SDouble toFP_Word8_ToDouble(const SWord8 a);-SDouble toFP_Word16_ToDouble(const SWord16 a);-SDouble toFP_Word32_ToDouble(const SWord32 a);-SDouble toFP_Word64_ToDouble(const SWord64 a);-SDouble toFP_Float_ToDouble(const SFloat a);-SDouble toFP_Double_ToDouble(const SDouble a);-SDouble toFP_Integer_ToDouble(const SInteger a);-SDouble toFP_Real_ToDouble(const SReal a);-SInt8 fromFP_Float_ToInt8(const SFloat a);-SInt16 fromFP_Float_ToInt16(const SFloat a);-SInt32 fromFP_Float_ToInt32(const SFloat a);-SInt64 fromFP_Float_ToInt64(const SFloat a);-SWord8 fromFP_Float_ToWord8(const SFloat a);-SWord16 fromFP_Float_ToWord16(const SFloat a);-SWord32 fromFP_Float_ToWord32(const SFloat a);-SWord64 fromFP_Float_ToWord64(const SFloat a);-SFloat fromFP_Float_ToFloat(const SFloat a);-SDouble fromFP_Float_ToDouble(const SFloat a);-SInteger fromFP_Float_ToInteger(const SFloat a);-SReal fromFP_Float_ToReal(const SFloat a);-SInt8 fromFP_DoubleTo_Int8(const SDouble a);-SInt16 fromFP_DoubleTo_Int16(const SDouble a);-SInt32 fromFP_DoubleTo_Int32(const SDouble a);-SInt64 fromFP_DoubleTo_Int64(const SDouble a);-SWord8 fromFP_DoubleTo_Word8(const SDouble a);-SWord16 fromFP_DoubleTo_Word16(const SDouble a);-SWord32 fromFP_DoubleTo_Word32(const SDouble a);-SWord64 fromFP_DoubleTo_Word64(const SDouble a);-SFloat fromFP_DoubleTo_Float(const SDouble a);-SDouble fromFP_DoubleTo_Double(const SDouble a);-SInteger fromFP_DoubleTo_Integer(const SDouble a);-SReal fromFP_DoubleTo_Real(const SDouble a);-SFloat fromFP_SWord32_SFloat(const SWord32 a);-SDouble fromFP_SWord64_SDouble(const SWord64 a);-SWord32 fromFP_SFloat_SWord32(const SFloat a);-SWord64 fromFP_SDouble_SWord64(const SDouble a);-SFloat f_FP_Abs(const SFloat a);-SDouble d_FP_Abs(const SDouble a);-SFloat f_FP_Neg(const SFloat a);-SDouble d_FP_Neg(const SDouble a);-SFloat f_FP_Add(const SFloat a, const SFloat b);-SDouble d_FP_Add(const SDouble a, const SDouble b);-SFloat f_FP_Sub(const SFloat a, const SFloat b);-SDouble d_FP_Sub(const SDouble a, const SDouble b);-SFloat f_FP_Mul(const SFloat a, const SFloat b);-SDouble d_FP_Mul(const SDouble a, const SDouble b);-SFloat f_FP_Div(const SFloat a, const SFloat b);-SDouble d_FP_Div(const SDouble a, const SDouble b);-SFloat f_FP_FMA(const SFloat a, const SFloat b, const SFloat c);-SDouble d_FP_FMA(const SDouble a, const SDouble b,-                 const SDouble c);-SFloat f_FP_Sqrt(const SFloat a);-SDouble d_FP_Sqrt(const SDouble a);-SFloat f_FP_Rem(const SFloat a, const SFloat b);-SDouble d_FP_Rem(const SDouble a, const SDouble b);-SFloat f_FP_RoundToIntegral(const SFloat a);-SDouble d_FP_RoundToIntegral(const SDouble a);-SFloat f_FP_Min(const SFloat a, const SFloat b);-SDouble d_FP_Min(const SDouble a, const SDouble b);-SFloat f_FP_Max(const SFloat a, const SFloat b);-SDouble d_FP_Max(const SDouble a, const SDouble b);-SBool f_FP_IsEqualObject(const SFloat a, const SFloat b);-SBool d_FP_IsEqualObject(const SDouble a, const SDouble b);-SBool f_FP_IsNormal(const SFloat a);-SBool d_FP_IsNormal(const SDouble a);-SBool f_FP_IsZero(const SFloat a);-SBool d_FP_IsZero(const SDouble a);-SBool f_FP_IsSubnormal(const SFloat a);-SBool d_FP_IsSubnormal(const SDouble a);-SBool f_FP_IsInfinite(const SFloat a);-SBool d_FP_IsInfinite(const SDouble a);-SBool f_FP_IsNaN(const SFloat a);-SBool d_FP_IsNaN(const SDouble a);-SBool f_FP_IsNegative(const SFloat a);-SBool d_FP_IsNegative(const SDouble a);-SBool f_FP_IsPositive(const SFloat a);-SBool d_FP_IsPositive(const SDouble a);--#endif /* __floatCodeGen__HEADER_INCLUDED__ */-== END: "floatCodeGen.h" ==================-== BEGIN: "floatCodeGen_driver.c" ================-/* Example driver program for floatCodeGen. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "floatCodeGen.h"--void toFP_Int8_ToFloat_driver(void)-{-  const SFloat __result = toFP_Int8_ToFloat(42);--  printf("toFP_Int8_ToFloat(42) = %.6g\n", __result);-}--void toFP_Int16_ToFloat_driver(void)-{-  const SFloat __result = toFP_Int16_ToFloat(0x002a);--  printf("toFP_Int16_ToFloat(0x002a) = %.6g\n", __result);-}--void toFP_Int32_ToFloat_driver(void)-{-  const SFloat __result = toFP_Int32_ToFloat(0x0000002aL);--  printf("toFP_Int32_ToFloat(0x0000002aL) = %.6g\n", __result);-}--void toFP_Int64_ToFloat_driver(void)-{-  const SFloat __result = toFP_Int64_ToFloat(0x000000000000002aLL);--  printf("toFP_Int64_ToFloat(0x000000000000002aLL) = %.6g\n", __result);-}--void toFP_Word8_ToFloat_driver(void)-{-  const SFloat __result = toFP_Word8_ToFloat(42);--  printf("toFP_Word8_ToFloat(42) = %.6g\n", __result);-}--void toFP_Word16_ToFloat_driver(void)-{-  const SFloat __result = toFP_Word16_ToFloat(0x002aU);--  printf("toFP_Word16_ToFloat(0x002aU) = %.6g\n", __result);-}--void toFP_Word32_ToFloat_driver(void)-{-  const SFloat __result = toFP_Word32_ToFloat(0x0000002aUL);--  printf("toFP_Word32_ToFloat(0x0000002aUL) = %.6g\n", __result);-}--void toFP_Word64_ToFloat_driver(void)-{-  const SFloat __result = toFP_Word64_ToFloat(0x000000000000002aULL);--  printf("toFP_Word64_ToFloat(0x000000000000002aULL) = %.6g\n", __result);-}--void toFP_Float_ToFloat_driver(void)-{-  const SFloat __result = toFP_Float_ToFloat(42.0F);--  printf("toFP_Float_ToFloat(42.0F) = %.6g\n", __result);-}--void toFP_Double_ToFloat_driver(void)-{-  const SFloat __result = toFP_Double_ToFloat(42.0);--  printf("toFP_Double_ToFloat(42.0) = %.6g\n", __result);-}--void toFP_Integer_ToFloat_driver(void)-{-  const SFloat __result = toFP_Integer_ToFloat(0x000000000000002aLL);--  printf("toFP_Integer_ToFloat(0x000000000000002aLL) = %.6g\n", __result);-}--void toFP_Real_ToFloat_driver(void)-{-  const SFloat __result = toFP_Real_ToFloat(42.0L);--  printf("toFP_Real_ToFloat(42.0L) = %.6g\n", __result);-}--void toFP_Int8_ToDouble_driver(void)-{-  const SDouble __result = toFP_Int8_ToDouble(42);--  printf("toFP_Int8_ToDouble(42) = %.15g\n", __result);-}--void toFP_Int16_ToDouble_driver(void)-{-  const SDouble __result = toFP_Int16_ToDouble(0x002a);--  printf("toFP_Int16_ToDouble(0x002a) = %.15g\n", __result);-}--void toFP_Int32_ToDouble_driver(void)-{-  const SDouble __result = toFP_Int32_ToDouble(0x0000002aL);--  printf("toFP_Int32_ToDouble(0x0000002aL) = %.15g\n", __result);-}--void toFP_Int64_ToDouble_driver(void)-{-  const SDouble __result = toFP_Int64_ToDouble(0x000000000000002aLL);--  printf("toFP_Int64_ToDouble(0x000000000000002aLL) = %.15g\n", __result);-}--void toFP_Word8_ToDouble_driver(void)-{-  const SDouble __result = toFP_Word8_ToDouble(42);--  printf("toFP_Word8_ToDouble(42) = %.15g\n", __result);-}--void toFP_Word16_ToDouble_driver(void)-{-  const SDouble __result = toFP_Word16_ToDouble(0x002aU);--  printf("toFP_Word16_ToDouble(0x002aU) = %.15g\n", __result);-}--void toFP_Word32_ToDouble_driver(void)-{-  const SDouble __result = toFP_Word32_ToDouble(0x0000002aUL);--  printf("toFP_Word32_ToDouble(0x0000002aUL) = %.15g\n", __result);-}--void toFP_Word64_ToDouble_driver(void)-{-  const SDouble __result = toFP_Word64_ToDouble(0x000000000000002aULL);--  printf("toFP_Word64_ToDouble(0x000000000000002aULL) = %.15g\n", __result);-}--void toFP_Float_ToDouble_driver(void)-{-  const SDouble __result = toFP_Float_ToDouble(42.0F);--  printf("toFP_Float_ToDouble(42.0F) = %.15g\n", __result);-}--void toFP_Double_ToDouble_driver(void)-{-  const SDouble __result = toFP_Double_ToDouble(42.0);--  printf("toFP_Double_ToDouble(42.0) = %.15g\n", __result);-}--void toFP_Integer_ToDouble_driver(void)-{-  const SDouble __result = toFP_Integer_ToDouble(0x000000000000002aLL);--  printf("toFP_Integer_ToDouble(0x000000000000002aLL) = %.15g\n", __result);-}--void toFP_Real_ToDouble_driver(void)-{-  const SDouble __result = toFP_Real_ToDouble(42.0L);--  printf("toFP_Real_ToDouble(42.0L) = %.15g\n", __result);-}--void fromFP_Float_ToInt8_driver(void)-{-  const SInt8 __result = fromFP_Float_ToInt8(42.0F);--  printf("fromFP_Float_ToInt8(42.0F) = %"PRId8"\n", __result);-}--void fromFP_Float_ToInt16_driver(void)-{-  const SInt16 __result = fromFP_Float_ToInt16(42.0F);--  printf("fromFP_Float_ToInt16(42.0F) = %"PRId16"\n", __result);-}--void fromFP_Float_ToInt32_driver(void)-{-  const SInt32 __result = fromFP_Float_ToInt32(42.0F);--  printf("fromFP_Float_ToInt32(42.0F) = %"PRId32"L\n", __result);-}--void fromFP_Float_ToInt64_driver(void)-{-  const SInt64 __result = fromFP_Float_ToInt64(42.0F);--  printf("fromFP_Float_ToInt64(42.0F) = %"PRId64"LL\n", __result);-}--void fromFP_Float_ToWord8_driver(void)-{-  const SWord8 __result = fromFP_Float_ToWord8(42.0F);--  printf("fromFP_Float_ToWord8(42.0F) = %"PRIu8"\n", __result);-}--void fromFP_Float_ToWord16_driver(void)-{-  const SWord16 __result = fromFP_Float_ToWord16(42.0F);--  printf("fromFP_Float_ToWord16(42.0F) = 0x%04"PRIx16"U\n", __result);-}--void fromFP_Float_ToWord32_driver(void)-{-  const SWord32 __result = fromFP_Float_ToWord32(42.0F);--  printf("fromFP_Float_ToWord32(42.0F) = 0x%08"PRIx32"UL\n", __result);-}--void fromFP_Float_ToWord64_driver(void)-{-  const SWord64 __result = fromFP_Float_ToWord64(42.0F);--  printf("fromFP_Float_ToWord64(42.0F) = 0x%016"PRIx64"ULL\n", __result);-}--void fromFP_Float_ToFloat_driver(void)-{-  const SFloat __result = fromFP_Float_ToFloat(42.0F);--  printf("fromFP_Float_ToFloat(42.0F) = %.6g\n", __result);-}--void fromFP_Float_ToDouble_driver(void)-{-  const SDouble __result = fromFP_Float_ToDouble(42.0F);--  printf("fromFP_Float_ToDouble(42.0F) = %.15g\n", __result);-}--void fromFP_Float_ToInteger_driver(void)-{-  const SInteger __result = fromFP_Float_ToInteger(42.0F);--  printf("fromFP_Float_ToInteger(42.0F) = %"PRId64"LL\n", __result);-}--void fromFP_Float_ToReal_driver(void)-{-  const SReal __result = fromFP_Float_ToReal(42.0F);--  printf("fromFP_Float_ToReal(42.0F) = %Lf\n", __result);-}--void fromFP_DoubleTo_Int8_driver(void)-{-  const SInt8 __result = fromFP_DoubleTo_Int8(42.0);--  printf("fromFP_DoubleTo_Int8(42.0) = %"PRId8"\n", __result);-}--void fromFP_DoubleTo_Int16_driver(void)-{-  const SInt16 __result = fromFP_DoubleTo_Int16(42.0);--  printf("fromFP_DoubleTo_Int16(42.0) = %"PRId16"\n", __result);-}--void fromFP_DoubleTo_Int32_driver(void)-{-  const SInt32 __result = fromFP_DoubleTo_Int32(42.0);--  printf("fromFP_DoubleTo_Int32(42.0) = %"PRId32"L\n", __result);-}--void fromFP_DoubleTo_Int64_driver(void)-{-  const SInt64 __result = fromFP_DoubleTo_Int64(42.0);--  printf("fromFP_DoubleTo_Int64(42.0) = %"PRId64"LL\n", __result);-}--void fromFP_DoubleTo_Word8_driver(void)-{-  const SWord8 __result = fromFP_DoubleTo_Word8(42.0);--  printf("fromFP_DoubleTo_Word8(42.0) = %"PRIu8"\n", __result);-}--void fromFP_DoubleTo_Word16_driver(void)-{-  const SWord16 __result = fromFP_DoubleTo_Word16(42.0);--  printf("fromFP_DoubleTo_Word16(42.0) = 0x%04"PRIx16"U\n", __result);-}--void fromFP_DoubleTo_Word32_driver(void)-{-  const SWord32 __result = fromFP_DoubleTo_Word32(42.0);--  printf("fromFP_DoubleTo_Word32(42.0) = 0x%08"PRIx32"UL\n", __result);-}--void fromFP_DoubleTo_Word64_driver(void)-{-  const SWord64 __result = fromFP_DoubleTo_Word64(42.0);--  printf("fromFP_DoubleTo_Word64(42.0) = 0x%016"PRIx64"ULL\n", __result);-}--void fromFP_DoubleTo_Float_driver(void)-{-  const SFloat __result = fromFP_DoubleTo_Float(42.0);--  printf("fromFP_DoubleTo_Float(42.0) = %.6g\n", __result);-}--void fromFP_DoubleTo_Double_driver(void)-{-  const SDouble __result = fromFP_DoubleTo_Double(42.0);--  printf("fromFP_DoubleTo_Double(42.0) = %.15g\n", __result);-}--void fromFP_DoubleTo_Integer_driver(void)-{-  const SInteger __result = fromFP_DoubleTo_Integer(42.0);--  printf("fromFP_DoubleTo_Integer(42.0) = %"PRId64"LL\n", __result);-}--void fromFP_DoubleTo_Real_driver(void)-{-  const SReal __result = fromFP_DoubleTo_Real(42.0);--  printf("fromFP_DoubleTo_Real(42.0) = %Lf\n", __result);-}--void fromFP_SWord32_SFloat_driver(void)-{-  const SFloat __result = fromFP_SWord32_SFloat(0x0000002aUL);--  printf("fromFP_SWord32_SFloat(0x0000002aUL) = %.6g\n", __result);-}--void fromFP_SWord64_SDouble_driver(void)-{-  const SDouble __result = fromFP_SWord64_SDouble(0x000000000000002aULL);--  printf("fromFP_SWord64_SDouble(0x000000000000002aULL) = %.15g\n", __result);-}--void fromFP_SFloat_SWord32_driver(void)-{-  const SWord32 __result = fromFP_SFloat_SWord32(42.0F);--  printf("fromFP_SFloat_SWord32(42.0F) = 0x%08"PRIx32"UL\n", __result);-}--void fromFP_SDouble_SWord64_driver(void)-{-  const SWord64 __result = fromFP_SDouble_SWord64(42.0);--  printf("fromFP_SDouble_SWord64(42.0) = 0x%016"PRIx64"ULL\n", __result);-}--void f_FP_Abs_driver(void)-{-  const SFloat __result = f_FP_Abs(42.0F);--  printf("f_FP_Abs(42.0F) = %.6g\n", __result);-}--void d_FP_Abs_driver(void)-{-  const SDouble __result = d_FP_Abs(42.0);--  printf("d_FP_Abs(42.0) = %.15g\n", __result);-}--void f_FP_Neg_driver(void)-{-  const SFloat __result = f_FP_Neg(42.0F);--  printf("f_FP_Neg(42.0F) = %.6g\n", __result);-}--void d_FP_Neg_driver(void)-{-  const SDouble __result = d_FP_Neg(42.0);--  printf("d_FP_Neg(42.0) = %.15g\n", __result);-}--void f_FP_Add_driver(void)-{-  const SFloat __result = f_FP_Add(42.0F, 43.0F);--  printf("f_FP_Add(42.0F, 43.0F) = %.6g\n", __result);-}--void d_FP_Add_driver(void)-{-  const SDouble __result = d_FP_Add(42.0, 43.0);--  printf("d_FP_Add(42.0, 43.0) = %.15g\n", __result);-}--void f_FP_Sub_driver(void)-{-  const SFloat __result = f_FP_Sub(42.0F, 43.0F);--  printf("f_FP_Sub(42.0F, 43.0F) = %.6g\n", __result);-}--void d_FP_Sub_driver(void)-{-  const SDouble __result = d_FP_Sub(42.0, 43.0);--  printf("d_FP_Sub(42.0, 43.0) = %.15g\n", __result);-}--void f_FP_Mul_driver(void)-{-  const SFloat __result = f_FP_Mul(42.0F, 43.0F);--  printf("f_FP_Mul(42.0F, 43.0F) = %.6g\n", __result);-}--void d_FP_Mul_driver(void)-{-  const SDouble __result = d_FP_Mul(42.0, 43.0);--  printf("d_FP_Mul(42.0, 43.0) = %.15g\n", __result);-}--void f_FP_Div_driver(void)-{-  const SFloat __result = f_FP_Div(42.0F, 43.0F);--  printf("f_FP_Div(42.0F, 43.0F) = %.6g\n", __result);-}--void d_FP_Div_driver(void)-{-  const SDouble __result = d_FP_Div(42.0, 43.0);--  printf("d_FP_Div(42.0, 43.0) = %.15g\n", __result);-}--void f_FP_FMA_driver(void)-{-  const SFloat __result = f_FP_FMA(42.0F, 43.0F, 44.0F);--  printf("f_FP_FMA(42.0F, 43.0F, 44.0F) = %.6g\n", __result);-}--void d_FP_FMA_driver(void)-{-  const SDouble __result = d_FP_FMA(42.0, 43.0, 44.0);--  printf("d_FP_FMA(42.0, 43.0, 44.0) = %.15g\n", __result);-}--void f_FP_Sqrt_driver(void)-{-  const SFloat __result = f_FP_Sqrt(42.0F);--  printf("f_FP_Sqrt(42.0F) = %.6g\n", __result);-}--void d_FP_Sqrt_driver(void)-{-  const SDouble __result = d_FP_Sqrt(42.0);--  printf("d_FP_Sqrt(42.0) = %.15g\n", __result);-}--void f_FP_Rem_driver(void)-{-  const SFloat __result = f_FP_Rem(42.0F, 43.0F);--  printf("f_FP_Rem(42.0F, 43.0F) = %.6g\n", __result);-}--void d_FP_Rem_driver(void)-{-  const SDouble __result = d_FP_Rem(42.0, 43.0);--  printf("d_FP_Rem(42.0, 43.0) = %.15g\n", __result);-}--void f_FP_RoundToIntegral_driver(void)-{-  const SFloat __result = f_FP_RoundToIntegral(42.0F);--  printf("f_FP_RoundToIntegral(42.0F) = %.6g\n", __result);-}--void d_FP_RoundToIntegral_driver(void)-{-  const SDouble __result = d_FP_RoundToIntegral(42.0);--  printf("d_FP_RoundToIntegral(42.0) = %.15g\n", __result);-}--void f_FP_Min_driver(void)-{-  const SFloat __result = f_FP_Min(42.0F, 43.0F);--  printf("f_FP_Min(42.0F, 43.0F) = %.6g\n", __result);-}--void d_FP_Min_driver(void)-{-  const SDouble __result = d_FP_Min(42.0, 43.0);--  printf("d_FP_Min(42.0, 43.0) = %.15g\n", __result);-}--void f_FP_Max_driver(void)-{-  const SFloat __result = f_FP_Max(42.0F, 43.0F);--  printf("f_FP_Max(42.0F, 43.0F) = %.6g\n", __result);-}--void d_FP_Max_driver(void)-{-  const SDouble __result = d_FP_Max(42.0, 43.0);--  printf("d_FP_Max(42.0, 43.0) = %.15g\n", __result);-}--void f_FP_IsEqualObject_driver(void)-{-  const SBool __result = f_FP_IsEqualObject(42.0F, 43.0F);--  printf("f_FP_IsEqualObject(42.0F, 43.0F) = %d\n", __result);-}--void d_FP_IsEqualObject_driver(void)-{-  const SBool __result = d_FP_IsEqualObject(42.0, 43.0);--  printf("d_FP_IsEqualObject(42.0, 43.0) = %d\n", __result);-}--void f_FP_IsNormal_driver(void)-{-  const SBool __result = f_FP_IsNormal(42.0F);--  printf("f_FP_IsNormal(42.0F) = %d\n", __result);-}--void d_FP_IsNormal_driver(void)-{-  const SBool __result = d_FP_IsNormal(42.0);--  printf("d_FP_IsNormal(42.0) = %d\n", __result);-}--void f_FP_IsZero_driver(void)-{-  const SBool __result = f_FP_IsZero(42.0F);--  printf("f_FP_IsZero(42.0F) = %d\n", __result);-}--void d_FP_IsZero_driver(void)-{-  const SBool __result = d_FP_IsZero(42.0);--  printf("d_FP_IsZero(42.0) = %d\n", __result);-}--void f_FP_IsSubnormal_driver(void)-{-  const SBool __result = f_FP_IsSubnormal(42.0F);--  printf("f_FP_IsSubnormal(42.0F) = %d\n", __result);-}--void d_FP_IsSubnormal_driver(void)-{-  const SBool __result = d_FP_IsSubnormal(42.0);--  printf("d_FP_IsSubnormal(42.0) = %d\n", __result);-}--void f_FP_IsInfinite_driver(void)-{-  const SBool __result = f_FP_IsInfinite(42.0F);--  printf("f_FP_IsInfinite(42.0F) = %d\n", __result);-}--void d_FP_IsInfinite_driver(void)-{-  const SBool __result = d_FP_IsInfinite(42.0);--  printf("d_FP_IsInfinite(42.0) = %d\n", __result);-}--void f_FP_IsNaN_driver(void)-{-  const SBool __result = f_FP_IsNaN(42.0F);--  printf("f_FP_IsNaN(42.0F) = %d\n", __result);-}--void d_FP_IsNaN_driver(void)-{-  const SBool __result = d_FP_IsNaN(42.0);--  printf("d_FP_IsNaN(42.0) = %d\n", __result);-}--void f_FP_IsNegative_driver(void)-{-  const SBool __result = f_FP_IsNegative(42.0F);--  printf("f_FP_IsNegative(42.0F) = %d\n", __result);-}--void d_FP_IsNegative_driver(void)-{-  const SBool __result = d_FP_IsNegative(42.0);--  printf("d_FP_IsNegative(42.0) = %d\n", __result);-}--void f_FP_IsPositive_driver(void)-{-  const SBool __result = f_FP_IsPositive(42.0F);--  printf("f_FP_IsPositive(42.0F) = %d\n", __result);-}--void d_FP_IsPositive_driver(void)-{-  const SBool __result = d_FP_IsPositive(42.0);--  printf("d_FP_IsPositive(42.0) = %d\n", __result);-}--int main(void)-{-  printf("====================================\n");-  printf("** Driver run for toFP_Int8_ToFloat:\n");-  printf("====================================\n");-  toFP_Int8_ToFloat_driver();--  printf("=====================================\n");-  printf("** Driver run for toFP_Int16_ToFloat:\n");-  printf("=====================================\n");-  toFP_Int16_ToFloat_driver();--  printf("=====================================\n");-  printf("** Driver run for toFP_Int32_ToFloat:\n");-  printf("=====================================\n");-  toFP_Int32_ToFloat_driver();--  printf("=====================================\n");-  printf("** Driver run for toFP_Int64_ToFloat:\n");-  printf("=====================================\n");-  toFP_Int64_ToFloat_driver();--  printf("=====================================\n");-  printf("** Driver run for toFP_Word8_ToFloat:\n");-  printf("=====================================\n");-  toFP_Word8_ToFloat_driver();--  printf("======================================\n");-  printf("** Driver run for toFP_Word16_ToFloat:\n");-  printf("======================================\n");-  toFP_Word16_ToFloat_driver();--  printf("======================================\n");-  printf("** Driver run for toFP_Word32_ToFloat:\n");-  printf("======================================\n");-  toFP_Word32_ToFloat_driver();--  printf("======================================\n");-  printf("** Driver run for toFP_Word64_ToFloat:\n");-  printf("======================================\n");-  toFP_Word64_ToFloat_driver();--  printf("=====================================\n");-  printf("** Driver run for toFP_Float_ToFloat:\n");-  printf("=====================================\n");-  toFP_Float_ToFloat_driver();--  printf("======================================\n");-  printf("** Driver run for toFP_Double_ToFloat:\n");-  printf("======================================\n");-  toFP_Double_ToFloat_driver();--  printf("=======================================\n");-  printf("** Driver run for toFP_Integer_ToFloat:\n");-  printf("=======================================\n");-  toFP_Integer_ToFloat_driver();--  printf("====================================\n");-  printf("** Driver run for toFP_Real_ToFloat:\n");-  printf("====================================\n");-  toFP_Real_ToFloat_driver();--  printf("=====================================\n");-  printf("** Driver run for toFP_Int8_ToDouble:\n");-  printf("=====================================\n");-  toFP_Int8_ToDouble_driver();--  printf("======================================\n");-  printf("** Driver run for toFP_Int16_ToDouble:\n");-  printf("======================================\n");-  toFP_Int16_ToDouble_driver();--  printf("======================================\n");-  printf("** Driver run for toFP_Int32_ToDouble:\n");-  printf("======================================\n");-  toFP_Int32_ToDouble_driver();--  printf("======================================\n");-  printf("** Driver run for toFP_Int64_ToDouble:\n");-  printf("======================================\n");-  toFP_Int64_ToDouble_driver();--  printf("======================================\n");-  printf("** Driver run for toFP_Word8_ToDouble:\n");-  printf("======================================\n");-  toFP_Word8_ToDouble_driver();--  printf("=======================================\n");-  printf("** Driver run for toFP_Word16_ToDouble:\n");-  printf("=======================================\n");-  toFP_Word16_ToDouble_driver();--  printf("=======================================\n");-  printf("** Driver run for toFP_Word32_ToDouble:\n");-  printf("=======================================\n");-  toFP_Word32_ToDouble_driver();--  printf("=======================================\n");-  printf("** Driver run for toFP_Word64_ToDouble:\n");-  printf("=======================================\n");-  toFP_Word64_ToDouble_driver();--  printf("======================================\n");-  printf("** Driver run for toFP_Float_ToDouble:\n");-  printf("======================================\n");-  toFP_Float_ToDouble_driver();--  printf("=======================================\n");-  printf("** Driver run for toFP_Double_ToDouble:\n");-  printf("=======================================\n");-  toFP_Double_ToDouble_driver();--  printf("========================================\n");-  printf("** Driver run for toFP_Integer_ToDouble:\n");-  printf("========================================\n");-  toFP_Integer_ToDouble_driver();--  printf("=====================================\n");-  printf("** Driver run for toFP_Real_ToDouble:\n");-  printf("=====================================\n");-  toFP_Real_ToDouble_driver();--  printf("======================================\n");-  printf("** Driver run for fromFP_Float_ToInt8:\n");-  printf("======================================\n");-  fromFP_Float_ToInt8_driver();--  printf("=======================================\n");-  printf("** Driver run for fromFP_Float_ToInt16:\n");-  printf("=======================================\n");-  fromFP_Float_ToInt16_driver();--  printf("=======================================\n");-  printf("** Driver run for fromFP_Float_ToInt32:\n");-  printf("=======================================\n");-  fromFP_Float_ToInt32_driver();--  printf("=======================================\n");-  printf("** Driver run for fromFP_Float_ToInt64:\n");-  printf("=======================================\n");-  fromFP_Float_ToInt64_driver();--  printf("=======================================\n");-  printf("** Driver run for fromFP_Float_ToWord8:\n");-  printf("=======================================\n");-  fromFP_Float_ToWord8_driver();--  printf("========================================\n");-  printf("** Driver run for fromFP_Float_ToWord16:\n");-  printf("========================================\n");-  fromFP_Float_ToWord16_driver();--  printf("========================================\n");-  printf("** Driver run for fromFP_Float_ToWord32:\n");-  printf("========================================\n");-  fromFP_Float_ToWord32_driver();--  printf("========================================\n");-  printf("** Driver run for fromFP_Float_ToWord64:\n");-  printf("========================================\n");-  fromFP_Float_ToWord64_driver();--  printf("=======================================\n");-  printf("** Driver run for fromFP_Float_ToFloat:\n");-  printf("=======================================\n");-  fromFP_Float_ToFloat_driver();--  printf("========================================\n");-  printf("** Driver run for fromFP_Float_ToDouble:\n");-  printf("========================================\n");-  fromFP_Float_ToDouble_driver();--  printf("=========================================\n");-  printf("** Driver run for fromFP_Float_ToInteger:\n");-  printf("=========================================\n");-  fromFP_Float_ToInteger_driver();--  printf("======================================\n");-  printf("** Driver run for fromFP_Float_ToReal:\n");-  printf("======================================\n");-  fromFP_Float_ToReal_driver();--  printf("=======================================\n");-  printf("** Driver run for fromFP_DoubleTo_Int8:\n");-  printf("=======================================\n");-  fromFP_DoubleTo_Int8_driver();--  printf("========================================\n");-  printf("** Driver run for fromFP_DoubleTo_Int16:\n");-  printf("========================================\n");-  fromFP_DoubleTo_Int16_driver();--  printf("========================================\n");-  printf("** Driver run for fromFP_DoubleTo_Int32:\n");-  printf("========================================\n");-  fromFP_DoubleTo_Int32_driver();--  printf("========================================\n");-  printf("** Driver run for fromFP_DoubleTo_Int64:\n");-  printf("========================================\n");-  fromFP_DoubleTo_Int64_driver();--  printf("========================================\n");-  printf("** Driver run for fromFP_DoubleTo_Word8:\n");-  printf("========================================\n");-  fromFP_DoubleTo_Word8_driver();--  printf("=========================================\n");-  printf("** Driver run for fromFP_DoubleTo_Word16:\n");-  printf("=========================================\n");-  fromFP_DoubleTo_Word16_driver();--  printf("=========================================\n");-  printf("** Driver run for fromFP_DoubleTo_Word32:\n");-  printf("=========================================\n");-  fromFP_DoubleTo_Word32_driver();--  printf("=========================================\n");-  printf("** Driver run for fromFP_DoubleTo_Word64:\n");-  printf("=========================================\n");-  fromFP_DoubleTo_Word64_driver();--  printf("========================================\n");-  printf("** Driver run for fromFP_DoubleTo_Float:\n");-  printf("========================================\n");-  fromFP_DoubleTo_Float_driver();--  printf("=========================================\n");-  printf("** Driver run for fromFP_DoubleTo_Double:\n");-  printf("=========================================\n");-  fromFP_DoubleTo_Double_driver();--  printf("==========================================\n");-  printf("** Driver run for fromFP_DoubleTo_Integer:\n");-  printf("==========================================\n");-  fromFP_DoubleTo_Integer_driver();--  printf("=======================================\n");-  printf("** Driver run for fromFP_DoubleTo_Real:\n");-  printf("=======================================\n");-  fromFP_DoubleTo_Real_driver();--  printf("========================================\n");-  printf("** Driver run for fromFP_SWord32_SFloat:\n");-  printf("========================================\n");-  fromFP_SWord32_SFloat_driver();--  printf("=========================================\n");-  printf("** Driver run for fromFP_SWord64_SDouble:\n");-  printf("=========================================\n");-  fromFP_SWord64_SDouble_driver();--  printf("========================================\n");-  printf("** Driver run for fromFP_SFloat_SWord32:\n");-  printf("========================================\n");-  fromFP_SFloat_SWord32_driver();--  printf("=========================================\n");-  printf("** Driver run for fromFP_SDouble_SWord64:\n");-  printf("=========================================\n");-  fromFP_SDouble_SWord64_driver();--  printf("===========================\n");-  printf("** Driver run for f_FP_Abs:\n");-  printf("===========================\n");-  f_FP_Abs_driver();--  printf("===========================\n");-  printf("** Driver run for d_FP_Abs:\n");-  printf("===========================\n");-  d_FP_Abs_driver();--  printf("===========================\n");-  printf("** Driver run for f_FP_Neg:\n");-  printf("===========================\n");-  f_FP_Neg_driver();--  printf("===========================\n");-  printf("** Driver run for d_FP_Neg:\n");-  printf("===========================\n");-  d_FP_Neg_driver();--  printf("===========================\n");-  printf("** Driver run for f_FP_Add:\n");-  printf("===========================\n");-  f_FP_Add_driver();--  printf("===========================\n");-  printf("** Driver run for d_FP_Add:\n");-  printf("===========================\n");-  d_FP_Add_driver();--  printf("===========================\n");-  printf("** Driver run for f_FP_Sub:\n");-  printf("===========================\n");-  f_FP_Sub_driver();--  printf("===========================\n");-  printf("** Driver run for d_FP_Sub:\n");-  printf("===========================\n");-  d_FP_Sub_driver();--  printf("===========================\n");-  printf("** Driver run for f_FP_Mul:\n");-  printf("===========================\n");-  f_FP_Mul_driver();--  printf("===========================\n");-  printf("** Driver run for d_FP_Mul:\n");-  printf("===========================\n");-  d_FP_Mul_driver();--  printf("===========================\n");-  printf("** Driver run for f_FP_Div:\n");-  printf("===========================\n");-  f_FP_Div_driver();--  printf("===========================\n");-  printf("** Driver run for d_FP_Div:\n");-  printf("===========================\n");-  d_FP_Div_driver();--  printf("===========================\n");-  printf("** Driver run for f_FP_FMA:\n");-  printf("===========================\n");-  f_FP_FMA_driver();--  printf("===========================\n");-  printf("** Driver run for d_FP_FMA:\n");-  printf("===========================\n");-  d_FP_FMA_driver();--  printf("============================\n");-  printf("** Driver run for f_FP_Sqrt:\n");-  printf("============================\n");-  f_FP_Sqrt_driver();--  printf("============================\n");-  printf("** Driver run for d_FP_Sqrt:\n");-  printf("============================\n");-  d_FP_Sqrt_driver();--  printf("===========================\n");-  printf("** Driver run for f_FP_Rem:\n");-  printf("===========================\n");-  f_FP_Rem_driver();--  printf("===========================\n");-  printf("** Driver run for d_FP_Rem:\n");-  printf("===========================\n");-  d_FP_Rem_driver();--  printf("=======================================\n");-  printf("** Driver run for f_FP_RoundToIntegral:\n");-  printf("=======================================\n");-  f_FP_RoundToIntegral_driver();--  printf("=======================================\n");-  printf("** Driver run for d_FP_RoundToIntegral:\n");-  printf("=======================================\n");-  d_FP_RoundToIntegral_driver();--  printf("===========================\n");-  printf("** Driver run for f_FP_Min:\n");-  printf("===========================\n");-  f_FP_Min_driver();--  printf("===========================\n");-  printf("** Driver run for d_FP_Min:\n");-  printf("===========================\n");-  d_FP_Min_driver();--  printf("===========================\n");-  printf("** Driver run for f_FP_Max:\n");-  printf("===========================\n");-  f_FP_Max_driver();--  printf("===========================\n");-  printf("** Driver run for d_FP_Max:\n");-  printf("===========================\n");-  d_FP_Max_driver();--  printf("=====================================\n");-  printf("** Driver run for f_FP_IsEqualObject:\n");-  printf("=====================================\n");-  f_FP_IsEqualObject_driver();--  printf("=====================================\n");-  printf("** Driver run for d_FP_IsEqualObject:\n");-  printf("=====================================\n");-  d_FP_IsEqualObject_driver();--  printf("================================\n");-  printf("** Driver run for f_FP_IsNormal:\n");-  printf("================================\n");-  f_FP_IsNormal_driver();--  printf("================================\n");-  printf("** Driver run for d_FP_IsNormal:\n");-  printf("================================\n");-  d_FP_IsNormal_driver();--  printf("==============================\n");-  printf("** Driver run for f_FP_IsZero:\n");-  printf("==============================\n");-  f_FP_IsZero_driver();--  printf("==============================\n");-  printf("** Driver run for d_FP_IsZero:\n");-  printf("==============================\n");-  d_FP_IsZero_driver();--  printf("===================================\n");-  printf("** Driver run for f_FP_IsSubnormal:\n");-  printf("===================================\n");-  f_FP_IsSubnormal_driver();--  printf("===================================\n");-  printf("** Driver run for d_FP_IsSubnormal:\n");-  printf("===================================\n");-  d_FP_IsSubnormal_driver();--  printf("==================================\n");-  printf("** Driver run for f_FP_IsInfinite:\n");-  printf("==================================\n");-  f_FP_IsInfinite_driver();--  printf("==================================\n");-  printf("** Driver run for d_FP_IsInfinite:\n");-  printf("==================================\n");-  d_FP_IsInfinite_driver();--  printf("=============================\n");-  printf("** Driver run for f_FP_IsNaN:\n");-  printf("=============================\n");-  f_FP_IsNaN_driver();--  printf("=============================\n");-  printf("** Driver run for d_FP_IsNaN:\n");-  printf("=============================\n");-  d_FP_IsNaN_driver();--  printf("==================================\n");-  printf("** Driver run for f_FP_IsNegative:\n");-  printf("==================================\n");-  f_FP_IsNegative_driver();--  printf("==================================\n");-  printf("** Driver run for d_FP_IsNegative:\n");-  printf("==================================\n");-  d_FP_IsNegative_driver();--  printf("==================================\n");-  printf("** Driver run for f_FP_IsPositive:\n");-  printf("==================================\n");-  f_FP_IsPositive_driver();--  printf("==================================\n");-  printf("** Driver run for d_FP_IsPositive:\n");-  printf("==================================\n");-  d_FP_IsPositive_driver();--  return 0;-}-== END: "floatCodeGen_driver.c" ==================-== BEGIN: "Makefile" ================-# Makefile for floatCodeGen. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer-AR?=ar-ARFLAGS?=cr--all: floatCodeGen.a floatCodeGen_driver--floatCodeGen.a: toFP_Int8_ToFloat.o toFP_Int16_ToFloat.o toFP_Int32_ToFloat.o toFP_Int64_ToFloat.o toFP_Word8_ToFloat.o toFP_Word16_ToFloat.o toFP_Word32_ToFloat.o toFP_Word64_ToFloat.o toFP_Float_ToFloat.o toFP_Double_ToFloat.o toFP_Integer_ToFloat.o toFP_Real_ToFloat.o toFP_Int8_ToDouble.o toFP_Int16_ToDouble.o toFP_Int32_ToDouble.o toFP_Int64_ToDouble.o toFP_Word8_ToDouble.o toFP_Word16_ToDouble.o toFP_Word32_ToDouble.o toFP_Word64_ToDouble.o toFP_Float_ToDouble.o toFP_Double_ToDouble.o toFP_Integer_ToDouble.o toFP_Real_ToDouble.o fromFP_Float_ToInt8.o fromFP_Float_ToInt16.o fromFP_Float_ToInt32.o fromFP_Float_ToInt64.o fromFP_Float_ToWord8.o fromFP_Float_ToWord16.o fromFP_Float_ToWord32.o fromFP_Float_ToWord64.o fromFP_Float_ToFloat.o fromFP_Float_ToDouble.o fromFP_Float_ToInteger.o fromFP_Float_ToReal.o fromFP_DoubleTo_Int8.o fromFP_DoubleTo_Int16.o fromFP_DoubleTo_Int32.o fromFP_DoubleTo_Int64.o fromFP_DoubleTo_Word8.o fromFP_DoubleTo_Word16.o fromFP_DoubleTo_Word32.o fromFP_DoubleTo_Word64.o fromFP_DoubleTo_Float.o fromFP_DoubleTo_Double.o fromFP_DoubleTo_Integer.o fromFP_DoubleTo_Real.o fromFP_SWord32_SFloat.o fromFP_SWord64_SDouble.o fromFP_SFloat_SWord32.o fromFP_SDouble_SWord64.o f_FP_Abs.o d_FP_Abs.o f_FP_Neg.o d_FP_Neg.o f_FP_Add.o d_FP_Add.o f_FP_Sub.o d_FP_Sub.o f_FP_Mul.o d_FP_Mul.o f_FP_Div.o d_FP_Div.o f_FP_FMA.o d_FP_FMA.o f_FP_Sqrt.o d_FP_Sqrt.o f_FP_Rem.o d_FP_Rem.o f_FP_RoundToIntegral.o d_FP_RoundToIntegral.o f_FP_Min.o d_FP_Min.o f_FP_Max.o d_FP_Max.o f_FP_IsEqualObject.o d_FP_IsEqualObject.o f_FP_IsNormal.o d_FP_IsNormal.o f_FP_IsZero.o d_FP_IsZero.o f_FP_IsSubnormal.o d_FP_IsSubnormal.o f_FP_IsInfinite.o d_FP_IsInfinite.o f_FP_IsNaN.o d_FP_IsNaN.o f_FP_IsNegative.o d_FP_IsNegative.o f_FP_IsPositive.o d_FP_IsPositive.o-	${AR} ${ARFLAGS} $@ $^--floatCodeGen_driver: floatCodeGen_driver.c floatCodeGen.h-	${CC} ${CCFLAGS} $< -o $@ floatCodeGen.a--toFP_Int8_ToFloat.o: toFP_Int8_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Int16_ToFloat.o: toFP_Int16_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Int32_ToFloat.o: toFP_Int32_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Int64_ToFloat.o: toFP_Int64_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Word8_ToFloat.o: toFP_Word8_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Word16_ToFloat.o: toFP_Word16_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Word32_ToFloat.o: toFP_Word32_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Word64_ToFloat.o: toFP_Word64_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Float_ToFloat.o: toFP_Float_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Double_ToFloat.o: toFP_Double_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Integer_ToFloat.o: toFP_Integer_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Real_ToFloat.o: toFP_Real_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Int8_ToDouble.o: toFP_Int8_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Int16_ToDouble.o: toFP_Int16_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Int32_ToDouble.o: toFP_Int32_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Int64_ToDouble.o: toFP_Int64_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Word8_ToDouble.o: toFP_Word8_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Word16_ToDouble.o: toFP_Word16_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Word32_ToDouble.o: toFP_Word32_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Word64_ToDouble.o: toFP_Word64_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Float_ToDouble.o: toFP_Float_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Double_ToDouble.o: toFP_Double_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Integer_ToDouble.o: toFP_Integer_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--toFP_Real_ToDouble.o: toFP_Real_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToInt8.o: fromFP_Float_ToInt8.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToInt16.o: fromFP_Float_ToInt16.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToInt32.o: fromFP_Float_ToInt32.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToInt64.o: fromFP_Float_ToInt64.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToWord8.o: fromFP_Float_ToWord8.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToWord16.o: fromFP_Float_ToWord16.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToWord32.o: fromFP_Float_ToWord32.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToWord64.o: fromFP_Float_ToWord64.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToFloat.o: fromFP_Float_ToFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToDouble.o: fromFP_Float_ToDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToInteger.o: fromFP_Float_ToInteger.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_Float_ToReal.o: fromFP_Float_ToReal.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Int8.o: fromFP_DoubleTo_Int8.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Int16.o: fromFP_DoubleTo_Int16.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Int32.o: fromFP_DoubleTo_Int32.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Int64.o: fromFP_DoubleTo_Int64.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Word8.o: fromFP_DoubleTo_Word8.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Word16.o: fromFP_DoubleTo_Word16.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Word32.o: fromFP_DoubleTo_Word32.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Word64.o: fromFP_DoubleTo_Word64.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Float.o: fromFP_DoubleTo_Float.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Double.o: fromFP_DoubleTo_Double.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Integer.o: fromFP_DoubleTo_Integer.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_DoubleTo_Real.o: fromFP_DoubleTo_Real.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_SWord32_SFloat.o: fromFP_SWord32_SFloat.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_SWord64_SDouble.o: fromFP_SWord64_SDouble.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_SFloat_SWord32.o: fromFP_SFloat_SWord32.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--fromFP_SDouble_SWord64.o: fromFP_SDouble_SWord64.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_Abs.o: f_FP_Abs.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_Abs.o: d_FP_Abs.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_Neg.o: f_FP_Neg.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_Neg.o: d_FP_Neg.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_Add.o: f_FP_Add.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_Add.o: d_FP_Add.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_Sub.o: f_FP_Sub.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_Sub.o: d_FP_Sub.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_Mul.o: f_FP_Mul.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_Mul.o: d_FP_Mul.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_Div.o: f_FP_Div.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_Div.o: d_FP_Div.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_FMA.o: f_FP_FMA.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_FMA.o: d_FP_FMA.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_Sqrt.o: f_FP_Sqrt.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_Sqrt.o: d_FP_Sqrt.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_Rem.o: f_FP_Rem.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_Rem.o: d_FP_Rem.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_RoundToIntegral.o: f_FP_RoundToIntegral.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_RoundToIntegral.o: d_FP_RoundToIntegral.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_Min.o: f_FP_Min.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_Min.o: d_FP_Min.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_Max.o: f_FP_Max.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_Max.o: d_FP_Max.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_IsEqualObject.o: f_FP_IsEqualObject.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_IsEqualObject.o: d_FP_IsEqualObject.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_IsNormal.o: f_FP_IsNormal.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_IsNormal.o: d_FP_IsNormal.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_IsZero.o: f_FP_IsZero.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_IsZero.o: d_FP_IsZero.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_IsSubnormal.o: f_FP_IsSubnormal.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_IsSubnormal.o: d_FP_IsSubnormal.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_IsInfinite.o: f_FP_IsInfinite.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_IsInfinite.o: d_FP_IsInfinite.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_IsNaN.o: f_FP_IsNaN.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_IsNaN.o: d_FP_IsNaN.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_IsNegative.o: f_FP_IsNegative.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_IsNegative.o: d_FP_IsNegative.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--f_FP_IsPositive.o: f_FP_IsPositive.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--d_FP_IsPositive.o: d_FP_IsPositive.c floatCodeGen.h-	${CC} ${CCFLAGS} -c $< -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f floatCodeGen.a floatCodeGen_driver-== END: "Makefile" ==================
− SBVUnitTest/GoldFiles/gcd.gold 
@@ -1,141 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for sgcd. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: sgcd_driver--sgcd.o: sgcd.c sgcd.h-	${CC} ${CCFLAGS} -c $< -o $@--sgcd_driver.o: sgcd_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--sgcd_driver: sgcd.o sgcd_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f sgcd_driver-== END: "Makefile" ==================-== BEGIN: "sgcd.h" ================-/* Header file for sgcd. Automatically generated by SBV. Do not edit! */--#ifndef __sgcd__HEADER_INCLUDED__-#define __sgcd__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-SWord8 sgcd(const SWord8 x, const SWord8 y);--#endif /* __sgcd__HEADER_INCLUDED__ */-== END: "sgcd.h" ==================-== BEGIN: "sgcd_driver.c" ================-/* Example driver program for sgcd. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "sgcd.h"--int main(void)-{-  const SWord8 __result = sgcd(55, 154);--  printf("sgcd(55, 154) = %"PRIu8"\n", __result);--  return 0;-}-== END: "sgcd_driver.c" ==================-== BEGIN: "sgcd.c" ================-/* File: "sgcd.c". Automatically generated by SBV. Do not edit! */--#include "sgcd.h"--SWord8 sgcd(const SWord8 x, const SWord8 y)-{-  const SWord8 s0 = x;-  const SWord8 s1 = y;-  const SBool  s3 = s1 == 0;-  const SWord8 s4 = (s1 == 0) ? s0 : (s0 % s1);-  const SWord8 s5 = s3 ? s0 : s4;-  const SBool  s6 = 0 == s5;-  const SWord8 s7 = (s5 == 0) ? s1 : (s1 % s5);-  const SWord8 s8 = s6 ? s1 : s7;-  const SBool  s9 = 0 == s8;-  const SWord8 s10 = (s8 == 0) ? s5 : (s5 % s8);-  const SWord8 s11 = s9 ? s5 : s10;-  const SBool  s12 = 0 == s11;-  const SWord8 s13 = (s11 == 0) ? s8 : (s8 % s11);-  const SWord8 s14 = s12 ? s8 : s13;-  const SBool  s15 = 0 == s14;-  const SWord8 s16 = (s14 == 0) ? s11 : (s11 % s14);-  const SWord8 s17 = s15 ? s11 : s16;-  const SBool  s18 = 0 == s17;-  const SWord8 s19 = (s17 == 0) ? s14 : (s14 % s17);-  const SWord8 s20 = s18 ? s14 : s19;-  const SBool  s21 = 0 == s20;-  const SWord8 s22 = (s20 == 0) ? s17 : (s17 % s20);-  const SWord8 s23 = s21 ? s17 : s22;-  const SBool  s24 = 0 == s23;-  const SWord8 s25 = (s23 == 0) ? s20 : (s20 % s23);-  const SWord8 s26 = s24 ? s20 : s25;-  const SBool  s27 = 0 == s26;-  const SWord8 s28 = (s26 == 0) ? s23 : (s23 % s26);-  const SWord8 s29 = s27 ? s23 : s28;-  const SBool  s30 = 0 == s29;-  const SWord8 s31 = (s29 == 0) ? s26 : (s26 % s29);-  const SWord8 s32 = s30 ? s26 : s31;-  const SBool  s33 = 0 == s32;-  const SWord8 s34 = (s32 == 0) ? s29 : (s29 % s32);-  const SWord8 s35 = s33 ? s29 : s34;-  const SBool  s36 = 0 == s35;-  const SWord8 s37 = s36 ? s32 : s35;-  const SWord8 s38 = s33 ? s29 : s37;-  const SWord8 s39 = s30 ? s26 : s38;-  const SWord8 s40 = s27 ? s23 : s39;-  const SWord8 s41 = s24 ? s20 : s40;-  const SWord8 s42 = s21 ? s17 : s41;-  const SWord8 s43 = s18 ? s14 : s42;-  const SWord8 s44 = s15 ? s11 : s43;-  const SWord8 s45 = s12 ? s8 : s44;-  const SWord8 s46 = s9 ? s5 : s45;-  const SWord8 s47 = s6 ? s1 : s46;-  const SWord8 s48 = s3 ? s0 : s47;--  return s48;-}-== END: "sgcd.c" ==================
− SBVUnitTest/GoldFiles/higher-1.gold 
@@ -1,1 +0,0 @@-Q.E.D.
− SBVUnitTest/GoldFiles/higher-2.gold 
@@ -1,1 +0,0 @@-Q.E.D.
− SBVUnitTest/GoldFiles/higher-3.gold 
@@ -1,1 +0,0 @@-Q.E.D.
− SBVUnitTest/GoldFiles/higher-4.gold 
@@ -1,1 +0,0 @@-Q.E.D.
− SBVUnitTest/GoldFiles/higher-5.gold 
@@ -1,1 +0,0 @@-Q.E.D.
− SBVUnitTest/GoldFiles/higher-6.gold 
@@ -1,1 +0,0 @@-Q.E.D.
− SBVUnitTest/GoldFiles/higher-7.gold 
@@ -1,1 +0,0 @@-Q.E.D.
− SBVUnitTest/GoldFiles/higher-8.gold 
@@ -1,1 +0,0 @@-Q.E.D.
− SBVUnitTest/GoldFiles/higher-9.gold 
@@ -1,2 +0,0 @@-Falsifiable. Counter-example:-  s0 = 128 :: Word8
− SBVUnitTest/GoldFiles/iteTest1.gold 
@@ -1,16 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-CONSTRAINTS-ASSERTIONS-OUTPUTS
− SBVUnitTest/GoldFiles/iteTest2.gold 
@@ -1,16 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-CONSTRAINTS-ASSERTIONS-OUTPUTS
− SBVUnitTest/GoldFiles/iteTest3.gold 
@@ -1,16 +0,0 @@-INPUTS-  s0 :: SWord8, aliasing "x"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-CONSTRAINTS-ASSERTIONS-OUTPUTS
− SBVUnitTest/GoldFiles/legato.gold 
@@ -1,8958 +0,0 @@-INPUTS-  s0 :: SWord32, existential, aliasing "addrX"-  s1 :: SWord8, existential, aliasing "x"-  s2 :: SWord32, existential, aliasing "addrY"-  s3 :: SWord8, existential, aliasing "y"-  s4 :: SWord32, existential, aliasing "addrLow"-  s5 :: SWord8, existential, aliasing "regX"-  s6 :: SWord8, existential, aliasing "regA"-  s7 :: SWord8, existential, aliasing "memVals"-  s8 :: SBool, existential, aliasing "flagC"-  s9 :: SBool, existential, aliasing "flagZ"-CONSTANTS-  s_2 = False :: Bool-  s_1 = True :: Bool-  s15 = 0 :: Word1-  s13 = 0 :: Word8-  s20 = 128 :: Word8-  s22 = 127 :: Word8-  s12 = 256 :: Word16-TABLES-ARRAYS-UNINTERPRETED CONSTANTS-USER GIVEN CODE SEGMENTS-AXIOMS-TACTICS-GOALS-DEFINE-  s10 :: SBool = /= s0 s2 s4-  s11 :: SBool = ~ s10-  s14 :: SWord1 = choose [0:0] s1-  s16 :: SBool = s14 /= s15-  s17 :: SBool = s_2 == s16-  s18 :: SBool = s0 == s4-  s19 :: SWord8 = s1 >>> 1-  s21 :: SWord8 = s19 | s20-  s23 :: SWord8 = s19 & s22-  s24 :: SWord8 = if s8 then s21 else s23-  s25 :: SBool = s2 == s4-  s26 :: SWord8 = if s25 then s3 else s7-  s27 :: SWord8 = if s18 then s1 else s26-  s28 :: SWord8 = if s18 then s24 else s27-  s29 :: SWord8 = s28 >>> 1-  s30 :: SWord8 = s22 & s29-  s31 :: SWord8 = if s18 then s30 else s24-  s32 :: SWord1 = choose [0:0] s31-  s33 :: SBool = s15 /= s32-  s34 :: SBool = s_2 == s33-  s35 :: SWord8 = if s16 then s20 else s13-  s36 :: SWord1 = choose [0:0] s35-  s37 :: SBool = s15 /= s36-  s38 :: SWord1 = choose [0:0] s28-  s39 :: SBool = s15 /= s38-  s40 :: SWord8 = s31 >>> 1-  s41 :: SWord8 = s20 | s40-  s42 :: SWord8 = s22 & s40-  s43 :: SWord8 = if s39 then s41 else s42-  s44 :: SWord8 = if s18 then s43 else s30-  s45 :: SWord8 = s44 >>> 1-  s46 :: SWord8 = s20 | s45-  s47 :: SWord8 = s22 & s45-  s48 :: SWord8 = if s37 then s46 else s47-  s49 :: SWord8 = if s18 then s48 else s43-  s50 :: SWord1 = choose [0:0] s49-  s51 :: SBool = s15 /= s50-  s52 :: SBool = s_2 == s51-  s53 :: SWord8 = s35 >>> 1-  s54 :: SWord8 = s20 | s53-  s55 :: SWord8 = s22 & s53-  s56 :: SWord8 = if s33 then s54 else s55-  s57 :: SWord1 = choose [0:0] s56-  s58 :: SBool = s15 /= s57-  s59 :: SWord1 = choose [0:0] s44-  s60 :: SBool = s15 /= s59-  s61 :: SWord8 = s49 >>> 1-  s62 :: SWord8 = s20 | s61-  s63 :: SWord8 = s22 & s61-  s64 :: SWord8 = if s60 then s62 else s63-  s65 :: SWord8 = if s18 then s64 else s48-  s66 :: SWord8 = s65 >>> 1-  s67 :: SWord8 = s20 | s66-  s68 :: SWord8 = s22 & s66-  s69 :: SWord8 = if s58 then s67 else s68-  s70 :: SWord8 = if s18 then s69 else s64-  s71 :: SWord1 = choose [0:0] s70-  s72 :: SBool = s15 /= s71-  s73 :: SBool = s_2 == s72-  s74 :: SWord8 = s56 >>> 1-  s75 :: SWord8 = s20 | s74-  s76 :: SWord8 = s22 & s74-  s77 :: SWord8 = if s51 then s75 else s76-  s78 :: SWord1 = choose [0:0] s77-  s79 :: SBool = s15 /= s78-  s80 :: SWord1 = choose [0:0] s65-  s81 :: SBool = s15 /= s80-  s82 :: SWord8 = s70 >>> 1-  s83 :: SWord8 = s20 | s82-  s84 :: SWord8 = s22 & s82-  s85 :: SWord8 = if s81 then s83 else s84-  s86 :: SWord8 = if s18 then s85 else s69-  s87 :: SWord8 = s86 >>> 1-  s88 :: SWord8 = s20 | s87-  s89 :: SWord8 = s22 & s87-  s90 :: SWord8 = if s79 then s88 else s89-  s91 :: SWord8 = if s18 then s90 else s85-  s92 :: SWord1 = choose [0:0] s91-  s93 :: SBool = s15 /= s92-  s94 :: SBool = s_2 == s93-  s95 :: SWord8 = s77 >>> 1-  s96 :: SWord8 = s20 | s95-  s97 :: SWord8 = s22 & s95-  s98 :: SWord8 = if s72 then s96 else s97-  s99 :: SWord1 = choose [0:0] s98-  s100 :: SBool = s15 /= s99-  s101 :: SWord1 = choose [0:0] s86-  s102 :: SBool = s15 /= s101-  s103 :: SWord8 = s91 >>> 1-  s104 :: SWord8 = s20 | s103-  s105 :: SWord8 = s22 & s103-  s106 :: SWord8 = if s102 then s104 else s105-  s107 :: SWord8 = if s18 then s106 else s90-  s108 :: SWord8 = s107 >>> 1-  s109 :: SWord8 = s20 | s108-  s110 :: SWord8 = s22 & s108-  s111 :: SWord8 = if s100 then s109 else s110-  s112 :: SWord8 = if s18 then s111 else s106-  s113 :: SWord1 = choose [0:0] s112-  s114 :: SBool = s15 /= s113-  s115 :: SBool = s_2 == s114-  s116 :: SWord8 = s98 >>> 1-  s117 :: SWord8 = s20 | s116-  s118 :: SWord8 = s22 & s116-  s119 :: SWord8 = if s93 then s117 else s118-  s120 :: SWord1 = choose [0:0] s119-  s121 :: SBool = s15 /= s120-  s122 :: SWord1 = choose [0:0] s107-  s123 :: SBool = s15 /= s122-  s124 :: SWord8 = s112 >>> 1-  s125 :: SWord8 = s20 | s124-  s126 :: SWord8 = s22 & s124-  s127 :: SWord8 = if s123 then s125 else s126-  s128 :: SWord8 = if s18 then s127 else s111-  s129 :: SWord8 = s128 >>> 1-  s130 :: SWord8 = s20 | s129-  s131 :: SWord8 = s22 & s129-  s132 :: SWord8 = if s121 then s130 else s131-  s133 :: SWord8 = if s18 then s132 else s127-  s134 :: SWord1 = choose [0:0] s133-  s135 :: SBool = s15 /= s134-  s136 :: SBool = s_2 == s135-  s137 :: SWord8 = s119 >>> 1-  s138 :: SWord8 = s20 | s137-  s139 :: SWord8 = s22 & s137-  s140 :: SWord8 = if s114 then s138 else s139-  s141 :: SWord1 = choose [0:0] s140-  s142 :: SBool = s15 /= s141-  s143 :: SWord1 = choose [0:0] s128-  s144 :: SBool = s15 /= s143-  s145 :: SWord8 = s133 >>> 1-  s146 :: SWord8 = s20 | s145-  s147 :: SWord8 = s22 & s145-  s148 :: SWord8 = if s144 then s146 else s147-  s149 :: SWord8 = if s18 then s148 else s132-  s150 :: SWord8 = s149 >>> 1-  s151 :: SWord8 = s20 | s150-  s152 :: SWord8 = s22 & s150-  s153 :: SWord8 = if s142 then s151 else s152-  s154 :: SWord8 = if s18 then s153 else s148-  s155 :: SWord1 = choose [0:0] s154-  s156 :: SBool = s15 /= s155-  s157 :: SBool = s_2 == s156-  s158 :: SWord8 = s140 >>> 1-  s159 :: SWord8 = s20 | s158-  s160 :: SWord8 = s22 & s158-  s161 :: SWord8 = if s135 then s159 else s160-  s162 :: SWord8 = s161 >>> 1-  s163 :: SWord8 = s20 | s162-  s164 :: SWord8 = s22 & s162-  s165 :: SWord8 = if s156 then s163 else s164-  s166 :: SBool = s0 == s2-  s167 :: SWord1 = choose [0:0] s149-  s168 :: SBool = s15 /= s167-  s169 :: SWord8 = s154 >>> 1-  s170 :: SWord8 = s20 | s169-  s171 :: SWord8 = s22 & s169-  s172 :: SWord8 = if s168 then s170 else s171-  s173 :: SWord8 = if s166 then s1 else s3-  s174 :: SWord8 = if s166 then s24 else s173-  s175 :: SWord8 = if s25 then s30 else s174-  s176 :: SWord8 = if s166 then s43 else s175-  s177 :: SWord8 = if s25 then s48 else s176-  s178 :: SWord8 = if s166 then s64 else s177-  s179 :: SWord8 = if s25 then s69 else s178-  s180 :: SWord8 = if s166 then s85 else s179-  s181 :: SWord8 = if s25 then s90 else s180-  s182 :: SWord8 = if s166 then s106 else s181-  s183 :: SWord8 = if s25 then s111 else s182-  s184 :: SWord8 = if s166 then s127 else s183-  s185 :: SWord8 = if s25 then s132 else s184-  s186 :: SWord8 = if s166 then s148 else s185-  s187 :: SWord8 = if s25 then s153 else s186-  s188 :: SWord8 = if s166 then s172 else s187-  s189 :: SWord8 = s161 + s188-  s190 :: SBool = s189 < s188-  s191 :: SBool = s189 < s161-  s192 :: SBool = s190 | s191-  s193 :: SWord8 = s189 >>> 1-  s194 :: SWord8 = s20 | s193-  s195 :: SWord8 = s22 & s193-  s196 :: SWord8 = if s192 then s194 else s195-  s197 :: SWord8 = if s157 then s165 else s196-  s198 :: SWord8 = s140 + s186-  s199 :: SWord1 = choose [0:0] s198-  s200 :: SBool = s15 /= s199-  s201 :: SWord8 = if s200 then s151 else s152-  s202 :: SWord8 = if s18 then s201 else s148-  s203 :: SWord1 = choose [0:0] s202-  s204 :: SBool = s15 /= s203-  s205 :: SBool = s_2 == s204-  s206 :: SBool = s198 < s186-  s207 :: SBool = s198 < s140-  s208 :: SBool = s206 | s207-  s209 :: SWord8 = s198 >>> 1-  s210 :: SWord8 = s20 | s209-  s211 :: SWord8 = s22 & s209-  s212 :: SWord8 = if s208 then s210 else s211-  s213 :: SWord8 = s212 >>> 1-  s214 :: SWord8 = s20 | s213-  s215 :: SWord8 = s22 & s213-  s216 :: SWord8 = if s204 then s214 else s215-  s217 :: SWord8 = s202 >>> 1-  s218 :: SWord8 = s20 | s217-  s219 :: SWord8 = s22 & s217-  s220 :: SWord8 = if s168 then s218 else s219-  s221 :: SWord8 = if s25 then s201 else s186-  s222 :: SWord8 = if s166 then s220 else s221-  s223 :: SWord8 = s212 + s222-  s224 :: SBool = s223 < s222-  s225 :: SBool = s223 < s212-  s226 :: SBool = s224 | s225-  s227 :: SWord8 = s223 >>> 1-  s228 :: SWord8 = s20 | s227-  s229 :: SWord8 = s22 & s227-  s230 :: SWord8 = if s226 then s228 else s229-  s231 :: SWord8 = if s205 then s216 else s230-  s232 :: SWord8 = if s136 then s197 else s231-  s233 :: SWord8 = s119 + s184-  s234 :: SWord1 = choose [0:0] s233-  s235 :: SBool = s15 /= s234-  s236 :: SWord8 = if s235 then s130 else s131-  s237 :: SWord8 = if s18 then s236 else s127-  s238 :: SWord1 = choose [0:0] s237-  s239 :: SBool = s15 /= s238-  s240 :: SBool = s_2 == s239-  s241 :: SBool = s233 < s184-  s242 :: SBool = s233 < s119-  s243 :: SBool = s241 | s242-  s244 :: SWord8 = s233 >>> 1-  s245 :: SWord8 = s20 | s244-  s246 :: SWord8 = s22 & s244-  s247 :: SWord8 = if s243 then s245 else s246-  s248 :: SWord1 = choose [0:0] s247-  s249 :: SBool = s15 /= s248-  s250 :: SWord8 = s237 >>> 1-  s251 :: SWord8 = s20 | s250-  s252 :: SWord8 = s22 & s250-  s253 :: SWord8 = if s144 then s251 else s252-  s254 :: SWord8 = if s18 then s253 else s236-  s255 :: SWord8 = s254 >>> 1-  s256 :: SWord8 = s20 | s255-  s257 :: SWord8 = s22 & s255-  s258 :: SWord8 = if s249 then s256 else s257-  s259 :: SWord8 = if s18 then s258 else s253-  s260 :: SWord1 = choose [0:0] s259-  s261 :: SBool = s15 /= s260-  s262 :: SBool = s_2 == s261-  s263 :: SWord8 = s247 >>> 1-  s264 :: SWord8 = s20 | s263-  s265 :: SWord8 = s22 & s263-  s266 :: SWord8 = if s239 then s264 else s265-  s267 :: SWord8 = s266 >>> 1-  s268 :: SWord8 = s20 | s267-  s269 :: SWord8 = s22 & s267-  s270 :: SWord8 = if s261 then s268 else s269-  s271 :: SWord1 = choose [0:0] s254-  s272 :: SBool = s15 /= s271-  s273 :: SWord8 = s259 >>> 1-  s274 :: SWord8 = s20 | s273-  s275 :: SWord8 = s22 & s273-  s276 :: SWord8 = if s272 then s274 else s275-  s277 :: SWord8 = if s25 then s236 else s184-  s278 :: SWord8 = if s166 then s253 else s277-  s279 :: SWord8 = if s25 then s258 else s278-  s280 :: SWord8 = if s166 then s276 else s279-  s281 :: SWord8 = s266 + s280-  s282 :: SBool = s281 < s280-  s283 :: SBool = s281 < s266-  s284 :: SBool = s282 | s283-  s285 :: SWord8 = s281 >>> 1-  s286 :: SWord8 = s20 | s285-  s287 :: SWord8 = s22 & s285-  s288 :: SWord8 = if s284 then s286 else s287-  s289 :: SWord8 = if s262 then s270 else s288-  s290 :: SWord8 = s247 + s278-  s291 :: SWord1 = choose [0:0] s290-  s292 :: SBool = s15 /= s291-  s293 :: SWord8 = if s292 then s256 else s257-  s294 :: SWord8 = if s18 then s293 else s253-  s295 :: SWord1 = choose [0:0] s294-  s296 :: SBool = s15 /= s295-  s297 :: SBool = s_2 == s296-  s298 :: SBool = s290 < s278-  s299 :: SBool = s290 < s247-  s300 :: SBool = s298 | s299-  s301 :: SWord8 = s290 >>> 1-  s302 :: SWord8 = s20 | s301-  s303 :: SWord8 = s22 & s301-  s304 :: SWord8 = if s300 then s302 else s303-  s305 :: SWord8 = s304 >>> 1-  s306 :: SWord8 = s20 | s305-  s307 :: SWord8 = s22 & s305-  s308 :: SWord8 = if s296 then s306 else s307-  s309 :: SWord8 = s294 >>> 1-  s310 :: SWord8 = s20 | s309-  s311 :: SWord8 = s22 & s309-  s312 :: SWord8 = if s272 then s310 else s311-  s313 :: SWord8 = if s25 then s293 else s278-  s314 :: SWord8 = if s166 then s312 else s313-  s315 :: SWord8 = s304 + s314-  s316 :: SBool = s315 < s314-  s317 :: SBool = s315 < s304-  s318 :: SBool = s316 | s317-  s319 :: SWord8 = s315 >>> 1-  s320 :: SWord8 = s20 | s319-  s321 :: SWord8 = s22 & s319-  s322 :: SWord8 = if s318 then s320 else s321-  s323 :: SWord8 = if s297 then s308 else s322-  s324 :: SWord8 = if s240 then s289 else s323-  s325 :: SWord8 = if s115 then s232 else s324-  s326 :: SWord8 = s98 + s182-  s327 :: SWord1 = choose [0:0] s326-  s328 :: SBool = s15 /= s327-  s329 :: SWord8 = if s328 then s109 else s110-  s330 :: SWord8 = if s18 then s329 else s106-  s331 :: SWord1 = choose [0:0] s330-  s332 :: SBool = s15 /= s331-  s333 :: SBool = s_2 == s332-  s334 :: SBool = s326 < s182-  s335 :: SBool = s326 < s98-  s336 :: SBool = s334 | s335-  s337 :: SWord8 = s326 >>> 1-  s338 :: SWord8 = s20 | s337-  s339 :: SWord8 = s22 & s337-  s340 :: SWord8 = if s336 then s338 else s339-  s341 :: SWord1 = choose [0:0] s340-  s342 :: SBool = s15 /= s341-  s343 :: SWord8 = s330 >>> 1-  s344 :: SWord8 = s20 | s343-  s345 :: SWord8 = s22 & s343-  s346 :: SWord8 = if s123 then s344 else s345-  s347 :: SWord8 = if s18 then s346 else s329-  s348 :: SWord8 = s347 >>> 1-  s349 :: SWord8 = s20 | s348-  s350 :: SWord8 = s22 & s348-  s351 :: SWord8 = if s342 then s349 else s350-  s352 :: SWord8 = if s18 then s351 else s346-  s353 :: SWord1 = choose [0:0] s352-  s354 :: SBool = s15 /= s353-  s355 :: SBool = s_2 == s354-  s356 :: SWord8 = s340 >>> 1-  s357 :: SWord8 = s20 | s356-  s358 :: SWord8 = s22 & s356-  s359 :: SWord8 = if s332 then s357 else s358-  s360 :: SWord1 = choose [0:0] s359-  s361 :: SBool = s15 /= s360-  s362 :: SWord1 = choose [0:0] s347-  s363 :: SBool = s15 /= s362-  s364 :: SWord8 = s352 >>> 1-  s365 :: SWord8 = s20 | s364-  s366 :: SWord8 = s22 & s364-  s367 :: SWord8 = if s363 then s365 else s366-  s368 :: SWord8 = if s18 then s367 else s351-  s369 :: SWord8 = s368 >>> 1-  s370 :: SWord8 = s20 | s369-  s371 :: SWord8 = s22 & s369-  s372 :: SWord8 = if s361 then s370 else s371-  s373 :: SWord8 = if s18 then s372 else s367-  s374 :: SWord1 = choose [0:0] s373-  s375 :: SBool = s15 /= s374-  s376 :: SBool = s_2 == s375-  s377 :: SWord8 = s359 >>> 1-  s378 :: SWord8 = s20 | s377-  s379 :: SWord8 = s22 & s377-  s380 :: SWord8 = if s354 then s378 else s379-  s381 :: SWord8 = s380 >>> 1-  s382 :: SWord8 = s20 | s381-  s383 :: SWord8 = s22 & s381-  s384 :: SWord8 = if s375 then s382 else s383-  s385 :: SWord1 = choose [0:0] s368-  s386 :: SBool = s15 /= s385-  s387 :: SWord8 = s373 >>> 1-  s388 :: SWord8 = s20 | s387-  s389 :: SWord8 = s22 & s387-  s390 :: SWord8 = if s386 then s388 else s389-  s391 :: SWord8 = if s25 then s329 else s182-  s392 :: SWord8 = if s166 then s346 else s391-  s393 :: SWord8 = if s25 then s351 else s392-  s394 :: SWord8 = if s166 then s367 else s393-  s395 :: SWord8 = if s25 then s372 else s394-  s396 :: SWord8 = if s166 then s390 else s395-  s397 :: SWord8 = s380 + s396-  s398 :: SBool = s397 < s396-  s399 :: SBool = s397 < s380-  s400 :: SBool = s398 | s399-  s401 :: SWord8 = s397 >>> 1-  s402 :: SWord8 = s20 | s401-  s403 :: SWord8 = s22 & s401-  s404 :: SWord8 = if s400 then s402 else s403-  s405 :: SWord8 = if s376 then s384 else s404-  s406 :: SWord8 = s359 + s394-  s407 :: SWord1 = choose [0:0] s406-  s408 :: SBool = s15 /= s407-  s409 :: SWord8 = if s408 then s370 else s371-  s410 :: SWord8 = if s18 then s409 else s367-  s411 :: SWord1 = choose [0:0] s410-  s412 :: SBool = s15 /= s411-  s413 :: SBool = s_2 == s412-  s414 :: SBool = s406 < s394-  s415 :: SBool = s406 < s359-  s416 :: SBool = s414 | s415-  s417 :: SWord8 = s406 >>> 1-  s418 :: SWord8 = s20 | s417-  s419 :: SWord8 = s22 & s417-  s420 :: SWord8 = if s416 then s418 else s419-  s421 :: SWord8 = s420 >>> 1-  s422 :: SWord8 = s20 | s421-  s423 :: SWord8 = s22 & s421-  s424 :: SWord8 = if s412 then s422 else s423-  s425 :: SWord8 = s410 >>> 1-  s426 :: SWord8 = s20 | s425-  s427 :: SWord8 = s22 & s425-  s428 :: SWord8 = if s386 then s426 else s427-  s429 :: SWord8 = if s25 then s409 else s394-  s430 :: SWord8 = if s166 then s428 else s429-  s431 :: SWord8 = s420 + s430-  s432 :: SBool = s431 < s430-  s433 :: SBool = s431 < s420-  s434 :: SBool = s432 | s433-  s435 :: SWord8 = s431 >>> 1-  s436 :: SWord8 = s20 | s435-  s437 :: SWord8 = s22 & s435-  s438 :: SWord8 = if s434 then s436 else s437-  s439 :: SWord8 = if s413 then s424 else s438-  s440 :: SWord8 = if s355 then s405 else s439-  s441 :: SWord8 = s340 + s392-  s442 :: SWord1 = choose [0:0] s441-  s443 :: SBool = s15 /= s442-  s444 :: SWord8 = if s443 then s349 else s350-  s445 :: SWord8 = if s18 then s444 else s346-  s446 :: SWord1 = choose [0:0] s445-  s447 :: SBool = s15 /= s446-  s448 :: SBool = s_2 == s447-  s449 :: SBool = s441 < s392-  s450 :: SBool = s441 < s340-  s451 :: SBool = s449 | s450-  s452 :: SWord8 = s441 >>> 1-  s453 :: SWord8 = s20 | s452-  s454 :: SWord8 = s22 & s452-  s455 :: SWord8 = if s451 then s453 else s454-  s456 :: SWord1 = choose [0:0] s455-  s457 :: SBool = s15 /= s456-  s458 :: SWord8 = s445 >>> 1-  s459 :: SWord8 = s20 | s458-  s460 :: SWord8 = s22 & s458-  s461 :: SWord8 = if s363 then s459 else s460-  s462 :: SWord8 = if s18 then s461 else s444-  s463 :: SWord8 = s462 >>> 1-  s464 :: SWord8 = s20 | s463-  s465 :: SWord8 = s22 & s463-  s466 :: SWord8 = if s457 then s464 else s465-  s467 :: SWord8 = if s18 then s466 else s461-  s468 :: SWord1 = choose [0:0] s467-  s469 :: SBool = s15 /= s468-  s470 :: SBool = s_2 == s469-  s471 :: SWord8 = s455 >>> 1-  s472 :: SWord8 = s20 | s471-  s473 :: SWord8 = s22 & s471-  s474 :: SWord8 = if s447 then s472 else s473-  s475 :: SWord8 = s474 >>> 1-  s476 :: SWord8 = s20 | s475-  s477 :: SWord8 = s22 & s475-  s478 :: SWord8 = if s469 then s476 else s477-  s479 :: SWord1 = choose [0:0] s462-  s480 :: SBool = s15 /= s479-  s481 :: SWord8 = s467 >>> 1-  s482 :: SWord8 = s20 | s481-  s483 :: SWord8 = s22 & s481-  s484 :: SWord8 = if s480 then s482 else s483-  s485 :: SWord8 = if s25 then s444 else s392-  s486 :: SWord8 = if s166 then s461 else s485-  s487 :: SWord8 = if s25 then s466 else s486-  s488 :: SWord8 = if s166 then s484 else s487-  s489 :: SWord8 = s474 + s488-  s490 :: SBool = s489 < s488-  s491 :: SBool = s489 < s474-  s492 :: SBool = s490 | s491-  s493 :: SWord8 = s489 >>> 1-  s494 :: SWord8 = s20 | s493-  s495 :: SWord8 = s22 & s493-  s496 :: SWord8 = if s492 then s494 else s495-  s497 :: SWord8 = if s470 then s478 else s496-  s498 :: SWord8 = s455 + s486-  s499 :: SWord1 = choose [0:0] s498-  s500 :: SBool = s15 /= s499-  s501 :: SWord8 = if s500 then s464 else s465-  s502 :: SWord8 = if s18 then s501 else s461-  s503 :: SWord1 = choose [0:0] s502-  s504 :: SBool = s15 /= s503-  s505 :: SBool = s_2 == s504-  s506 :: SBool = s498 < s486-  s507 :: SBool = s498 < s455-  s508 :: SBool = s506 | s507-  s509 :: SWord8 = s498 >>> 1-  s510 :: SWord8 = s20 | s509-  s511 :: SWord8 = s22 & s509-  s512 :: SWord8 = if s508 then s510 else s511-  s513 :: SWord8 = s512 >>> 1-  s514 :: SWord8 = s20 | s513-  s515 :: SWord8 = s22 & s513-  s516 :: SWord8 = if s504 then s514 else s515-  s517 :: SWord8 = s502 >>> 1-  s518 :: SWord8 = s20 | s517-  s519 :: SWord8 = s22 & s517-  s520 :: SWord8 = if s480 then s518 else s519-  s521 :: SWord8 = if s25 then s501 else s486-  s522 :: SWord8 = if s166 then s520 else s521-  s523 :: SWord8 = s512 + s522-  s524 :: SBool = s523 < s522-  s525 :: SBool = s523 < s512-  s526 :: SBool = s524 | s525-  s527 :: SWord8 = s523 >>> 1-  s528 :: SWord8 = s20 | s527-  s529 :: SWord8 = s22 & s527-  s530 :: SWord8 = if s526 then s528 else s529-  s531 :: SWord8 = if s505 then s516 else s530-  s532 :: SWord8 = if s448 then s497 else s531-  s533 :: SWord8 = if s333 then s440 else s532-  s534 :: SWord8 = if s94 then s325 else s533-  s535 :: SWord8 = s77 + s180-  s536 :: SWord1 = choose [0:0] s535-  s537 :: SBool = s15 /= s536-  s538 :: SWord8 = if s537 then s88 else s89-  s539 :: SWord8 = if s18 then s538 else s85-  s540 :: SWord1 = choose [0:0] s539-  s541 :: SBool = s15 /= s540-  s542 :: SBool = s_2 == s541-  s543 :: SBool = s535 < s180-  s544 :: SBool = s535 < s77-  s545 :: SBool = s543 | s544-  s546 :: SWord8 = s535 >>> 1-  s547 :: SWord8 = s20 | s546-  s548 :: SWord8 = s22 & s546-  s549 :: SWord8 = if s545 then s547 else s548-  s550 :: SWord1 = choose [0:0] s549-  s551 :: SBool = s15 /= s550-  s552 :: SWord8 = s539 >>> 1-  s553 :: SWord8 = s20 | s552-  s554 :: SWord8 = s22 & s552-  s555 :: SWord8 = if s102 then s553 else s554-  s556 :: SWord8 = if s18 then s555 else s538-  s557 :: SWord8 = s556 >>> 1-  s558 :: SWord8 = s20 | s557-  s559 :: SWord8 = s22 & s557-  s560 :: SWord8 = if s551 then s558 else s559-  s561 :: SWord8 = if s18 then s560 else s555-  s562 :: SWord1 = choose [0:0] s561-  s563 :: SBool = s15 /= s562-  s564 :: SBool = s_2 == s563-  s565 :: SWord8 = s549 >>> 1-  s566 :: SWord8 = s20 | s565-  s567 :: SWord8 = s22 & s565-  s568 :: SWord8 = if s541 then s566 else s567-  s569 :: SWord1 = choose [0:0] s568-  s570 :: SBool = s15 /= s569-  s571 :: SWord1 = choose [0:0] s556-  s572 :: SBool = s15 /= s571-  s573 :: SWord8 = s561 >>> 1-  s574 :: SWord8 = s20 | s573-  s575 :: SWord8 = s22 & s573-  s576 :: SWord8 = if s572 then s574 else s575-  s577 :: SWord8 = if s18 then s576 else s560-  s578 :: SWord8 = s577 >>> 1-  s579 :: SWord8 = s20 | s578-  s580 :: SWord8 = s22 & s578-  s581 :: SWord8 = if s570 then s579 else s580-  s582 :: SWord8 = if s18 then s581 else s576-  s583 :: SWord1 = choose [0:0] s582-  s584 :: SBool = s15 /= s583-  s585 :: SBool = s_2 == s584-  s586 :: SWord8 = s568 >>> 1-  s587 :: SWord8 = s20 | s586-  s588 :: SWord8 = s22 & s586-  s589 :: SWord8 = if s563 then s587 else s588-  s590 :: SWord1 = choose [0:0] s589-  s591 :: SBool = s15 /= s590-  s592 :: SWord1 = choose [0:0] s577-  s593 :: SBool = s15 /= s592-  s594 :: SWord8 = s582 >>> 1-  s595 :: SWord8 = s20 | s594-  s596 :: SWord8 = s22 & s594-  s597 :: SWord8 = if s593 then s595 else s596-  s598 :: SWord8 = if s18 then s597 else s581-  s599 :: SWord8 = s598 >>> 1-  s600 :: SWord8 = s20 | s599-  s601 :: SWord8 = s22 & s599-  s602 :: SWord8 = if s591 then s600 else s601-  s603 :: SWord8 = if s18 then s602 else s597-  s604 :: SWord1 = choose [0:0] s603-  s605 :: SBool = s15 /= s604-  s606 :: SBool = s_2 == s605-  s607 :: SWord8 = s589 >>> 1-  s608 :: SWord8 = s20 | s607-  s609 :: SWord8 = s22 & s607-  s610 :: SWord8 = if s584 then s608 else s609-  s611 :: SWord8 = s610 >>> 1-  s612 :: SWord8 = s20 | s611-  s613 :: SWord8 = s22 & s611-  s614 :: SWord8 = if s605 then s612 else s613-  s615 :: SWord1 = choose [0:0] s598-  s616 :: SBool = s15 /= s615-  s617 :: SWord8 = s603 >>> 1-  s618 :: SWord8 = s20 | s617-  s619 :: SWord8 = s22 & s617-  s620 :: SWord8 = if s616 then s618 else s619-  s621 :: SWord8 = if s25 then s538 else s180-  s622 :: SWord8 = if s166 then s555 else s621-  s623 :: SWord8 = if s25 then s560 else s622-  s624 :: SWord8 = if s166 then s576 else s623-  s625 :: SWord8 = if s25 then s581 else s624-  s626 :: SWord8 = if s166 then s597 else s625-  s627 :: SWord8 = if s25 then s602 else s626-  s628 :: SWord8 = if s166 then s620 else s627-  s629 :: SWord8 = s610 + s628-  s630 :: SBool = s629 < s628-  s631 :: SBool = s629 < s610-  s632 :: SBool = s630 | s631-  s633 :: SWord8 = s629 >>> 1-  s634 :: SWord8 = s20 | s633-  s635 :: SWord8 = s22 & s633-  s636 :: SWord8 = if s632 then s634 else s635-  s637 :: SWord8 = if s606 then s614 else s636-  s638 :: SWord8 = s589 + s626-  s639 :: SWord1 = choose [0:0] s638-  s640 :: SBool = s15 /= s639-  s641 :: SWord8 = if s640 then s600 else s601-  s642 :: SWord8 = if s18 then s641 else s597-  s643 :: SWord1 = choose [0:0] s642-  s644 :: SBool = s15 /= s643-  s645 :: SBool = s_2 == s644-  s646 :: SBool = s638 < s626-  s647 :: SBool = s638 < s589-  s648 :: SBool = s646 | s647-  s649 :: SWord8 = s638 >>> 1-  s650 :: SWord8 = s20 | s649-  s651 :: SWord8 = s22 & s649-  s652 :: SWord8 = if s648 then s650 else s651-  s653 :: SWord8 = s652 >>> 1-  s654 :: SWord8 = s20 | s653-  s655 :: SWord8 = s22 & s653-  s656 :: SWord8 = if s644 then s654 else s655-  s657 :: SWord8 = s642 >>> 1-  s658 :: SWord8 = s20 | s657-  s659 :: SWord8 = s22 & s657-  s660 :: SWord8 = if s616 then s658 else s659-  s661 :: SWord8 = if s25 then s641 else s626-  s662 :: SWord8 = if s166 then s660 else s661-  s663 :: SWord8 = s652 + s662-  s664 :: SBool = s663 < s662-  s665 :: SBool = s663 < s652-  s666 :: SBool = s664 | s665-  s667 :: SWord8 = s663 >>> 1-  s668 :: SWord8 = s20 | s667-  s669 :: SWord8 = s22 & s667-  s670 :: SWord8 = if s666 then s668 else s669-  s671 :: SWord8 = if s645 then s656 else s670-  s672 :: SWord8 = if s585 then s637 else s671-  s673 :: SWord8 = s568 + s624-  s674 :: SWord1 = choose [0:0] s673-  s675 :: SBool = s15 /= s674-  s676 :: SWord8 = if s675 then s579 else s580-  s677 :: SWord8 = if s18 then s676 else s576-  s678 :: SWord1 = choose [0:0] s677-  s679 :: SBool = s15 /= s678-  s680 :: SBool = s_2 == s679-  s681 :: SBool = s673 < s624-  s682 :: SBool = s673 < s568-  s683 :: SBool = s681 | s682-  s684 :: SWord8 = s673 >>> 1-  s685 :: SWord8 = s20 | s684-  s686 :: SWord8 = s22 & s684-  s687 :: SWord8 = if s683 then s685 else s686-  s688 :: SWord1 = choose [0:0] s687-  s689 :: SBool = s15 /= s688-  s690 :: SWord8 = s677 >>> 1-  s691 :: SWord8 = s20 | s690-  s692 :: SWord8 = s22 & s690-  s693 :: SWord8 = if s593 then s691 else s692-  s694 :: SWord8 = if s18 then s693 else s676-  s695 :: SWord8 = s694 >>> 1-  s696 :: SWord8 = s20 | s695-  s697 :: SWord8 = s22 & s695-  s698 :: SWord8 = if s689 then s696 else s697-  s699 :: SWord8 = if s18 then s698 else s693-  s700 :: SWord1 = choose [0:0] s699-  s701 :: SBool = s15 /= s700-  s702 :: SBool = s_2 == s701-  s703 :: SWord8 = s687 >>> 1-  s704 :: SWord8 = s20 | s703-  s705 :: SWord8 = s22 & s703-  s706 :: SWord8 = if s679 then s704 else s705-  s707 :: SWord8 = s706 >>> 1-  s708 :: SWord8 = s20 | s707-  s709 :: SWord8 = s22 & s707-  s710 :: SWord8 = if s701 then s708 else s709-  s711 :: SWord1 = choose [0:0] s694-  s712 :: SBool = s15 /= s711-  s713 :: SWord8 = s699 >>> 1-  s714 :: SWord8 = s20 | s713-  s715 :: SWord8 = s22 & s713-  s716 :: SWord8 = if s712 then s714 else s715-  s717 :: SWord8 = if s25 then s676 else s624-  s718 :: SWord8 = if s166 then s693 else s717-  s719 :: SWord8 = if s25 then s698 else s718-  s720 :: SWord8 = if s166 then s716 else s719-  s721 :: SWord8 = s706 + s720-  s722 :: SBool = s721 < s720-  s723 :: SBool = s721 < s706-  s724 :: SBool = s722 | s723-  s725 :: SWord8 = s721 >>> 1-  s726 :: SWord8 = s20 | s725-  s727 :: SWord8 = s22 & s725-  s728 :: SWord8 = if s724 then s726 else s727-  s729 :: SWord8 = if s702 then s710 else s728-  s730 :: SWord8 = s687 + s718-  s731 :: SWord1 = choose [0:0] s730-  s732 :: SBool = s15 /= s731-  s733 :: SWord8 = if s732 then s696 else s697-  s734 :: SWord8 = if s18 then s733 else s693-  s735 :: SWord1 = choose [0:0] s734-  s736 :: SBool = s15 /= s735-  s737 :: SBool = s_2 == s736-  s738 :: SBool = s730 < s718-  s739 :: SBool = s730 < s687-  s740 :: SBool = s738 | s739-  s741 :: SWord8 = s730 >>> 1-  s742 :: SWord8 = s20 | s741-  s743 :: SWord8 = s22 & s741-  s744 :: SWord8 = if s740 then s742 else s743-  s745 :: SWord8 = s744 >>> 1-  s746 :: SWord8 = s20 | s745-  s747 :: SWord8 = s22 & s745-  s748 :: SWord8 = if s736 then s746 else s747-  s749 :: SWord8 = s734 >>> 1-  s750 :: SWord8 = s20 | s749-  s751 :: SWord8 = s22 & s749-  s752 :: SWord8 = if s712 then s750 else s751-  s753 :: SWord8 = if s25 then s733 else s718-  s754 :: SWord8 = if s166 then s752 else s753-  s755 :: SWord8 = s744 + s754-  s756 :: SBool = s755 < s754-  s757 :: SBool = s755 < s744-  s758 :: SBool = s756 | s757-  s759 :: SWord8 = s755 >>> 1-  s760 :: SWord8 = s20 | s759-  s761 :: SWord8 = s22 & s759-  s762 :: SWord8 = if s758 then s760 else s761-  s763 :: SWord8 = if s737 then s748 else s762-  s764 :: SWord8 = if s680 then s729 else s763-  s765 :: SWord8 = if s564 then s672 else s764-  s766 :: SWord8 = s549 + s622-  s767 :: SWord1 = choose [0:0] s766-  s768 :: SBool = s15 /= s767-  s769 :: SWord8 = if s768 then s558 else s559-  s770 :: SWord8 = if s18 then s769 else s555-  s771 :: SWord1 = choose [0:0] s770-  s772 :: SBool = s15 /= s771-  s773 :: SBool = s_2 == s772-  s774 :: SBool = s766 < s622-  s775 :: SBool = s766 < s549-  s776 :: SBool = s774 | s775-  s777 :: SWord8 = s766 >>> 1-  s778 :: SWord8 = s20 | s777-  s779 :: SWord8 = s22 & s777-  s780 :: SWord8 = if s776 then s778 else s779-  s781 :: SWord1 = choose [0:0] s780-  s782 :: SBool = s15 /= s781-  s783 :: SWord8 = s770 >>> 1-  s784 :: SWord8 = s20 | s783-  s785 :: SWord8 = s22 & s783-  s786 :: SWord8 = if s572 then s784 else s785-  s787 :: SWord8 = if s18 then s786 else s769-  s788 :: SWord8 = s787 >>> 1-  s789 :: SWord8 = s20 | s788-  s790 :: SWord8 = s22 & s788-  s791 :: SWord8 = if s782 then s789 else s790-  s792 :: SWord8 = if s18 then s791 else s786-  s793 :: SWord1 = choose [0:0] s792-  s794 :: SBool = s15 /= s793-  s795 :: SBool = s_2 == s794-  s796 :: SWord8 = s780 >>> 1-  s797 :: SWord8 = s20 | s796-  s798 :: SWord8 = s22 & s796-  s799 :: SWord8 = if s772 then s797 else s798-  s800 :: SWord1 = choose [0:0] s799-  s801 :: SBool = s15 /= s800-  s802 :: SWord1 = choose [0:0] s787-  s803 :: SBool = s15 /= s802-  s804 :: SWord8 = s792 >>> 1-  s805 :: SWord8 = s20 | s804-  s806 :: SWord8 = s22 & s804-  s807 :: SWord8 = if s803 then s805 else s806-  s808 :: SWord8 = if s18 then s807 else s791-  s809 :: SWord8 = s808 >>> 1-  s810 :: SWord8 = s20 | s809-  s811 :: SWord8 = s22 & s809-  s812 :: SWord8 = if s801 then s810 else s811-  s813 :: SWord8 = if s18 then s812 else s807-  s814 :: SWord1 = choose [0:0] s813-  s815 :: SBool = s15 /= s814-  s816 :: SBool = s_2 == s815-  s817 :: SWord8 = s799 >>> 1-  s818 :: SWord8 = s20 | s817-  s819 :: SWord8 = s22 & s817-  s820 :: SWord8 = if s794 then s818 else s819-  s821 :: SWord8 = s820 >>> 1-  s822 :: SWord8 = s20 | s821-  s823 :: SWord8 = s22 & s821-  s824 :: SWord8 = if s815 then s822 else s823-  s825 :: SWord1 = choose [0:0] s808-  s826 :: SBool = s15 /= s825-  s827 :: SWord8 = s813 >>> 1-  s828 :: SWord8 = s20 | s827-  s829 :: SWord8 = s22 & s827-  s830 :: SWord8 = if s826 then s828 else s829-  s831 :: SWord8 = if s25 then s769 else s622-  s832 :: SWord8 = if s166 then s786 else s831-  s833 :: SWord8 = if s25 then s791 else s832-  s834 :: SWord8 = if s166 then s807 else s833-  s835 :: SWord8 = if s25 then s812 else s834-  s836 :: SWord8 = if s166 then s830 else s835-  s837 :: SWord8 = s820 + s836-  s838 :: SBool = s837 < s836-  s839 :: SBool = s837 < s820-  s840 :: SBool = s838 | s839-  s841 :: SWord8 = s837 >>> 1-  s842 :: SWord8 = s20 | s841-  s843 :: SWord8 = s22 & s841-  s844 :: SWord8 = if s840 then s842 else s843-  s845 :: SWord8 = if s816 then s824 else s844-  s846 :: SWord8 = s799 + s834-  s847 :: SWord1 = choose [0:0] s846-  s848 :: SBool = s15 /= s847-  s849 :: SWord8 = if s848 then s810 else s811-  s850 :: SWord8 = if s18 then s849 else s807-  s851 :: SWord1 = choose [0:0] s850-  s852 :: SBool = s15 /= s851-  s853 :: SBool = s_2 == s852-  s854 :: SBool = s846 < s834-  s855 :: SBool = s846 < s799-  s856 :: SBool = s854 | s855-  s857 :: SWord8 = s846 >>> 1-  s858 :: SWord8 = s20 | s857-  s859 :: SWord8 = s22 & s857-  s860 :: SWord8 = if s856 then s858 else s859-  s861 :: SWord8 = s860 >>> 1-  s862 :: SWord8 = s20 | s861-  s863 :: SWord8 = s22 & s861-  s864 :: SWord8 = if s852 then s862 else s863-  s865 :: SWord8 = s850 >>> 1-  s866 :: SWord8 = s20 | s865-  s867 :: SWord8 = s22 & s865-  s868 :: SWord8 = if s826 then s866 else s867-  s869 :: SWord8 = if s25 then s849 else s834-  s870 :: SWord8 = if s166 then s868 else s869-  s871 :: SWord8 = s860 + s870-  s872 :: SBool = s871 < s870-  s873 :: SBool = s871 < s860-  s874 :: SBool = s872 | s873-  s875 :: SWord8 = s871 >>> 1-  s876 :: SWord8 = s20 | s875-  s877 :: SWord8 = s22 & s875-  s878 :: SWord8 = if s874 then s876 else s877-  s879 :: SWord8 = if s853 then s864 else s878-  s880 :: SWord8 = if s795 then s845 else s879-  s881 :: SWord8 = s780 + s832-  s882 :: SWord1 = choose [0:0] s881-  s883 :: SBool = s15 /= s882-  s884 :: SWord8 = if s883 then s789 else s790-  s885 :: SWord8 = if s18 then s884 else s786-  s886 :: SWord1 = choose [0:0] s885-  s887 :: SBool = s15 /= s886-  s888 :: SBool = s_2 == s887-  s889 :: SBool = s881 < s832-  s890 :: SBool = s881 < s780-  s891 :: SBool = s889 | s890-  s892 :: SWord8 = s881 >>> 1-  s893 :: SWord8 = s20 | s892-  s894 :: SWord8 = s22 & s892-  s895 :: SWord8 = if s891 then s893 else s894-  s896 :: SWord1 = choose [0:0] s895-  s897 :: SBool = s15 /= s896-  s898 :: SWord8 = s885 >>> 1-  s899 :: SWord8 = s20 | s898-  s900 :: SWord8 = s22 & s898-  s901 :: SWord8 = if s803 then s899 else s900-  s902 :: SWord8 = if s18 then s901 else s884-  s903 :: SWord8 = s902 >>> 1-  s904 :: SWord8 = s20 | s903-  s905 :: SWord8 = s22 & s903-  s906 :: SWord8 = if s897 then s904 else s905-  s907 :: SWord8 = if s18 then s906 else s901-  s908 :: SWord1 = choose [0:0] s907-  s909 :: SBool = s15 /= s908-  s910 :: SBool = s_2 == s909-  s911 :: SWord8 = s895 >>> 1-  s912 :: SWord8 = s20 | s911-  s913 :: SWord8 = s22 & s911-  s914 :: SWord8 = if s887 then s912 else s913-  s915 :: SWord8 = s914 >>> 1-  s916 :: SWord8 = s20 | s915-  s917 :: SWord8 = s22 & s915-  s918 :: SWord8 = if s909 then s916 else s917-  s919 :: SWord1 = choose [0:0] s902-  s920 :: SBool = s15 /= s919-  s921 :: SWord8 = s907 >>> 1-  s922 :: SWord8 = s20 | s921-  s923 :: SWord8 = s22 & s921-  s924 :: SWord8 = if s920 then s922 else s923-  s925 :: SWord8 = if s25 then s884 else s832-  s926 :: SWord8 = if s166 then s901 else s925-  s927 :: SWord8 = if s25 then s906 else s926-  s928 :: SWord8 = if s166 then s924 else s927-  s929 :: SWord8 = s914 + s928-  s930 :: SBool = s929 < s928-  s931 :: SBool = s929 < s914-  s932 :: SBool = s930 | s931-  s933 :: SWord8 = s929 >>> 1-  s934 :: SWord8 = s20 | s933-  s935 :: SWord8 = s22 & s933-  s936 :: SWord8 = if s932 then s934 else s935-  s937 :: SWord8 = if s910 then s918 else s936-  s938 :: SWord8 = s895 + s926-  s939 :: SWord1 = choose [0:0] s938-  s940 :: SBool = s15 /= s939-  s941 :: SWord8 = if s940 then s904 else s905-  s942 :: SWord8 = if s18 then s941 else s901-  s943 :: SWord1 = choose [0:0] s942-  s944 :: SBool = s15 /= s943-  s945 :: SBool = s_2 == s944-  s946 :: SBool = s938 < s926-  s947 :: SBool = s938 < s895-  s948 :: SBool = s946 | s947-  s949 :: SWord8 = s938 >>> 1-  s950 :: SWord8 = s20 | s949-  s951 :: SWord8 = s22 & s949-  s952 :: SWord8 = if s948 then s950 else s951-  s953 :: SWord8 = s952 >>> 1-  s954 :: SWord8 = s20 | s953-  s955 :: SWord8 = s22 & s953-  s956 :: SWord8 = if s944 then s954 else s955-  s957 :: SWord8 = s942 >>> 1-  s958 :: SWord8 = s20 | s957-  s959 :: SWord8 = s22 & s957-  s960 :: SWord8 = if s920 then s958 else s959-  s961 :: SWord8 = if s25 then s941 else s926-  s962 :: SWord8 = if s166 then s960 else s961-  s963 :: SWord8 = s952 + s962-  s964 :: SBool = s963 < s962-  s965 :: SBool = s963 < s952-  s966 :: SBool = s964 | s965-  s967 :: SWord8 = s963 >>> 1-  s968 :: SWord8 = s20 | s967-  s969 :: SWord8 = s22 & s967-  s970 :: SWord8 = if s966 then s968 else s969-  s971 :: SWord8 = if s945 then s956 else s970-  s972 :: SWord8 = if s888 then s937 else s971-  s973 :: SWord8 = if s773 then s880 else s972-  s974 :: SWord8 = if s542 then s765 else s973-  s975 :: SWord8 = if s73 then s534 else s974-  s976 :: SWord8 = s56 + s178-  s977 :: SWord1 = choose [0:0] s976-  s978 :: SBool = s15 /= s977-  s979 :: SWord8 = if s978 then s67 else s68-  s980 :: SWord8 = if s18 then s979 else s64-  s981 :: SWord1 = choose [0:0] s980-  s982 :: SBool = s15 /= s981-  s983 :: SBool = s_2 == s982-  s984 :: SBool = s976 < s178-  s985 :: SBool = s976 < s56-  s986 :: SBool = s984 | s985-  s987 :: SWord8 = s976 >>> 1-  s988 :: SWord8 = s20 | s987-  s989 :: SWord8 = s22 & s987-  s990 :: SWord8 = if s986 then s988 else s989-  s991 :: SWord1 = choose [0:0] s990-  s992 :: SBool = s15 /= s991-  s993 :: SWord8 = s980 >>> 1-  s994 :: SWord8 = s20 | s993-  s995 :: SWord8 = s22 & s993-  s996 :: SWord8 = if s81 then s994 else s995-  s997 :: SWord8 = if s18 then s996 else s979-  s998 :: SWord8 = s997 >>> 1-  s999 :: SWord8 = s20 | s998-  s1000 :: SWord8 = s22 & s998-  s1001 :: SWord8 = if s992 then s999 else s1000-  s1002 :: SWord8 = if s18 then s1001 else s996-  s1003 :: SWord1 = choose [0:0] s1002-  s1004 :: SBool = s15 /= s1003-  s1005 :: SBool = s_2 == s1004-  s1006 :: SWord8 = s990 >>> 1-  s1007 :: SWord8 = s20 | s1006-  s1008 :: SWord8 = s22 & s1006-  s1009 :: SWord8 = if s982 then s1007 else s1008-  s1010 :: SWord1 = choose [0:0] s1009-  s1011 :: SBool = s15 /= s1010-  s1012 :: SWord1 = choose [0:0] s997-  s1013 :: SBool = s15 /= s1012-  s1014 :: SWord8 = s1002 >>> 1-  s1015 :: SWord8 = s20 | s1014-  s1016 :: SWord8 = s22 & s1014-  s1017 :: SWord8 = if s1013 then s1015 else s1016-  s1018 :: SWord8 = if s18 then s1017 else s1001-  s1019 :: SWord8 = s1018 >>> 1-  s1020 :: SWord8 = s20 | s1019-  s1021 :: SWord8 = s22 & s1019-  s1022 :: SWord8 = if s1011 then s1020 else s1021-  s1023 :: SWord8 = if s18 then s1022 else s1017-  s1024 :: SWord1 = choose [0:0] s1023-  s1025 :: SBool = s15 /= s1024-  s1026 :: SBool = s_2 == s1025-  s1027 :: SWord8 = s1009 >>> 1-  s1028 :: SWord8 = s20 | s1027-  s1029 :: SWord8 = s22 & s1027-  s1030 :: SWord8 = if s1004 then s1028 else s1029-  s1031 :: SWord1 = choose [0:0] s1030-  s1032 :: SBool = s15 /= s1031-  s1033 :: SWord1 = choose [0:0] s1018-  s1034 :: SBool = s15 /= s1033-  s1035 :: SWord8 = s1023 >>> 1-  s1036 :: SWord8 = s20 | s1035-  s1037 :: SWord8 = s22 & s1035-  s1038 :: SWord8 = if s1034 then s1036 else s1037-  s1039 :: SWord8 = if s18 then s1038 else s1022-  s1040 :: SWord8 = s1039 >>> 1-  s1041 :: SWord8 = s20 | s1040-  s1042 :: SWord8 = s22 & s1040-  s1043 :: SWord8 = if s1032 then s1041 else s1042-  s1044 :: SWord8 = if s18 then s1043 else s1038-  s1045 :: SWord1 = choose [0:0] s1044-  s1046 :: SBool = s15 /= s1045-  s1047 :: SBool = s_2 == s1046-  s1048 :: SWord8 = s1030 >>> 1-  s1049 :: SWord8 = s20 | s1048-  s1050 :: SWord8 = s22 & s1048-  s1051 :: SWord8 = if s1025 then s1049 else s1050-  s1052 :: SWord1 = choose [0:0] s1051-  s1053 :: SBool = s15 /= s1052-  s1054 :: SWord1 = choose [0:0] s1039-  s1055 :: SBool = s15 /= s1054-  s1056 :: SWord8 = s1044 >>> 1-  s1057 :: SWord8 = s20 | s1056-  s1058 :: SWord8 = s22 & s1056-  s1059 :: SWord8 = if s1055 then s1057 else s1058-  s1060 :: SWord8 = if s18 then s1059 else s1043-  s1061 :: SWord8 = s1060 >>> 1-  s1062 :: SWord8 = s20 | s1061-  s1063 :: SWord8 = s22 & s1061-  s1064 :: SWord8 = if s1053 then s1062 else s1063-  s1065 :: SWord8 = if s18 then s1064 else s1059-  s1066 :: SWord1 = choose [0:0] s1065-  s1067 :: SBool = s15 /= s1066-  s1068 :: SBool = s_2 == s1067-  s1069 :: SWord8 = s1051 >>> 1-  s1070 :: SWord8 = s20 | s1069-  s1071 :: SWord8 = s22 & s1069-  s1072 :: SWord8 = if s1046 then s1070 else s1071-  s1073 :: SWord8 = s1072 >>> 1-  s1074 :: SWord8 = s20 | s1073-  s1075 :: SWord8 = s22 & s1073-  s1076 :: SWord8 = if s1067 then s1074 else s1075-  s1077 :: SWord1 = choose [0:0] s1060-  s1078 :: SBool = s15 /= s1077-  s1079 :: SWord8 = s1065 >>> 1-  s1080 :: SWord8 = s20 | s1079-  s1081 :: SWord8 = s22 & s1079-  s1082 :: SWord8 = if s1078 then s1080 else s1081-  s1083 :: SWord8 = if s25 then s979 else s178-  s1084 :: SWord8 = if s166 then s996 else s1083-  s1085 :: SWord8 = if s25 then s1001 else s1084-  s1086 :: SWord8 = if s166 then s1017 else s1085-  s1087 :: SWord8 = if s25 then s1022 else s1086-  s1088 :: SWord8 = if s166 then s1038 else s1087-  s1089 :: SWord8 = if s25 then s1043 else s1088-  s1090 :: SWord8 = if s166 then s1059 else s1089-  s1091 :: SWord8 = if s25 then s1064 else s1090-  s1092 :: SWord8 = if s166 then s1082 else s1091-  s1093 :: SWord8 = s1072 + s1092-  s1094 :: SBool = s1093 < s1092-  s1095 :: SBool = s1093 < s1072-  s1096 :: SBool = s1094 | s1095-  s1097 :: SWord8 = s1093 >>> 1-  s1098 :: SWord8 = s20 | s1097-  s1099 :: SWord8 = s22 & s1097-  s1100 :: SWord8 = if s1096 then s1098 else s1099-  s1101 :: SWord8 = if s1068 then s1076 else s1100-  s1102 :: SWord8 = s1051 + s1090-  s1103 :: SWord1 = choose [0:0] s1102-  s1104 :: SBool = s15 /= s1103-  s1105 :: SWord8 = if s1104 then s1062 else s1063-  s1106 :: SWord8 = if s18 then s1105 else s1059-  s1107 :: SWord1 = choose [0:0] s1106-  s1108 :: SBool = s15 /= s1107-  s1109 :: SBool = s_2 == s1108-  s1110 :: SBool = s1102 < s1090-  s1111 :: SBool = s1102 < s1051-  s1112 :: SBool = s1110 | s1111-  s1113 :: SWord8 = s1102 >>> 1-  s1114 :: SWord8 = s20 | s1113-  s1115 :: SWord8 = s22 & s1113-  s1116 :: SWord8 = if s1112 then s1114 else s1115-  s1117 :: SWord8 = s1116 >>> 1-  s1118 :: SWord8 = s20 | s1117-  s1119 :: SWord8 = s22 & s1117-  s1120 :: SWord8 = if s1108 then s1118 else s1119-  s1121 :: SWord8 = s1106 >>> 1-  s1122 :: SWord8 = s20 | s1121-  s1123 :: SWord8 = s22 & s1121-  s1124 :: SWord8 = if s1078 then s1122 else s1123-  s1125 :: SWord8 = if s25 then s1105 else s1090-  s1126 :: SWord8 = if s166 then s1124 else s1125-  s1127 :: SWord8 = s1116 + s1126-  s1128 :: SBool = s1127 < s1126-  s1129 :: SBool = s1127 < s1116-  s1130 :: SBool = s1128 | s1129-  s1131 :: SWord8 = s1127 >>> 1-  s1132 :: SWord8 = s20 | s1131-  s1133 :: SWord8 = s22 & s1131-  s1134 :: SWord8 = if s1130 then s1132 else s1133-  s1135 :: SWord8 = if s1109 then s1120 else s1134-  s1136 :: SWord8 = if s1047 then s1101 else s1135-  s1137 :: SWord8 = s1030 + s1088-  s1138 :: SWord1 = choose [0:0] s1137-  s1139 :: SBool = s15 /= s1138-  s1140 :: SWord8 = if s1139 then s1041 else s1042-  s1141 :: SWord8 = if s18 then s1140 else s1038-  s1142 :: SWord1 = choose [0:0] s1141-  s1143 :: SBool = s15 /= s1142-  s1144 :: SBool = s_2 == s1143-  s1145 :: SBool = s1137 < s1088-  s1146 :: SBool = s1137 < s1030-  s1147 :: SBool = s1145 | s1146-  s1148 :: SWord8 = s1137 >>> 1-  s1149 :: SWord8 = s20 | s1148-  s1150 :: SWord8 = s22 & s1148-  s1151 :: SWord8 = if s1147 then s1149 else s1150-  s1152 :: SWord1 = choose [0:0] s1151-  s1153 :: SBool = s15 /= s1152-  s1154 :: SWord8 = s1141 >>> 1-  s1155 :: SWord8 = s20 | s1154-  s1156 :: SWord8 = s22 & s1154-  s1157 :: SWord8 = if s1055 then s1155 else s1156-  s1158 :: SWord8 = if s18 then s1157 else s1140-  s1159 :: SWord8 = s1158 >>> 1-  s1160 :: SWord8 = s20 | s1159-  s1161 :: SWord8 = s22 & s1159-  s1162 :: SWord8 = if s1153 then s1160 else s1161-  s1163 :: SWord8 = if s18 then s1162 else s1157-  s1164 :: SWord1 = choose [0:0] s1163-  s1165 :: SBool = s15 /= s1164-  s1166 :: SBool = s_2 == s1165-  s1167 :: SWord8 = s1151 >>> 1-  s1168 :: SWord8 = s20 | s1167-  s1169 :: SWord8 = s22 & s1167-  s1170 :: SWord8 = if s1143 then s1168 else s1169-  s1171 :: SWord8 = s1170 >>> 1-  s1172 :: SWord8 = s20 | s1171-  s1173 :: SWord8 = s22 & s1171-  s1174 :: SWord8 = if s1165 then s1172 else s1173-  s1175 :: SWord1 = choose [0:0] s1158-  s1176 :: SBool = s15 /= s1175-  s1177 :: SWord8 = s1163 >>> 1-  s1178 :: SWord8 = s20 | s1177-  s1179 :: SWord8 = s22 & s1177-  s1180 :: SWord8 = if s1176 then s1178 else s1179-  s1181 :: SWord8 = if s25 then s1140 else s1088-  s1182 :: SWord8 = if s166 then s1157 else s1181-  s1183 :: SWord8 = if s25 then s1162 else s1182-  s1184 :: SWord8 = if s166 then s1180 else s1183-  s1185 :: SWord8 = s1170 + s1184-  s1186 :: SBool = s1185 < s1184-  s1187 :: SBool = s1185 < s1170-  s1188 :: SBool = s1186 | s1187-  s1189 :: SWord8 = s1185 >>> 1-  s1190 :: SWord8 = s20 | s1189-  s1191 :: SWord8 = s22 & s1189-  s1192 :: SWord8 = if s1188 then s1190 else s1191-  s1193 :: SWord8 = if s1166 then s1174 else s1192-  s1194 :: SWord8 = s1151 + s1182-  s1195 :: SWord1 = choose [0:0] s1194-  s1196 :: SBool = s15 /= s1195-  s1197 :: SWord8 = if s1196 then s1160 else s1161-  s1198 :: SWord8 = if s18 then s1197 else s1157-  s1199 :: SWord1 = choose [0:0] s1198-  s1200 :: SBool = s15 /= s1199-  s1201 :: SBool = s_2 == s1200-  s1202 :: SBool = s1194 < s1182-  s1203 :: SBool = s1194 < s1151-  s1204 :: SBool = s1202 | s1203-  s1205 :: SWord8 = s1194 >>> 1-  s1206 :: SWord8 = s20 | s1205-  s1207 :: SWord8 = s22 & s1205-  s1208 :: SWord8 = if s1204 then s1206 else s1207-  s1209 :: SWord8 = s1208 >>> 1-  s1210 :: SWord8 = s20 | s1209-  s1211 :: SWord8 = s22 & s1209-  s1212 :: SWord8 = if s1200 then s1210 else s1211-  s1213 :: SWord8 = s1198 >>> 1-  s1214 :: SWord8 = s20 | s1213-  s1215 :: SWord8 = s22 & s1213-  s1216 :: SWord8 = if s1176 then s1214 else s1215-  s1217 :: SWord8 = if s25 then s1197 else s1182-  s1218 :: SWord8 = if s166 then s1216 else s1217-  s1219 :: SWord8 = s1208 + s1218-  s1220 :: SBool = s1219 < s1218-  s1221 :: SBool = s1219 < s1208-  s1222 :: SBool = s1220 | s1221-  s1223 :: SWord8 = s1219 >>> 1-  s1224 :: SWord8 = s20 | s1223-  s1225 :: SWord8 = s22 & s1223-  s1226 :: SWord8 = if s1222 then s1224 else s1225-  s1227 :: SWord8 = if s1201 then s1212 else s1226-  s1228 :: SWord8 = if s1144 then s1193 else s1227-  s1229 :: SWord8 = if s1026 then s1136 else s1228-  s1230 :: SWord8 = s1009 + s1086-  s1231 :: SWord1 = choose [0:0] s1230-  s1232 :: SBool = s15 /= s1231-  s1233 :: SWord8 = if s1232 then s1020 else s1021-  s1234 :: SWord8 = if s18 then s1233 else s1017-  s1235 :: SWord1 = choose [0:0] s1234-  s1236 :: SBool = s15 /= s1235-  s1237 :: SBool = s_2 == s1236-  s1238 :: SBool = s1230 < s1086-  s1239 :: SBool = s1230 < s1009-  s1240 :: SBool = s1238 | s1239-  s1241 :: SWord8 = s1230 >>> 1-  s1242 :: SWord8 = s20 | s1241-  s1243 :: SWord8 = s22 & s1241-  s1244 :: SWord8 = if s1240 then s1242 else s1243-  s1245 :: SWord1 = choose [0:0] s1244-  s1246 :: SBool = s15 /= s1245-  s1247 :: SWord8 = s1234 >>> 1-  s1248 :: SWord8 = s20 | s1247-  s1249 :: SWord8 = s22 & s1247-  s1250 :: SWord8 = if s1034 then s1248 else s1249-  s1251 :: SWord8 = if s18 then s1250 else s1233-  s1252 :: SWord8 = s1251 >>> 1-  s1253 :: SWord8 = s20 | s1252-  s1254 :: SWord8 = s22 & s1252-  s1255 :: SWord8 = if s1246 then s1253 else s1254-  s1256 :: SWord8 = if s18 then s1255 else s1250-  s1257 :: SWord1 = choose [0:0] s1256-  s1258 :: SBool = s15 /= s1257-  s1259 :: SBool = s_2 == s1258-  s1260 :: SWord8 = s1244 >>> 1-  s1261 :: SWord8 = s20 | s1260-  s1262 :: SWord8 = s22 & s1260-  s1263 :: SWord8 = if s1236 then s1261 else s1262-  s1264 :: SWord1 = choose [0:0] s1263-  s1265 :: SBool = s15 /= s1264-  s1266 :: SWord1 = choose [0:0] s1251-  s1267 :: SBool = s15 /= s1266-  s1268 :: SWord8 = s1256 >>> 1-  s1269 :: SWord8 = s20 | s1268-  s1270 :: SWord8 = s22 & s1268-  s1271 :: SWord8 = if s1267 then s1269 else s1270-  s1272 :: SWord8 = if s18 then s1271 else s1255-  s1273 :: SWord8 = s1272 >>> 1-  s1274 :: SWord8 = s20 | s1273-  s1275 :: SWord8 = s22 & s1273-  s1276 :: SWord8 = if s1265 then s1274 else s1275-  s1277 :: SWord8 = if s18 then s1276 else s1271-  s1278 :: SWord1 = choose [0:0] s1277-  s1279 :: SBool = s15 /= s1278-  s1280 :: SBool = s_2 == s1279-  s1281 :: SWord8 = s1263 >>> 1-  s1282 :: SWord8 = s20 | s1281-  s1283 :: SWord8 = s22 & s1281-  s1284 :: SWord8 = if s1258 then s1282 else s1283-  s1285 :: SWord8 = s1284 >>> 1-  s1286 :: SWord8 = s20 | s1285-  s1287 :: SWord8 = s22 & s1285-  s1288 :: SWord8 = if s1279 then s1286 else s1287-  s1289 :: SWord1 = choose [0:0] s1272-  s1290 :: SBool = s15 /= s1289-  s1291 :: SWord8 = s1277 >>> 1-  s1292 :: SWord8 = s20 | s1291-  s1293 :: SWord8 = s22 & s1291-  s1294 :: SWord8 = if s1290 then s1292 else s1293-  s1295 :: SWord8 = if s25 then s1233 else s1086-  s1296 :: SWord8 = if s166 then s1250 else s1295-  s1297 :: SWord8 = if s25 then s1255 else s1296-  s1298 :: SWord8 = if s166 then s1271 else s1297-  s1299 :: SWord8 = if s25 then s1276 else s1298-  s1300 :: SWord8 = if s166 then s1294 else s1299-  s1301 :: SWord8 = s1284 + s1300-  s1302 :: SBool = s1301 < s1300-  s1303 :: SBool = s1301 < s1284-  s1304 :: SBool = s1302 | s1303-  s1305 :: SWord8 = s1301 >>> 1-  s1306 :: SWord8 = s20 | s1305-  s1307 :: SWord8 = s22 & s1305-  s1308 :: SWord8 = if s1304 then s1306 else s1307-  s1309 :: SWord8 = if s1280 then s1288 else s1308-  s1310 :: SWord8 = s1263 + s1298-  s1311 :: SWord1 = choose [0:0] s1310-  s1312 :: SBool = s15 /= s1311-  s1313 :: SWord8 = if s1312 then s1274 else s1275-  s1314 :: SWord8 = if s18 then s1313 else s1271-  s1315 :: SWord1 = choose [0:0] s1314-  s1316 :: SBool = s15 /= s1315-  s1317 :: SBool = s_2 == s1316-  s1318 :: SBool = s1310 < s1298-  s1319 :: SBool = s1310 < s1263-  s1320 :: SBool = s1318 | s1319-  s1321 :: SWord8 = s1310 >>> 1-  s1322 :: SWord8 = s20 | s1321-  s1323 :: SWord8 = s22 & s1321-  s1324 :: SWord8 = if s1320 then s1322 else s1323-  s1325 :: SWord8 = s1324 >>> 1-  s1326 :: SWord8 = s20 | s1325-  s1327 :: SWord8 = s22 & s1325-  s1328 :: SWord8 = if s1316 then s1326 else s1327-  s1329 :: SWord8 = s1314 >>> 1-  s1330 :: SWord8 = s20 | s1329-  s1331 :: SWord8 = s22 & s1329-  s1332 :: SWord8 = if s1290 then s1330 else s1331-  s1333 :: SWord8 = if s25 then s1313 else s1298-  s1334 :: SWord8 = if s166 then s1332 else s1333-  s1335 :: SWord8 = s1324 + s1334-  s1336 :: SBool = s1335 < s1334-  s1337 :: SBool = s1335 < s1324-  s1338 :: SBool = s1336 | s1337-  s1339 :: SWord8 = s1335 >>> 1-  s1340 :: SWord8 = s20 | s1339-  s1341 :: SWord8 = s22 & s1339-  s1342 :: SWord8 = if s1338 then s1340 else s1341-  s1343 :: SWord8 = if s1317 then s1328 else s1342-  s1344 :: SWord8 = if s1259 then s1309 else s1343-  s1345 :: SWord8 = s1244 + s1296-  s1346 :: SWord1 = choose [0:0] s1345-  s1347 :: SBool = s15 /= s1346-  s1348 :: SWord8 = if s1347 then s1253 else s1254-  s1349 :: SWord8 = if s18 then s1348 else s1250-  s1350 :: SWord1 = choose [0:0] s1349-  s1351 :: SBool = s15 /= s1350-  s1352 :: SBool = s_2 == s1351-  s1353 :: SBool = s1345 < s1296-  s1354 :: SBool = s1345 < s1244-  s1355 :: SBool = s1353 | s1354-  s1356 :: SWord8 = s1345 >>> 1-  s1357 :: SWord8 = s20 | s1356-  s1358 :: SWord8 = s22 & s1356-  s1359 :: SWord8 = if s1355 then s1357 else s1358-  s1360 :: SWord1 = choose [0:0] s1359-  s1361 :: SBool = s15 /= s1360-  s1362 :: SWord8 = s1349 >>> 1-  s1363 :: SWord8 = s20 | s1362-  s1364 :: SWord8 = s22 & s1362-  s1365 :: SWord8 = if s1267 then s1363 else s1364-  s1366 :: SWord8 = if s18 then s1365 else s1348-  s1367 :: SWord8 = s1366 >>> 1-  s1368 :: SWord8 = s20 | s1367-  s1369 :: SWord8 = s22 & s1367-  s1370 :: SWord8 = if s1361 then s1368 else s1369-  s1371 :: SWord8 = if s18 then s1370 else s1365-  s1372 :: SWord1 = choose [0:0] s1371-  s1373 :: SBool = s15 /= s1372-  s1374 :: SBool = s_2 == s1373-  s1375 :: SWord8 = s1359 >>> 1-  s1376 :: SWord8 = s20 | s1375-  s1377 :: SWord8 = s22 & s1375-  s1378 :: SWord8 = if s1351 then s1376 else s1377-  s1379 :: SWord8 = s1378 >>> 1-  s1380 :: SWord8 = s20 | s1379-  s1381 :: SWord8 = s22 & s1379-  s1382 :: SWord8 = if s1373 then s1380 else s1381-  s1383 :: SWord1 = choose [0:0] s1366-  s1384 :: SBool = s15 /= s1383-  s1385 :: SWord8 = s1371 >>> 1-  s1386 :: SWord8 = s20 | s1385-  s1387 :: SWord8 = s22 & s1385-  s1388 :: SWord8 = if s1384 then s1386 else s1387-  s1389 :: SWord8 = if s25 then s1348 else s1296-  s1390 :: SWord8 = if s166 then s1365 else s1389-  s1391 :: SWord8 = if s25 then s1370 else s1390-  s1392 :: SWord8 = if s166 then s1388 else s1391-  s1393 :: SWord8 = s1378 + s1392-  s1394 :: SBool = s1393 < s1392-  s1395 :: SBool = s1393 < s1378-  s1396 :: SBool = s1394 | s1395-  s1397 :: SWord8 = s1393 >>> 1-  s1398 :: SWord8 = s20 | s1397-  s1399 :: SWord8 = s22 & s1397-  s1400 :: SWord8 = if s1396 then s1398 else s1399-  s1401 :: SWord8 = if s1374 then s1382 else s1400-  s1402 :: SWord8 = s1359 + s1390-  s1403 :: SWord1 = choose [0:0] s1402-  s1404 :: SBool = s15 /= s1403-  s1405 :: SWord8 = if s1404 then s1368 else s1369-  s1406 :: SWord8 = if s18 then s1405 else s1365-  s1407 :: SWord1 = choose [0:0] s1406-  s1408 :: SBool = s15 /= s1407-  s1409 :: SBool = s_2 == s1408-  s1410 :: SBool = s1402 < s1390-  s1411 :: SBool = s1402 < s1359-  s1412 :: SBool = s1410 | s1411-  s1413 :: SWord8 = s1402 >>> 1-  s1414 :: SWord8 = s20 | s1413-  s1415 :: SWord8 = s22 & s1413-  s1416 :: SWord8 = if s1412 then s1414 else s1415-  s1417 :: SWord8 = s1416 >>> 1-  s1418 :: SWord8 = s20 | s1417-  s1419 :: SWord8 = s22 & s1417-  s1420 :: SWord8 = if s1408 then s1418 else s1419-  s1421 :: SWord8 = s1406 >>> 1-  s1422 :: SWord8 = s20 | s1421-  s1423 :: SWord8 = s22 & s1421-  s1424 :: SWord8 = if s1384 then s1422 else s1423-  s1425 :: SWord8 = if s25 then s1405 else s1390-  s1426 :: SWord8 = if s166 then s1424 else s1425-  s1427 :: SWord8 = s1416 + s1426-  s1428 :: SBool = s1427 < s1426-  s1429 :: SBool = s1427 < s1416-  s1430 :: SBool = s1428 | s1429-  s1431 :: SWord8 = s1427 >>> 1-  s1432 :: SWord8 = s20 | s1431-  s1433 :: SWord8 = s22 & s1431-  s1434 :: SWord8 = if s1430 then s1432 else s1433-  s1435 :: SWord8 = if s1409 then s1420 else s1434-  s1436 :: SWord8 = if s1352 then s1401 else s1435-  s1437 :: SWord8 = if s1237 then s1344 else s1436-  s1438 :: SWord8 = if s1005 then s1229 else s1437-  s1439 :: SWord8 = s990 + s1084-  s1440 :: SWord1 = choose [0:0] s1439-  s1441 :: SBool = s15 /= s1440-  s1442 :: SWord8 = if s1441 then s999 else s1000-  s1443 :: SWord8 = if s18 then s1442 else s996-  s1444 :: SWord1 = choose [0:0] s1443-  s1445 :: SBool = s15 /= s1444-  s1446 :: SBool = s_2 == s1445-  s1447 :: SBool = s1439 < s1084-  s1448 :: SBool = s1439 < s990-  s1449 :: SBool = s1447 | s1448-  s1450 :: SWord8 = s1439 >>> 1-  s1451 :: SWord8 = s20 | s1450-  s1452 :: SWord8 = s22 & s1450-  s1453 :: SWord8 = if s1449 then s1451 else s1452-  s1454 :: SWord1 = choose [0:0] s1453-  s1455 :: SBool = s15 /= s1454-  s1456 :: SWord8 = s1443 >>> 1-  s1457 :: SWord8 = s20 | s1456-  s1458 :: SWord8 = s22 & s1456-  s1459 :: SWord8 = if s1013 then s1457 else s1458-  s1460 :: SWord8 = if s18 then s1459 else s1442-  s1461 :: SWord8 = s1460 >>> 1-  s1462 :: SWord8 = s20 | s1461-  s1463 :: SWord8 = s22 & s1461-  s1464 :: SWord8 = if s1455 then s1462 else s1463-  s1465 :: SWord8 = if s18 then s1464 else s1459-  s1466 :: SWord1 = choose [0:0] s1465-  s1467 :: SBool = s15 /= s1466-  s1468 :: SBool = s_2 == s1467-  s1469 :: SWord8 = s1453 >>> 1-  s1470 :: SWord8 = s20 | s1469-  s1471 :: SWord8 = s22 & s1469-  s1472 :: SWord8 = if s1445 then s1470 else s1471-  s1473 :: SWord1 = choose [0:0] s1472-  s1474 :: SBool = s15 /= s1473-  s1475 :: SWord1 = choose [0:0] s1460-  s1476 :: SBool = s15 /= s1475-  s1477 :: SWord8 = s1465 >>> 1-  s1478 :: SWord8 = s20 | s1477-  s1479 :: SWord8 = s22 & s1477-  s1480 :: SWord8 = if s1476 then s1478 else s1479-  s1481 :: SWord8 = if s18 then s1480 else s1464-  s1482 :: SWord8 = s1481 >>> 1-  s1483 :: SWord8 = s20 | s1482-  s1484 :: SWord8 = s22 & s1482-  s1485 :: SWord8 = if s1474 then s1483 else s1484-  s1486 :: SWord8 = if s18 then s1485 else s1480-  s1487 :: SWord1 = choose [0:0] s1486-  s1488 :: SBool = s15 /= s1487-  s1489 :: SBool = s_2 == s1488-  s1490 :: SWord8 = s1472 >>> 1-  s1491 :: SWord8 = s20 | s1490-  s1492 :: SWord8 = s22 & s1490-  s1493 :: SWord8 = if s1467 then s1491 else s1492-  s1494 :: SWord1 = choose [0:0] s1493-  s1495 :: SBool = s15 /= s1494-  s1496 :: SWord1 = choose [0:0] s1481-  s1497 :: SBool = s15 /= s1496-  s1498 :: SWord8 = s1486 >>> 1-  s1499 :: SWord8 = s20 | s1498-  s1500 :: SWord8 = s22 & s1498-  s1501 :: SWord8 = if s1497 then s1499 else s1500-  s1502 :: SWord8 = if s18 then s1501 else s1485-  s1503 :: SWord8 = s1502 >>> 1-  s1504 :: SWord8 = s20 | s1503-  s1505 :: SWord8 = s22 & s1503-  s1506 :: SWord8 = if s1495 then s1504 else s1505-  s1507 :: SWord8 = if s18 then s1506 else s1501-  s1508 :: SWord1 = choose [0:0] s1507-  s1509 :: SBool = s15 /= s1508-  s1510 :: SBool = s_2 == s1509-  s1511 :: SWord8 = s1493 >>> 1-  s1512 :: SWord8 = s20 | s1511-  s1513 :: SWord8 = s22 & s1511-  s1514 :: SWord8 = if s1488 then s1512 else s1513-  s1515 :: SWord8 = s1514 >>> 1-  s1516 :: SWord8 = s20 | s1515-  s1517 :: SWord8 = s22 & s1515-  s1518 :: SWord8 = if s1509 then s1516 else s1517-  s1519 :: SWord1 = choose [0:0] s1502-  s1520 :: SBool = s15 /= s1519-  s1521 :: SWord8 = s1507 >>> 1-  s1522 :: SWord8 = s20 | s1521-  s1523 :: SWord8 = s22 & s1521-  s1524 :: SWord8 = if s1520 then s1522 else s1523-  s1525 :: SWord8 = if s25 then s1442 else s1084-  s1526 :: SWord8 = if s166 then s1459 else s1525-  s1527 :: SWord8 = if s25 then s1464 else s1526-  s1528 :: SWord8 = if s166 then s1480 else s1527-  s1529 :: SWord8 = if s25 then s1485 else s1528-  s1530 :: SWord8 = if s166 then s1501 else s1529-  s1531 :: SWord8 = if s25 then s1506 else s1530-  s1532 :: SWord8 = if s166 then s1524 else s1531-  s1533 :: SWord8 = s1514 + s1532-  s1534 :: SBool = s1533 < s1532-  s1535 :: SBool = s1533 < s1514-  s1536 :: SBool = s1534 | s1535-  s1537 :: SWord8 = s1533 >>> 1-  s1538 :: SWord8 = s20 | s1537-  s1539 :: SWord8 = s22 & s1537-  s1540 :: SWord8 = if s1536 then s1538 else s1539-  s1541 :: SWord8 = if s1510 then s1518 else s1540-  s1542 :: SWord8 = s1493 + s1530-  s1543 :: SWord1 = choose [0:0] s1542-  s1544 :: SBool = s15 /= s1543-  s1545 :: SWord8 = if s1544 then s1504 else s1505-  s1546 :: SWord8 = if s18 then s1545 else s1501-  s1547 :: SWord1 = choose [0:0] s1546-  s1548 :: SBool = s15 /= s1547-  s1549 :: SBool = s_2 == s1548-  s1550 :: SBool = s1542 < s1530-  s1551 :: SBool = s1542 < s1493-  s1552 :: SBool = s1550 | s1551-  s1553 :: SWord8 = s1542 >>> 1-  s1554 :: SWord8 = s20 | s1553-  s1555 :: SWord8 = s22 & s1553-  s1556 :: SWord8 = if s1552 then s1554 else s1555-  s1557 :: SWord8 = s1556 >>> 1-  s1558 :: SWord8 = s20 | s1557-  s1559 :: SWord8 = s22 & s1557-  s1560 :: SWord8 = if s1548 then s1558 else s1559-  s1561 :: SWord8 = s1546 >>> 1-  s1562 :: SWord8 = s20 | s1561-  s1563 :: SWord8 = s22 & s1561-  s1564 :: SWord8 = if s1520 then s1562 else s1563-  s1565 :: SWord8 = if s25 then s1545 else s1530-  s1566 :: SWord8 = if s166 then s1564 else s1565-  s1567 :: SWord8 = s1556 + s1566-  s1568 :: SBool = s1567 < s1566-  s1569 :: SBool = s1567 < s1556-  s1570 :: SBool = s1568 | s1569-  s1571 :: SWord8 = s1567 >>> 1-  s1572 :: SWord8 = s20 | s1571-  s1573 :: SWord8 = s22 & s1571-  s1574 :: SWord8 = if s1570 then s1572 else s1573-  s1575 :: SWord8 = if s1549 then s1560 else s1574-  s1576 :: SWord8 = if s1489 then s1541 else s1575-  s1577 :: SWord8 = s1472 + s1528-  s1578 :: SWord1 = choose [0:0] s1577-  s1579 :: SBool = s15 /= s1578-  s1580 :: SWord8 = if s1579 then s1483 else s1484-  s1581 :: SWord8 = if s18 then s1580 else s1480-  s1582 :: SWord1 = choose [0:0] s1581-  s1583 :: SBool = s15 /= s1582-  s1584 :: SBool = s_2 == s1583-  s1585 :: SBool = s1577 < s1528-  s1586 :: SBool = s1577 < s1472-  s1587 :: SBool = s1585 | s1586-  s1588 :: SWord8 = s1577 >>> 1-  s1589 :: SWord8 = s20 | s1588-  s1590 :: SWord8 = s22 & s1588-  s1591 :: SWord8 = if s1587 then s1589 else s1590-  s1592 :: SWord1 = choose [0:0] s1591-  s1593 :: SBool = s15 /= s1592-  s1594 :: SWord8 = s1581 >>> 1-  s1595 :: SWord8 = s20 | s1594-  s1596 :: SWord8 = s22 & s1594-  s1597 :: SWord8 = if s1497 then s1595 else s1596-  s1598 :: SWord8 = if s18 then s1597 else s1580-  s1599 :: SWord8 = s1598 >>> 1-  s1600 :: SWord8 = s20 | s1599-  s1601 :: SWord8 = s22 & s1599-  s1602 :: SWord8 = if s1593 then s1600 else s1601-  s1603 :: SWord8 = if s18 then s1602 else s1597-  s1604 :: SWord1 = choose [0:0] s1603-  s1605 :: SBool = s15 /= s1604-  s1606 :: SBool = s_2 == s1605-  s1607 :: SWord8 = s1591 >>> 1-  s1608 :: SWord8 = s20 | s1607-  s1609 :: SWord8 = s22 & s1607-  s1610 :: SWord8 = if s1583 then s1608 else s1609-  s1611 :: SWord8 = s1610 >>> 1-  s1612 :: SWord8 = s20 | s1611-  s1613 :: SWord8 = s22 & s1611-  s1614 :: SWord8 = if s1605 then s1612 else s1613-  s1615 :: SWord1 = choose [0:0] s1598-  s1616 :: SBool = s15 /= s1615-  s1617 :: SWord8 = s1603 >>> 1-  s1618 :: SWord8 = s20 | s1617-  s1619 :: SWord8 = s22 & s1617-  s1620 :: SWord8 = if s1616 then s1618 else s1619-  s1621 :: SWord8 = if s25 then s1580 else s1528-  s1622 :: SWord8 = if s166 then s1597 else s1621-  s1623 :: SWord8 = if s25 then s1602 else s1622-  s1624 :: SWord8 = if s166 then s1620 else s1623-  s1625 :: SWord8 = s1610 + s1624-  s1626 :: SBool = s1625 < s1624-  s1627 :: SBool = s1625 < s1610-  s1628 :: SBool = s1626 | s1627-  s1629 :: SWord8 = s1625 >>> 1-  s1630 :: SWord8 = s20 | s1629-  s1631 :: SWord8 = s22 & s1629-  s1632 :: SWord8 = if s1628 then s1630 else s1631-  s1633 :: SWord8 = if s1606 then s1614 else s1632-  s1634 :: SWord8 = s1591 + s1622-  s1635 :: SWord1 = choose [0:0] s1634-  s1636 :: SBool = s15 /= s1635-  s1637 :: SWord8 = if s1636 then s1600 else s1601-  s1638 :: SWord8 = if s18 then s1637 else s1597-  s1639 :: SWord1 = choose [0:0] s1638-  s1640 :: SBool = s15 /= s1639-  s1641 :: SBool = s_2 == s1640-  s1642 :: SBool = s1634 < s1622-  s1643 :: SBool = s1634 < s1591-  s1644 :: SBool = s1642 | s1643-  s1645 :: SWord8 = s1634 >>> 1-  s1646 :: SWord8 = s20 | s1645-  s1647 :: SWord8 = s22 & s1645-  s1648 :: SWord8 = if s1644 then s1646 else s1647-  s1649 :: SWord8 = s1648 >>> 1-  s1650 :: SWord8 = s20 | s1649-  s1651 :: SWord8 = s22 & s1649-  s1652 :: SWord8 = if s1640 then s1650 else s1651-  s1653 :: SWord8 = s1638 >>> 1-  s1654 :: SWord8 = s20 | s1653-  s1655 :: SWord8 = s22 & s1653-  s1656 :: SWord8 = if s1616 then s1654 else s1655-  s1657 :: SWord8 = if s25 then s1637 else s1622-  s1658 :: SWord8 = if s166 then s1656 else s1657-  s1659 :: SWord8 = s1648 + s1658-  s1660 :: SBool = s1659 < s1658-  s1661 :: SBool = s1659 < s1648-  s1662 :: SBool = s1660 | s1661-  s1663 :: SWord8 = s1659 >>> 1-  s1664 :: SWord8 = s20 | s1663-  s1665 :: SWord8 = s22 & s1663-  s1666 :: SWord8 = if s1662 then s1664 else s1665-  s1667 :: SWord8 = if s1641 then s1652 else s1666-  s1668 :: SWord8 = if s1584 then s1633 else s1667-  s1669 :: SWord8 = if s1468 then s1576 else s1668-  s1670 :: SWord8 = s1453 + s1526-  s1671 :: SWord1 = choose [0:0] s1670-  s1672 :: SBool = s15 /= s1671-  s1673 :: SWord8 = if s1672 then s1462 else s1463-  s1674 :: SWord8 = if s18 then s1673 else s1459-  s1675 :: SWord1 = choose [0:0] s1674-  s1676 :: SBool = s15 /= s1675-  s1677 :: SBool = s_2 == s1676-  s1678 :: SBool = s1670 < s1526-  s1679 :: SBool = s1670 < s1453-  s1680 :: SBool = s1678 | s1679-  s1681 :: SWord8 = s1670 >>> 1-  s1682 :: SWord8 = s20 | s1681-  s1683 :: SWord8 = s22 & s1681-  s1684 :: SWord8 = if s1680 then s1682 else s1683-  s1685 :: SWord1 = choose [0:0] s1684-  s1686 :: SBool = s15 /= s1685-  s1687 :: SWord8 = s1674 >>> 1-  s1688 :: SWord8 = s20 | s1687-  s1689 :: SWord8 = s22 & s1687-  s1690 :: SWord8 = if s1476 then s1688 else s1689-  s1691 :: SWord8 = if s18 then s1690 else s1673-  s1692 :: SWord8 = s1691 >>> 1-  s1693 :: SWord8 = s20 | s1692-  s1694 :: SWord8 = s22 & s1692-  s1695 :: SWord8 = if s1686 then s1693 else s1694-  s1696 :: SWord8 = if s18 then s1695 else s1690-  s1697 :: SWord1 = choose [0:0] s1696-  s1698 :: SBool = s15 /= s1697-  s1699 :: SBool = s_2 == s1698-  s1700 :: SWord8 = s1684 >>> 1-  s1701 :: SWord8 = s20 | s1700-  s1702 :: SWord8 = s22 & s1700-  s1703 :: SWord8 = if s1676 then s1701 else s1702-  s1704 :: SWord1 = choose [0:0] s1703-  s1705 :: SBool = s15 /= s1704-  s1706 :: SWord1 = choose [0:0] s1691-  s1707 :: SBool = s15 /= s1706-  s1708 :: SWord8 = s1696 >>> 1-  s1709 :: SWord8 = s20 | s1708-  s1710 :: SWord8 = s22 & s1708-  s1711 :: SWord8 = if s1707 then s1709 else s1710-  s1712 :: SWord8 = if s18 then s1711 else s1695-  s1713 :: SWord8 = s1712 >>> 1-  s1714 :: SWord8 = s20 | s1713-  s1715 :: SWord8 = s22 & s1713-  s1716 :: SWord8 = if s1705 then s1714 else s1715-  s1717 :: SWord8 = if s18 then s1716 else s1711-  s1718 :: SWord1 = choose [0:0] s1717-  s1719 :: SBool = s15 /= s1718-  s1720 :: SBool = s_2 == s1719-  s1721 :: SWord8 = s1703 >>> 1-  s1722 :: SWord8 = s20 | s1721-  s1723 :: SWord8 = s22 & s1721-  s1724 :: SWord8 = if s1698 then s1722 else s1723-  s1725 :: SWord8 = s1724 >>> 1-  s1726 :: SWord8 = s20 | s1725-  s1727 :: SWord8 = s22 & s1725-  s1728 :: SWord8 = if s1719 then s1726 else s1727-  s1729 :: SWord1 = choose [0:0] s1712-  s1730 :: SBool = s15 /= s1729-  s1731 :: SWord8 = s1717 >>> 1-  s1732 :: SWord8 = s20 | s1731-  s1733 :: SWord8 = s22 & s1731-  s1734 :: SWord8 = if s1730 then s1732 else s1733-  s1735 :: SWord8 = if s25 then s1673 else s1526-  s1736 :: SWord8 = if s166 then s1690 else s1735-  s1737 :: SWord8 = if s25 then s1695 else s1736-  s1738 :: SWord8 = if s166 then s1711 else s1737-  s1739 :: SWord8 = if s25 then s1716 else s1738-  s1740 :: SWord8 = if s166 then s1734 else s1739-  s1741 :: SWord8 = s1724 + s1740-  s1742 :: SBool = s1741 < s1740-  s1743 :: SBool = s1741 < s1724-  s1744 :: SBool = s1742 | s1743-  s1745 :: SWord8 = s1741 >>> 1-  s1746 :: SWord8 = s20 | s1745-  s1747 :: SWord8 = s22 & s1745-  s1748 :: SWord8 = if s1744 then s1746 else s1747-  s1749 :: SWord8 = if s1720 then s1728 else s1748-  s1750 :: SWord8 = s1703 + s1738-  s1751 :: SWord1 = choose [0:0] s1750-  s1752 :: SBool = s15 /= s1751-  s1753 :: SWord8 = if s1752 then s1714 else s1715-  s1754 :: SWord8 = if s18 then s1753 else s1711-  s1755 :: SWord1 = choose [0:0] s1754-  s1756 :: SBool = s15 /= s1755-  s1757 :: SBool = s_2 == s1756-  s1758 :: SBool = s1750 < s1738-  s1759 :: SBool = s1750 < s1703-  s1760 :: SBool = s1758 | s1759-  s1761 :: SWord8 = s1750 >>> 1-  s1762 :: SWord8 = s20 | s1761-  s1763 :: SWord8 = s22 & s1761-  s1764 :: SWord8 = if s1760 then s1762 else s1763-  s1765 :: SWord8 = s1764 >>> 1-  s1766 :: SWord8 = s20 | s1765-  s1767 :: SWord8 = s22 & s1765-  s1768 :: SWord8 = if s1756 then s1766 else s1767-  s1769 :: SWord8 = s1754 >>> 1-  s1770 :: SWord8 = s20 | s1769-  s1771 :: SWord8 = s22 & s1769-  s1772 :: SWord8 = if s1730 then s1770 else s1771-  s1773 :: SWord8 = if s25 then s1753 else s1738-  s1774 :: SWord8 = if s166 then s1772 else s1773-  s1775 :: SWord8 = s1764 + s1774-  s1776 :: SBool = s1775 < s1774-  s1777 :: SBool = s1775 < s1764-  s1778 :: SBool = s1776 | s1777-  s1779 :: SWord8 = s1775 >>> 1-  s1780 :: SWord8 = s20 | s1779-  s1781 :: SWord8 = s22 & s1779-  s1782 :: SWord8 = if s1778 then s1780 else s1781-  s1783 :: SWord8 = if s1757 then s1768 else s1782-  s1784 :: SWord8 = if s1699 then s1749 else s1783-  s1785 :: SWord8 = s1684 + s1736-  s1786 :: SWord1 = choose [0:0] s1785-  s1787 :: SBool = s15 /= s1786-  s1788 :: SWord8 = if s1787 then s1693 else s1694-  s1789 :: SWord8 = if s18 then s1788 else s1690-  s1790 :: SWord1 = choose [0:0] s1789-  s1791 :: SBool = s15 /= s1790-  s1792 :: SBool = s_2 == s1791-  s1793 :: SBool = s1785 < s1736-  s1794 :: SBool = s1785 < s1684-  s1795 :: SBool = s1793 | s1794-  s1796 :: SWord8 = s1785 >>> 1-  s1797 :: SWord8 = s20 | s1796-  s1798 :: SWord8 = s22 & s1796-  s1799 :: SWord8 = if s1795 then s1797 else s1798-  s1800 :: SWord1 = choose [0:0] s1799-  s1801 :: SBool = s15 /= s1800-  s1802 :: SWord8 = s1789 >>> 1-  s1803 :: SWord8 = s20 | s1802-  s1804 :: SWord8 = s22 & s1802-  s1805 :: SWord8 = if s1707 then s1803 else s1804-  s1806 :: SWord8 = if s18 then s1805 else s1788-  s1807 :: SWord8 = s1806 >>> 1-  s1808 :: SWord8 = s20 | s1807-  s1809 :: SWord8 = s22 & s1807-  s1810 :: SWord8 = if s1801 then s1808 else s1809-  s1811 :: SWord8 = if s18 then s1810 else s1805-  s1812 :: SWord1 = choose [0:0] s1811-  s1813 :: SBool = s15 /= s1812-  s1814 :: SBool = s_2 == s1813-  s1815 :: SWord8 = s1799 >>> 1-  s1816 :: SWord8 = s20 | s1815-  s1817 :: SWord8 = s22 & s1815-  s1818 :: SWord8 = if s1791 then s1816 else s1817-  s1819 :: SWord8 = s1818 >>> 1-  s1820 :: SWord8 = s20 | s1819-  s1821 :: SWord8 = s22 & s1819-  s1822 :: SWord8 = if s1813 then s1820 else s1821-  s1823 :: SWord1 = choose [0:0] s1806-  s1824 :: SBool = s15 /= s1823-  s1825 :: SWord8 = s1811 >>> 1-  s1826 :: SWord8 = s20 | s1825-  s1827 :: SWord8 = s22 & s1825-  s1828 :: SWord8 = if s1824 then s1826 else s1827-  s1829 :: SWord8 = if s25 then s1788 else s1736-  s1830 :: SWord8 = if s166 then s1805 else s1829-  s1831 :: SWord8 = if s25 then s1810 else s1830-  s1832 :: SWord8 = if s166 then s1828 else s1831-  s1833 :: SWord8 = s1818 + s1832-  s1834 :: SBool = s1833 < s1832-  s1835 :: SBool = s1833 < s1818-  s1836 :: SBool = s1834 | s1835-  s1837 :: SWord8 = s1833 >>> 1-  s1838 :: SWord8 = s20 | s1837-  s1839 :: SWord8 = s22 & s1837-  s1840 :: SWord8 = if s1836 then s1838 else s1839-  s1841 :: SWord8 = if s1814 then s1822 else s1840-  s1842 :: SWord8 = s1799 + s1830-  s1843 :: SWord1 = choose [0:0] s1842-  s1844 :: SBool = s15 /= s1843-  s1845 :: SWord8 = if s1844 then s1808 else s1809-  s1846 :: SWord8 = if s18 then s1845 else s1805-  s1847 :: SWord1 = choose [0:0] s1846-  s1848 :: SBool = s15 /= s1847-  s1849 :: SBool = s_2 == s1848-  s1850 :: SBool = s1842 < s1830-  s1851 :: SBool = s1842 < s1799-  s1852 :: SBool = s1850 | s1851-  s1853 :: SWord8 = s1842 >>> 1-  s1854 :: SWord8 = s20 | s1853-  s1855 :: SWord8 = s22 & s1853-  s1856 :: SWord8 = if s1852 then s1854 else s1855-  s1857 :: SWord8 = s1856 >>> 1-  s1858 :: SWord8 = s20 | s1857-  s1859 :: SWord8 = s22 & s1857-  s1860 :: SWord8 = if s1848 then s1858 else s1859-  s1861 :: SWord8 = s1846 >>> 1-  s1862 :: SWord8 = s20 | s1861-  s1863 :: SWord8 = s22 & s1861-  s1864 :: SWord8 = if s1824 then s1862 else s1863-  s1865 :: SWord8 = if s25 then s1845 else s1830-  s1866 :: SWord8 = if s166 then s1864 else s1865-  s1867 :: SWord8 = s1856 + s1866-  s1868 :: SBool = s1867 < s1866-  s1869 :: SBool = s1867 < s1856-  s1870 :: SBool = s1868 | s1869-  s1871 :: SWord8 = s1867 >>> 1-  s1872 :: SWord8 = s20 | s1871-  s1873 :: SWord8 = s22 & s1871-  s1874 :: SWord8 = if s1870 then s1872 else s1873-  s1875 :: SWord8 = if s1849 then s1860 else s1874-  s1876 :: SWord8 = if s1792 then s1841 else s1875-  s1877 :: SWord8 = if s1677 then s1784 else s1876-  s1878 :: SWord8 = if s1446 then s1669 else s1877-  s1879 :: SWord8 = if s983 then s1438 else s1878-  s1880 :: SWord8 = if s52 then s975 else s1879-  s1881 :: SWord8 = s35 + s176-  s1882 :: SWord1 = choose [0:0] s1881-  s1883 :: SBool = s15 /= s1882-  s1884 :: SWord8 = if s1883 then s46 else s47-  s1885 :: SWord8 = if s18 then s1884 else s43-  s1886 :: SWord1 = choose [0:0] s1885-  s1887 :: SBool = s15 /= s1886-  s1888 :: SBool = s_2 == s1887-  s1889 :: SBool = s1881 < s176-  s1890 :: SBool = s1881 < s35-  s1891 :: SBool = s1889 | s1890-  s1892 :: SWord8 = s1881 >>> 1-  s1893 :: SWord8 = s20 | s1892-  s1894 :: SWord8 = s22 & s1892-  s1895 :: SWord8 = if s1891 then s1893 else s1894-  s1896 :: SWord1 = choose [0:0] s1895-  s1897 :: SBool = s15 /= s1896-  s1898 :: SWord8 = s1885 >>> 1-  s1899 :: SWord8 = s20 | s1898-  s1900 :: SWord8 = s22 & s1898-  s1901 :: SWord8 = if s60 then s1899 else s1900-  s1902 :: SWord8 = if s18 then s1901 else s1884-  s1903 :: SWord8 = s1902 >>> 1-  s1904 :: SWord8 = s20 | s1903-  s1905 :: SWord8 = s22 & s1903-  s1906 :: SWord8 = if s1897 then s1904 else s1905-  s1907 :: SWord8 = if s18 then s1906 else s1901-  s1908 :: SWord1 = choose [0:0] s1907-  s1909 :: SBool = s15 /= s1908-  s1910 :: SBool = s_2 == s1909-  s1911 :: SWord8 = s1895 >>> 1-  s1912 :: SWord8 = s20 | s1911-  s1913 :: SWord8 = s22 & s1911-  s1914 :: SWord8 = if s1887 then s1912 else s1913-  s1915 :: SWord1 = choose [0:0] s1914-  s1916 :: SBool = s15 /= s1915-  s1917 :: SWord1 = choose [0:0] s1902-  s1918 :: SBool = s15 /= s1917-  s1919 :: SWord8 = s1907 >>> 1-  s1920 :: SWord8 = s20 | s1919-  s1921 :: SWord8 = s22 & s1919-  s1922 :: SWord8 = if s1918 then s1920 else s1921-  s1923 :: SWord8 = if s18 then s1922 else s1906-  s1924 :: SWord8 = s1923 >>> 1-  s1925 :: SWord8 = s20 | s1924-  s1926 :: SWord8 = s22 & s1924-  s1927 :: SWord8 = if s1916 then s1925 else s1926-  s1928 :: SWord8 = if s18 then s1927 else s1922-  s1929 :: SWord1 = choose [0:0] s1928-  s1930 :: SBool = s15 /= s1929-  s1931 :: SBool = s_2 == s1930-  s1932 :: SWord8 = s1914 >>> 1-  s1933 :: SWord8 = s20 | s1932-  s1934 :: SWord8 = s22 & s1932-  s1935 :: SWord8 = if s1909 then s1933 else s1934-  s1936 :: SWord1 = choose [0:0] s1935-  s1937 :: SBool = s15 /= s1936-  s1938 :: SWord1 = choose [0:0] s1923-  s1939 :: SBool = s15 /= s1938-  s1940 :: SWord8 = s1928 >>> 1-  s1941 :: SWord8 = s20 | s1940-  s1942 :: SWord8 = s22 & s1940-  s1943 :: SWord8 = if s1939 then s1941 else s1942-  s1944 :: SWord8 = if s18 then s1943 else s1927-  s1945 :: SWord8 = s1944 >>> 1-  s1946 :: SWord8 = s20 | s1945-  s1947 :: SWord8 = s22 & s1945-  s1948 :: SWord8 = if s1937 then s1946 else s1947-  s1949 :: SWord8 = if s18 then s1948 else s1943-  s1950 :: SWord1 = choose [0:0] s1949-  s1951 :: SBool = s15 /= s1950-  s1952 :: SBool = s_2 == s1951-  s1953 :: SWord8 = s1935 >>> 1-  s1954 :: SWord8 = s20 | s1953-  s1955 :: SWord8 = s22 & s1953-  s1956 :: SWord8 = if s1930 then s1954 else s1955-  s1957 :: SWord1 = choose [0:0] s1956-  s1958 :: SBool = s15 /= s1957-  s1959 :: SWord1 = choose [0:0] s1944-  s1960 :: SBool = s15 /= s1959-  s1961 :: SWord8 = s1949 >>> 1-  s1962 :: SWord8 = s20 | s1961-  s1963 :: SWord8 = s22 & s1961-  s1964 :: SWord8 = if s1960 then s1962 else s1963-  s1965 :: SWord8 = if s18 then s1964 else s1948-  s1966 :: SWord8 = s1965 >>> 1-  s1967 :: SWord8 = s20 | s1966-  s1968 :: SWord8 = s22 & s1966-  s1969 :: SWord8 = if s1958 then s1967 else s1968-  s1970 :: SWord8 = if s18 then s1969 else s1964-  s1971 :: SWord1 = choose [0:0] s1970-  s1972 :: SBool = s15 /= s1971-  s1973 :: SBool = s_2 == s1972-  s1974 :: SWord8 = s1956 >>> 1-  s1975 :: SWord8 = s20 | s1974-  s1976 :: SWord8 = s22 & s1974-  s1977 :: SWord8 = if s1951 then s1975 else s1976-  s1978 :: SWord1 = choose [0:0] s1977-  s1979 :: SBool = s15 /= s1978-  s1980 :: SWord1 = choose [0:0] s1965-  s1981 :: SBool = s15 /= s1980-  s1982 :: SWord8 = s1970 >>> 1-  s1983 :: SWord8 = s20 | s1982-  s1984 :: SWord8 = s22 & s1982-  s1985 :: SWord8 = if s1981 then s1983 else s1984-  s1986 :: SWord8 = if s18 then s1985 else s1969-  s1987 :: SWord8 = s1986 >>> 1-  s1988 :: SWord8 = s20 | s1987-  s1989 :: SWord8 = s22 & s1987-  s1990 :: SWord8 = if s1979 then s1988 else s1989-  s1991 :: SWord8 = if s18 then s1990 else s1985-  s1992 :: SWord1 = choose [0:0] s1991-  s1993 :: SBool = s15 /= s1992-  s1994 :: SBool = s_2 == s1993-  s1995 :: SWord8 = s1977 >>> 1-  s1996 :: SWord8 = s20 | s1995-  s1997 :: SWord8 = s22 & s1995-  s1998 :: SWord8 = if s1972 then s1996 else s1997-  s1999 :: SWord8 = s1998 >>> 1-  s2000 :: SWord8 = s20 | s1999-  s2001 :: SWord8 = s22 & s1999-  s2002 :: SWord8 = if s1993 then s2000 else s2001-  s2003 :: SWord1 = choose [0:0] s1986-  s2004 :: SBool = s15 /= s2003-  s2005 :: SWord8 = s1991 >>> 1-  s2006 :: SWord8 = s20 | s2005-  s2007 :: SWord8 = s22 & s2005-  s2008 :: SWord8 = if s2004 then s2006 else s2007-  s2009 :: SWord8 = if s25 then s1884 else s176-  s2010 :: SWord8 = if s166 then s1901 else s2009-  s2011 :: SWord8 = if s25 then s1906 else s2010-  s2012 :: SWord8 = if s166 then s1922 else s2011-  s2013 :: SWord8 = if s25 then s1927 else s2012-  s2014 :: SWord8 = if s166 then s1943 else s2013-  s2015 :: SWord8 = if s25 then s1948 else s2014-  s2016 :: SWord8 = if s166 then s1964 else s2015-  s2017 :: SWord8 = if s25 then s1969 else s2016-  s2018 :: SWord8 = if s166 then s1985 else s2017-  s2019 :: SWord8 = if s25 then s1990 else s2018-  s2020 :: SWord8 = if s166 then s2008 else s2019-  s2021 :: SWord8 = s1998 + s2020-  s2022 :: SBool = s2021 < s2020-  s2023 :: SBool = s2021 < s1998-  s2024 :: SBool = s2022 | s2023-  s2025 :: SWord8 = s2021 >>> 1-  s2026 :: SWord8 = s20 | s2025-  s2027 :: SWord8 = s22 & s2025-  s2028 :: SWord8 = if s2024 then s2026 else s2027-  s2029 :: SWord8 = if s1994 then s2002 else s2028-  s2030 :: SWord8 = s1977 + s2018-  s2031 :: SWord1 = choose [0:0] s2030-  s2032 :: SBool = s15 /= s2031-  s2033 :: SWord8 = if s2032 then s1988 else s1989-  s2034 :: SWord8 = if s18 then s2033 else s1985-  s2035 :: SWord1 = choose [0:0] s2034-  s2036 :: SBool = s15 /= s2035-  s2037 :: SBool = s_2 == s2036-  s2038 :: SBool = s2030 < s2018-  s2039 :: SBool = s2030 < s1977-  s2040 :: SBool = s2038 | s2039-  s2041 :: SWord8 = s2030 >>> 1-  s2042 :: SWord8 = s20 | s2041-  s2043 :: SWord8 = s22 & s2041-  s2044 :: SWord8 = if s2040 then s2042 else s2043-  s2045 :: SWord8 = s2044 >>> 1-  s2046 :: SWord8 = s20 | s2045-  s2047 :: SWord8 = s22 & s2045-  s2048 :: SWord8 = if s2036 then s2046 else s2047-  s2049 :: SWord8 = s2034 >>> 1-  s2050 :: SWord8 = s20 | s2049-  s2051 :: SWord8 = s22 & s2049-  s2052 :: SWord8 = if s2004 then s2050 else s2051-  s2053 :: SWord8 = if s25 then s2033 else s2018-  s2054 :: SWord8 = if s166 then s2052 else s2053-  s2055 :: SWord8 = s2044 + s2054-  s2056 :: SBool = s2055 < s2054-  s2057 :: SBool = s2055 < s2044-  s2058 :: SBool = s2056 | s2057-  s2059 :: SWord8 = s2055 >>> 1-  s2060 :: SWord8 = s20 | s2059-  s2061 :: SWord8 = s22 & s2059-  s2062 :: SWord8 = if s2058 then s2060 else s2061-  s2063 :: SWord8 = if s2037 then s2048 else s2062-  s2064 :: SWord8 = if s1973 then s2029 else s2063-  s2065 :: SWord8 = s1956 + s2016-  s2066 :: SWord1 = choose [0:0] s2065-  s2067 :: SBool = s15 /= s2066-  s2068 :: SWord8 = if s2067 then s1967 else s1968-  s2069 :: SWord8 = if s18 then s2068 else s1964-  s2070 :: SWord1 = choose [0:0] s2069-  s2071 :: SBool = s15 /= s2070-  s2072 :: SBool = s_2 == s2071-  s2073 :: SBool = s2065 < s2016-  s2074 :: SBool = s2065 < s1956-  s2075 :: SBool = s2073 | s2074-  s2076 :: SWord8 = s2065 >>> 1-  s2077 :: SWord8 = s20 | s2076-  s2078 :: SWord8 = s22 & s2076-  s2079 :: SWord8 = if s2075 then s2077 else s2078-  s2080 :: SWord1 = choose [0:0] s2079-  s2081 :: SBool = s15 /= s2080-  s2082 :: SWord8 = s2069 >>> 1-  s2083 :: SWord8 = s20 | s2082-  s2084 :: SWord8 = s22 & s2082-  s2085 :: SWord8 = if s1981 then s2083 else s2084-  s2086 :: SWord8 = if s18 then s2085 else s2068-  s2087 :: SWord8 = s2086 >>> 1-  s2088 :: SWord8 = s20 | s2087-  s2089 :: SWord8 = s22 & s2087-  s2090 :: SWord8 = if s2081 then s2088 else s2089-  s2091 :: SWord8 = if s18 then s2090 else s2085-  s2092 :: SWord1 = choose [0:0] s2091-  s2093 :: SBool = s15 /= s2092-  s2094 :: SBool = s_2 == s2093-  s2095 :: SWord8 = s2079 >>> 1-  s2096 :: SWord8 = s20 | s2095-  s2097 :: SWord8 = s22 & s2095-  s2098 :: SWord8 = if s2071 then s2096 else s2097-  s2099 :: SWord8 = s2098 >>> 1-  s2100 :: SWord8 = s20 | s2099-  s2101 :: SWord8 = s22 & s2099-  s2102 :: SWord8 = if s2093 then s2100 else s2101-  s2103 :: SWord1 = choose [0:0] s2086-  s2104 :: SBool = s15 /= s2103-  s2105 :: SWord8 = s2091 >>> 1-  s2106 :: SWord8 = s20 | s2105-  s2107 :: SWord8 = s22 & s2105-  s2108 :: SWord8 = if s2104 then s2106 else s2107-  s2109 :: SWord8 = if s25 then s2068 else s2016-  s2110 :: SWord8 = if s166 then s2085 else s2109-  s2111 :: SWord8 = if s25 then s2090 else s2110-  s2112 :: SWord8 = if s166 then s2108 else s2111-  s2113 :: SWord8 = s2098 + s2112-  s2114 :: SBool = s2113 < s2112-  s2115 :: SBool = s2113 < s2098-  s2116 :: SBool = s2114 | s2115-  s2117 :: SWord8 = s2113 >>> 1-  s2118 :: SWord8 = s20 | s2117-  s2119 :: SWord8 = s22 & s2117-  s2120 :: SWord8 = if s2116 then s2118 else s2119-  s2121 :: SWord8 = if s2094 then s2102 else s2120-  s2122 :: SWord8 = s2079 + s2110-  s2123 :: SWord1 = choose [0:0] s2122-  s2124 :: SBool = s15 /= s2123-  s2125 :: SWord8 = if s2124 then s2088 else s2089-  s2126 :: SWord8 = if s18 then s2125 else s2085-  s2127 :: SWord1 = choose [0:0] s2126-  s2128 :: SBool = s15 /= s2127-  s2129 :: SBool = s_2 == s2128-  s2130 :: SBool = s2122 < s2110-  s2131 :: SBool = s2122 < s2079-  s2132 :: SBool = s2130 | s2131-  s2133 :: SWord8 = s2122 >>> 1-  s2134 :: SWord8 = s20 | s2133-  s2135 :: SWord8 = s22 & s2133-  s2136 :: SWord8 = if s2132 then s2134 else s2135-  s2137 :: SWord8 = s2136 >>> 1-  s2138 :: SWord8 = s20 | s2137-  s2139 :: SWord8 = s22 & s2137-  s2140 :: SWord8 = if s2128 then s2138 else s2139-  s2141 :: SWord8 = s2126 >>> 1-  s2142 :: SWord8 = s20 | s2141-  s2143 :: SWord8 = s22 & s2141-  s2144 :: SWord8 = if s2104 then s2142 else s2143-  s2145 :: SWord8 = if s25 then s2125 else s2110-  s2146 :: SWord8 = if s166 then s2144 else s2145-  s2147 :: SWord8 = s2136 + s2146-  s2148 :: SBool = s2147 < s2146-  s2149 :: SBool = s2147 < s2136-  s2150 :: SBool = s2148 | s2149-  s2151 :: SWord8 = s2147 >>> 1-  s2152 :: SWord8 = s20 | s2151-  s2153 :: SWord8 = s22 & s2151-  s2154 :: SWord8 = if s2150 then s2152 else s2153-  s2155 :: SWord8 = if s2129 then s2140 else s2154-  s2156 :: SWord8 = if s2072 then s2121 else s2155-  s2157 :: SWord8 = if s1952 then s2064 else s2156-  s2158 :: SWord8 = s1935 + s2014-  s2159 :: SWord1 = choose [0:0] s2158-  s2160 :: SBool = s15 /= s2159-  s2161 :: SWord8 = if s2160 then s1946 else s1947-  s2162 :: SWord8 = if s18 then s2161 else s1943-  s2163 :: SWord1 = choose [0:0] s2162-  s2164 :: SBool = s15 /= s2163-  s2165 :: SBool = s_2 == s2164-  s2166 :: SBool = s2158 < s2014-  s2167 :: SBool = s2158 < s1935-  s2168 :: SBool = s2166 | s2167-  s2169 :: SWord8 = s2158 >>> 1-  s2170 :: SWord8 = s20 | s2169-  s2171 :: SWord8 = s22 & s2169-  s2172 :: SWord8 = if s2168 then s2170 else s2171-  s2173 :: SWord1 = choose [0:0] s2172-  s2174 :: SBool = s15 /= s2173-  s2175 :: SWord8 = s2162 >>> 1-  s2176 :: SWord8 = s20 | s2175-  s2177 :: SWord8 = s22 & s2175-  s2178 :: SWord8 = if s1960 then s2176 else s2177-  s2179 :: SWord8 = if s18 then s2178 else s2161-  s2180 :: SWord8 = s2179 >>> 1-  s2181 :: SWord8 = s20 | s2180-  s2182 :: SWord8 = s22 & s2180-  s2183 :: SWord8 = if s2174 then s2181 else s2182-  s2184 :: SWord8 = if s18 then s2183 else s2178-  s2185 :: SWord1 = choose [0:0] s2184-  s2186 :: SBool = s15 /= s2185-  s2187 :: SBool = s_2 == s2186-  s2188 :: SWord8 = s2172 >>> 1-  s2189 :: SWord8 = s20 | s2188-  s2190 :: SWord8 = s22 & s2188-  s2191 :: SWord8 = if s2164 then s2189 else s2190-  s2192 :: SWord1 = choose [0:0] s2191-  s2193 :: SBool = s15 /= s2192-  s2194 :: SWord1 = choose [0:0] s2179-  s2195 :: SBool = s15 /= s2194-  s2196 :: SWord8 = s2184 >>> 1-  s2197 :: SWord8 = s20 | s2196-  s2198 :: SWord8 = s22 & s2196-  s2199 :: SWord8 = if s2195 then s2197 else s2198-  s2200 :: SWord8 = if s18 then s2199 else s2183-  s2201 :: SWord8 = s2200 >>> 1-  s2202 :: SWord8 = s20 | s2201-  s2203 :: SWord8 = s22 & s2201-  s2204 :: SWord8 = if s2193 then s2202 else s2203-  s2205 :: SWord8 = if s18 then s2204 else s2199-  s2206 :: SWord1 = choose [0:0] s2205-  s2207 :: SBool = s15 /= s2206-  s2208 :: SBool = s_2 == s2207-  s2209 :: SWord8 = s2191 >>> 1-  s2210 :: SWord8 = s20 | s2209-  s2211 :: SWord8 = s22 & s2209-  s2212 :: SWord8 = if s2186 then s2210 else s2211-  s2213 :: SWord8 = s2212 >>> 1-  s2214 :: SWord8 = s20 | s2213-  s2215 :: SWord8 = s22 & s2213-  s2216 :: SWord8 = if s2207 then s2214 else s2215-  s2217 :: SWord1 = choose [0:0] s2200-  s2218 :: SBool = s15 /= s2217-  s2219 :: SWord8 = s2205 >>> 1-  s2220 :: SWord8 = s20 | s2219-  s2221 :: SWord8 = s22 & s2219-  s2222 :: SWord8 = if s2218 then s2220 else s2221-  s2223 :: SWord8 = if s25 then s2161 else s2014-  s2224 :: SWord8 = if s166 then s2178 else s2223-  s2225 :: SWord8 = if s25 then s2183 else s2224-  s2226 :: SWord8 = if s166 then s2199 else s2225-  s2227 :: SWord8 = if s25 then s2204 else s2226-  s2228 :: SWord8 = if s166 then s2222 else s2227-  s2229 :: SWord8 = s2212 + s2228-  s2230 :: SBool = s2229 < s2228-  s2231 :: SBool = s2229 < s2212-  s2232 :: SBool = s2230 | s2231-  s2233 :: SWord8 = s2229 >>> 1-  s2234 :: SWord8 = s20 | s2233-  s2235 :: SWord8 = s22 & s2233-  s2236 :: SWord8 = if s2232 then s2234 else s2235-  s2237 :: SWord8 = if s2208 then s2216 else s2236-  s2238 :: SWord8 = s2191 + s2226-  s2239 :: SWord1 = choose [0:0] s2238-  s2240 :: SBool = s15 /= s2239-  s2241 :: SWord8 = if s2240 then s2202 else s2203-  s2242 :: SWord8 = if s18 then s2241 else s2199-  s2243 :: SWord1 = choose [0:0] s2242-  s2244 :: SBool = s15 /= s2243-  s2245 :: SBool = s_2 == s2244-  s2246 :: SBool = s2238 < s2226-  s2247 :: SBool = s2238 < s2191-  s2248 :: SBool = s2246 | s2247-  s2249 :: SWord8 = s2238 >>> 1-  s2250 :: SWord8 = s20 | s2249-  s2251 :: SWord8 = s22 & s2249-  s2252 :: SWord8 = if s2248 then s2250 else s2251-  s2253 :: SWord8 = s2252 >>> 1-  s2254 :: SWord8 = s20 | s2253-  s2255 :: SWord8 = s22 & s2253-  s2256 :: SWord8 = if s2244 then s2254 else s2255-  s2257 :: SWord8 = s2242 >>> 1-  s2258 :: SWord8 = s20 | s2257-  s2259 :: SWord8 = s22 & s2257-  s2260 :: SWord8 = if s2218 then s2258 else s2259-  s2261 :: SWord8 = if s25 then s2241 else s2226-  s2262 :: SWord8 = if s166 then s2260 else s2261-  s2263 :: SWord8 = s2252 + s2262-  s2264 :: SBool = s2263 < s2262-  s2265 :: SBool = s2263 < s2252-  s2266 :: SBool = s2264 | s2265-  s2267 :: SWord8 = s2263 >>> 1-  s2268 :: SWord8 = s20 | s2267-  s2269 :: SWord8 = s22 & s2267-  s2270 :: SWord8 = if s2266 then s2268 else s2269-  s2271 :: SWord8 = if s2245 then s2256 else s2270-  s2272 :: SWord8 = if s2187 then s2237 else s2271-  s2273 :: SWord8 = s2172 + s2224-  s2274 :: SWord1 = choose [0:0] s2273-  s2275 :: SBool = s15 /= s2274-  s2276 :: SWord8 = if s2275 then s2181 else s2182-  s2277 :: SWord8 = if s18 then s2276 else s2178-  s2278 :: SWord1 = choose [0:0] s2277-  s2279 :: SBool = s15 /= s2278-  s2280 :: SBool = s_2 == s2279-  s2281 :: SBool = s2273 < s2224-  s2282 :: SBool = s2273 < s2172-  s2283 :: SBool = s2281 | s2282-  s2284 :: SWord8 = s2273 >>> 1-  s2285 :: SWord8 = s20 | s2284-  s2286 :: SWord8 = s22 & s2284-  s2287 :: SWord8 = if s2283 then s2285 else s2286-  s2288 :: SWord1 = choose [0:0] s2287-  s2289 :: SBool = s15 /= s2288-  s2290 :: SWord8 = s2277 >>> 1-  s2291 :: SWord8 = s20 | s2290-  s2292 :: SWord8 = s22 & s2290-  s2293 :: SWord8 = if s2195 then s2291 else s2292-  s2294 :: SWord8 = if s18 then s2293 else s2276-  s2295 :: SWord8 = s2294 >>> 1-  s2296 :: SWord8 = s20 | s2295-  s2297 :: SWord8 = s22 & s2295-  s2298 :: SWord8 = if s2289 then s2296 else s2297-  s2299 :: SWord8 = if s18 then s2298 else s2293-  s2300 :: SWord1 = choose [0:0] s2299-  s2301 :: SBool = s15 /= s2300-  s2302 :: SBool = s_2 == s2301-  s2303 :: SWord8 = s2287 >>> 1-  s2304 :: SWord8 = s20 | s2303-  s2305 :: SWord8 = s22 & s2303-  s2306 :: SWord8 = if s2279 then s2304 else s2305-  s2307 :: SWord8 = s2306 >>> 1-  s2308 :: SWord8 = s20 | s2307-  s2309 :: SWord8 = s22 & s2307-  s2310 :: SWord8 = if s2301 then s2308 else s2309-  s2311 :: SWord1 = choose [0:0] s2294-  s2312 :: SBool = s15 /= s2311-  s2313 :: SWord8 = s2299 >>> 1-  s2314 :: SWord8 = s20 | s2313-  s2315 :: SWord8 = s22 & s2313-  s2316 :: SWord8 = if s2312 then s2314 else s2315-  s2317 :: SWord8 = if s25 then s2276 else s2224-  s2318 :: SWord8 = if s166 then s2293 else s2317-  s2319 :: SWord8 = if s25 then s2298 else s2318-  s2320 :: SWord8 = if s166 then s2316 else s2319-  s2321 :: SWord8 = s2306 + s2320-  s2322 :: SBool = s2321 < s2320-  s2323 :: SBool = s2321 < s2306-  s2324 :: SBool = s2322 | s2323-  s2325 :: SWord8 = s2321 >>> 1-  s2326 :: SWord8 = s20 | s2325-  s2327 :: SWord8 = s22 & s2325-  s2328 :: SWord8 = if s2324 then s2326 else s2327-  s2329 :: SWord8 = if s2302 then s2310 else s2328-  s2330 :: SWord8 = s2287 + s2318-  s2331 :: SWord1 = choose [0:0] s2330-  s2332 :: SBool = s15 /= s2331-  s2333 :: SWord8 = if s2332 then s2296 else s2297-  s2334 :: SWord8 = if s18 then s2333 else s2293-  s2335 :: SWord1 = choose [0:0] s2334-  s2336 :: SBool = s15 /= s2335-  s2337 :: SBool = s_2 == s2336-  s2338 :: SBool = s2330 < s2318-  s2339 :: SBool = s2330 < s2287-  s2340 :: SBool = s2338 | s2339-  s2341 :: SWord8 = s2330 >>> 1-  s2342 :: SWord8 = s20 | s2341-  s2343 :: SWord8 = s22 & s2341-  s2344 :: SWord8 = if s2340 then s2342 else s2343-  s2345 :: SWord8 = s2344 >>> 1-  s2346 :: SWord8 = s20 | s2345-  s2347 :: SWord8 = s22 & s2345-  s2348 :: SWord8 = if s2336 then s2346 else s2347-  s2349 :: SWord8 = s2334 >>> 1-  s2350 :: SWord8 = s20 | s2349-  s2351 :: SWord8 = s22 & s2349-  s2352 :: SWord8 = if s2312 then s2350 else s2351-  s2353 :: SWord8 = if s25 then s2333 else s2318-  s2354 :: SWord8 = if s166 then s2352 else s2353-  s2355 :: SWord8 = s2344 + s2354-  s2356 :: SBool = s2355 < s2354-  s2357 :: SBool = s2355 < s2344-  s2358 :: SBool = s2356 | s2357-  s2359 :: SWord8 = s2355 >>> 1-  s2360 :: SWord8 = s20 | s2359-  s2361 :: SWord8 = s22 & s2359-  s2362 :: SWord8 = if s2358 then s2360 else s2361-  s2363 :: SWord8 = if s2337 then s2348 else s2362-  s2364 :: SWord8 = if s2280 then s2329 else s2363-  s2365 :: SWord8 = if s2165 then s2272 else s2364-  s2366 :: SWord8 = if s1931 then s2157 else s2365-  s2367 :: SWord8 = s1914 + s2012-  s2368 :: SWord1 = choose [0:0] s2367-  s2369 :: SBool = s15 /= s2368-  s2370 :: SWord8 = if s2369 then s1925 else s1926-  s2371 :: SWord8 = if s18 then s2370 else s1922-  s2372 :: SWord1 = choose [0:0] s2371-  s2373 :: SBool = s15 /= s2372-  s2374 :: SBool = s_2 == s2373-  s2375 :: SBool = s2367 < s2012-  s2376 :: SBool = s2367 < s1914-  s2377 :: SBool = s2375 | s2376-  s2378 :: SWord8 = s2367 >>> 1-  s2379 :: SWord8 = s20 | s2378-  s2380 :: SWord8 = s22 & s2378-  s2381 :: SWord8 = if s2377 then s2379 else s2380-  s2382 :: SWord1 = choose [0:0] s2381-  s2383 :: SBool = s15 /= s2382-  s2384 :: SWord8 = s2371 >>> 1-  s2385 :: SWord8 = s20 | s2384-  s2386 :: SWord8 = s22 & s2384-  s2387 :: SWord8 = if s1939 then s2385 else s2386-  s2388 :: SWord8 = if s18 then s2387 else s2370-  s2389 :: SWord8 = s2388 >>> 1-  s2390 :: SWord8 = s20 | s2389-  s2391 :: SWord8 = s22 & s2389-  s2392 :: SWord8 = if s2383 then s2390 else s2391-  s2393 :: SWord8 = if s18 then s2392 else s2387-  s2394 :: SWord1 = choose [0:0] s2393-  s2395 :: SBool = s15 /= s2394-  s2396 :: SBool = s_2 == s2395-  s2397 :: SWord8 = s2381 >>> 1-  s2398 :: SWord8 = s20 | s2397-  s2399 :: SWord8 = s22 & s2397-  s2400 :: SWord8 = if s2373 then s2398 else s2399-  s2401 :: SWord1 = choose [0:0] s2400-  s2402 :: SBool = s15 /= s2401-  s2403 :: SWord1 = choose [0:0] s2388-  s2404 :: SBool = s15 /= s2403-  s2405 :: SWord8 = s2393 >>> 1-  s2406 :: SWord8 = s20 | s2405-  s2407 :: SWord8 = s22 & s2405-  s2408 :: SWord8 = if s2404 then s2406 else s2407-  s2409 :: SWord8 = if s18 then s2408 else s2392-  s2410 :: SWord8 = s2409 >>> 1-  s2411 :: SWord8 = s20 | s2410-  s2412 :: SWord8 = s22 & s2410-  s2413 :: SWord8 = if s2402 then s2411 else s2412-  s2414 :: SWord8 = if s18 then s2413 else s2408-  s2415 :: SWord1 = choose [0:0] s2414-  s2416 :: SBool = s15 /= s2415-  s2417 :: SBool = s_2 == s2416-  s2418 :: SWord8 = s2400 >>> 1-  s2419 :: SWord8 = s20 | s2418-  s2420 :: SWord8 = s22 & s2418-  s2421 :: SWord8 = if s2395 then s2419 else s2420-  s2422 :: SWord1 = choose [0:0] s2421-  s2423 :: SBool = s15 /= s2422-  s2424 :: SWord1 = choose [0:0] s2409-  s2425 :: SBool = s15 /= s2424-  s2426 :: SWord8 = s2414 >>> 1-  s2427 :: SWord8 = s20 | s2426-  s2428 :: SWord8 = s22 & s2426-  s2429 :: SWord8 = if s2425 then s2427 else s2428-  s2430 :: SWord8 = if s18 then s2429 else s2413-  s2431 :: SWord8 = s2430 >>> 1-  s2432 :: SWord8 = s20 | s2431-  s2433 :: SWord8 = s22 & s2431-  s2434 :: SWord8 = if s2423 then s2432 else s2433-  s2435 :: SWord8 = if s18 then s2434 else s2429-  s2436 :: SWord1 = choose [0:0] s2435-  s2437 :: SBool = s15 /= s2436-  s2438 :: SBool = s_2 == s2437-  s2439 :: SWord8 = s2421 >>> 1-  s2440 :: SWord8 = s20 | s2439-  s2441 :: SWord8 = s22 & s2439-  s2442 :: SWord8 = if s2416 then s2440 else s2441-  s2443 :: SWord8 = s2442 >>> 1-  s2444 :: SWord8 = s20 | s2443-  s2445 :: SWord8 = s22 & s2443-  s2446 :: SWord8 = if s2437 then s2444 else s2445-  s2447 :: SWord1 = choose [0:0] s2430-  s2448 :: SBool = s15 /= s2447-  s2449 :: SWord8 = s2435 >>> 1-  s2450 :: SWord8 = s20 | s2449-  s2451 :: SWord8 = s22 & s2449-  s2452 :: SWord8 = if s2448 then s2450 else s2451-  s2453 :: SWord8 = if s25 then s2370 else s2012-  s2454 :: SWord8 = if s166 then s2387 else s2453-  s2455 :: SWord8 = if s25 then s2392 else s2454-  s2456 :: SWord8 = if s166 then s2408 else s2455-  s2457 :: SWord8 = if s25 then s2413 else s2456-  s2458 :: SWord8 = if s166 then s2429 else s2457-  s2459 :: SWord8 = if s25 then s2434 else s2458-  s2460 :: SWord8 = if s166 then s2452 else s2459-  s2461 :: SWord8 = s2442 + s2460-  s2462 :: SBool = s2461 < s2460-  s2463 :: SBool = s2461 < s2442-  s2464 :: SBool = s2462 | s2463-  s2465 :: SWord8 = s2461 >>> 1-  s2466 :: SWord8 = s20 | s2465-  s2467 :: SWord8 = s22 & s2465-  s2468 :: SWord8 = if s2464 then s2466 else s2467-  s2469 :: SWord8 = if s2438 then s2446 else s2468-  s2470 :: SWord8 = s2421 + s2458-  s2471 :: SWord1 = choose [0:0] s2470-  s2472 :: SBool = s15 /= s2471-  s2473 :: SWord8 = if s2472 then s2432 else s2433-  s2474 :: SWord8 = if s18 then s2473 else s2429-  s2475 :: SWord1 = choose [0:0] s2474-  s2476 :: SBool = s15 /= s2475-  s2477 :: SBool = s_2 == s2476-  s2478 :: SBool = s2470 < s2458-  s2479 :: SBool = s2470 < s2421-  s2480 :: SBool = s2478 | s2479-  s2481 :: SWord8 = s2470 >>> 1-  s2482 :: SWord8 = s20 | s2481-  s2483 :: SWord8 = s22 & s2481-  s2484 :: SWord8 = if s2480 then s2482 else s2483-  s2485 :: SWord8 = s2484 >>> 1-  s2486 :: SWord8 = s20 | s2485-  s2487 :: SWord8 = s22 & s2485-  s2488 :: SWord8 = if s2476 then s2486 else s2487-  s2489 :: SWord8 = s2474 >>> 1-  s2490 :: SWord8 = s20 | s2489-  s2491 :: SWord8 = s22 & s2489-  s2492 :: SWord8 = if s2448 then s2490 else s2491-  s2493 :: SWord8 = if s25 then s2473 else s2458-  s2494 :: SWord8 = if s166 then s2492 else s2493-  s2495 :: SWord8 = s2484 + s2494-  s2496 :: SBool = s2495 < s2494-  s2497 :: SBool = s2495 < s2484-  s2498 :: SBool = s2496 | s2497-  s2499 :: SWord8 = s2495 >>> 1-  s2500 :: SWord8 = s20 | s2499-  s2501 :: SWord8 = s22 & s2499-  s2502 :: SWord8 = if s2498 then s2500 else s2501-  s2503 :: SWord8 = if s2477 then s2488 else s2502-  s2504 :: SWord8 = if s2417 then s2469 else s2503-  s2505 :: SWord8 = s2400 + s2456-  s2506 :: SWord1 = choose [0:0] s2505-  s2507 :: SBool = s15 /= s2506-  s2508 :: SWord8 = if s2507 then s2411 else s2412-  s2509 :: SWord8 = if s18 then s2508 else s2408-  s2510 :: SWord1 = choose [0:0] s2509-  s2511 :: SBool = s15 /= s2510-  s2512 :: SBool = s_2 == s2511-  s2513 :: SBool = s2505 < s2456-  s2514 :: SBool = s2505 < s2400-  s2515 :: SBool = s2513 | s2514-  s2516 :: SWord8 = s2505 >>> 1-  s2517 :: SWord8 = s20 | s2516-  s2518 :: SWord8 = s22 & s2516-  s2519 :: SWord8 = if s2515 then s2517 else s2518-  s2520 :: SWord1 = choose [0:0] s2519-  s2521 :: SBool = s15 /= s2520-  s2522 :: SWord8 = s2509 >>> 1-  s2523 :: SWord8 = s20 | s2522-  s2524 :: SWord8 = s22 & s2522-  s2525 :: SWord8 = if s2425 then s2523 else s2524-  s2526 :: SWord8 = if s18 then s2525 else s2508-  s2527 :: SWord8 = s2526 >>> 1-  s2528 :: SWord8 = s20 | s2527-  s2529 :: SWord8 = s22 & s2527-  s2530 :: SWord8 = if s2521 then s2528 else s2529-  s2531 :: SWord8 = if s18 then s2530 else s2525-  s2532 :: SWord1 = choose [0:0] s2531-  s2533 :: SBool = s15 /= s2532-  s2534 :: SBool = s_2 == s2533-  s2535 :: SWord8 = s2519 >>> 1-  s2536 :: SWord8 = s20 | s2535-  s2537 :: SWord8 = s22 & s2535-  s2538 :: SWord8 = if s2511 then s2536 else s2537-  s2539 :: SWord8 = s2538 >>> 1-  s2540 :: SWord8 = s20 | s2539-  s2541 :: SWord8 = s22 & s2539-  s2542 :: SWord8 = if s2533 then s2540 else s2541-  s2543 :: SWord1 = choose [0:0] s2526-  s2544 :: SBool = s15 /= s2543-  s2545 :: SWord8 = s2531 >>> 1-  s2546 :: SWord8 = s20 | s2545-  s2547 :: SWord8 = s22 & s2545-  s2548 :: SWord8 = if s2544 then s2546 else s2547-  s2549 :: SWord8 = if s25 then s2508 else s2456-  s2550 :: SWord8 = if s166 then s2525 else s2549-  s2551 :: SWord8 = if s25 then s2530 else s2550-  s2552 :: SWord8 = if s166 then s2548 else s2551-  s2553 :: SWord8 = s2538 + s2552-  s2554 :: SBool = s2553 < s2552-  s2555 :: SBool = s2553 < s2538-  s2556 :: SBool = s2554 | s2555-  s2557 :: SWord8 = s2553 >>> 1-  s2558 :: SWord8 = s20 | s2557-  s2559 :: SWord8 = s22 & s2557-  s2560 :: SWord8 = if s2556 then s2558 else s2559-  s2561 :: SWord8 = if s2534 then s2542 else s2560-  s2562 :: SWord8 = s2519 + s2550-  s2563 :: SWord1 = choose [0:0] s2562-  s2564 :: SBool = s15 /= s2563-  s2565 :: SWord8 = if s2564 then s2528 else s2529-  s2566 :: SWord8 = if s18 then s2565 else s2525-  s2567 :: SWord1 = choose [0:0] s2566-  s2568 :: SBool = s15 /= s2567-  s2569 :: SBool = s_2 == s2568-  s2570 :: SBool = s2562 < s2550-  s2571 :: SBool = s2562 < s2519-  s2572 :: SBool = s2570 | s2571-  s2573 :: SWord8 = s2562 >>> 1-  s2574 :: SWord8 = s20 | s2573-  s2575 :: SWord8 = s22 & s2573-  s2576 :: SWord8 = if s2572 then s2574 else s2575-  s2577 :: SWord8 = s2576 >>> 1-  s2578 :: SWord8 = s20 | s2577-  s2579 :: SWord8 = s22 & s2577-  s2580 :: SWord8 = if s2568 then s2578 else s2579-  s2581 :: SWord8 = s2566 >>> 1-  s2582 :: SWord8 = s20 | s2581-  s2583 :: SWord8 = s22 & s2581-  s2584 :: SWord8 = if s2544 then s2582 else s2583-  s2585 :: SWord8 = if s25 then s2565 else s2550-  s2586 :: SWord8 = if s166 then s2584 else s2585-  s2587 :: SWord8 = s2576 + s2586-  s2588 :: SBool = s2587 < s2586-  s2589 :: SBool = s2587 < s2576-  s2590 :: SBool = s2588 | s2589-  s2591 :: SWord8 = s2587 >>> 1-  s2592 :: SWord8 = s20 | s2591-  s2593 :: SWord8 = s22 & s2591-  s2594 :: SWord8 = if s2590 then s2592 else s2593-  s2595 :: SWord8 = if s2569 then s2580 else s2594-  s2596 :: SWord8 = if s2512 then s2561 else s2595-  s2597 :: SWord8 = if s2396 then s2504 else s2596-  s2598 :: SWord8 = s2381 + s2454-  s2599 :: SWord1 = choose [0:0] s2598-  s2600 :: SBool = s15 /= s2599-  s2601 :: SWord8 = if s2600 then s2390 else s2391-  s2602 :: SWord8 = if s18 then s2601 else s2387-  s2603 :: SWord1 = choose [0:0] s2602-  s2604 :: SBool = s15 /= s2603-  s2605 :: SBool = s_2 == s2604-  s2606 :: SBool = s2598 < s2454-  s2607 :: SBool = s2598 < s2381-  s2608 :: SBool = s2606 | s2607-  s2609 :: SWord8 = s2598 >>> 1-  s2610 :: SWord8 = s20 | s2609-  s2611 :: SWord8 = s22 & s2609-  s2612 :: SWord8 = if s2608 then s2610 else s2611-  s2613 :: SWord1 = choose [0:0] s2612-  s2614 :: SBool = s15 /= s2613-  s2615 :: SWord8 = s2602 >>> 1-  s2616 :: SWord8 = s20 | s2615-  s2617 :: SWord8 = s22 & s2615-  s2618 :: SWord8 = if s2404 then s2616 else s2617-  s2619 :: SWord8 = if s18 then s2618 else s2601-  s2620 :: SWord8 = s2619 >>> 1-  s2621 :: SWord8 = s20 | s2620-  s2622 :: SWord8 = s22 & s2620-  s2623 :: SWord8 = if s2614 then s2621 else s2622-  s2624 :: SWord8 = if s18 then s2623 else s2618-  s2625 :: SWord1 = choose [0:0] s2624-  s2626 :: SBool = s15 /= s2625-  s2627 :: SBool = s_2 == s2626-  s2628 :: SWord8 = s2612 >>> 1-  s2629 :: SWord8 = s20 | s2628-  s2630 :: SWord8 = s22 & s2628-  s2631 :: SWord8 = if s2604 then s2629 else s2630-  s2632 :: SWord1 = choose [0:0] s2631-  s2633 :: SBool = s15 /= s2632-  s2634 :: SWord1 = choose [0:0] s2619-  s2635 :: SBool = s15 /= s2634-  s2636 :: SWord8 = s2624 >>> 1-  s2637 :: SWord8 = s20 | s2636-  s2638 :: SWord8 = s22 & s2636-  s2639 :: SWord8 = if s2635 then s2637 else s2638-  s2640 :: SWord8 = if s18 then s2639 else s2623-  s2641 :: SWord8 = s2640 >>> 1-  s2642 :: SWord8 = s20 | s2641-  s2643 :: SWord8 = s22 & s2641-  s2644 :: SWord8 = if s2633 then s2642 else s2643-  s2645 :: SWord8 = if s18 then s2644 else s2639-  s2646 :: SWord1 = choose [0:0] s2645-  s2647 :: SBool = s15 /= s2646-  s2648 :: SBool = s_2 == s2647-  s2649 :: SWord8 = s2631 >>> 1-  s2650 :: SWord8 = s20 | s2649-  s2651 :: SWord8 = s22 & s2649-  s2652 :: SWord8 = if s2626 then s2650 else s2651-  s2653 :: SWord8 = s2652 >>> 1-  s2654 :: SWord8 = s20 | s2653-  s2655 :: SWord8 = s22 & s2653-  s2656 :: SWord8 = if s2647 then s2654 else s2655-  s2657 :: SWord1 = choose [0:0] s2640-  s2658 :: SBool = s15 /= s2657-  s2659 :: SWord8 = s2645 >>> 1-  s2660 :: SWord8 = s20 | s2659-  s2661 :: SWord8 = s22 & s2659-  s2662 :: SWord8 = if s2658 then s2660 else s2661-  s2663 :: SWord8 = if s25 then s2601 else s2454-  s2664 :: SWord8 = if s166 then s2618 else s2663-  s2665 :: SWord8 = if s25 then s2623 else s2664-  s2666 :: SWord8 = if s166 then s2639 else s2665-  s2667 :: SWord8 = if s25 then s2644 else s2666-  s2668 :: SWord8 = if s166 then s2662 else s2667-  s2669 :: SWord8 = s2652 + s2668-  s2670 :: SBool = s2669 < s2668-  s2671 :: SBool = s2669 < s2652-  s2672 :: SBool = s2670 | s2671-  s2673 :: SWord8 = s2669 >>> 1-  s2674 :: SWord8 = s20 | s2673-  s2675 :: SWord8 = s22 & s2673-  s2676 :: SWord8 = if s2672 then s2674 else s2675-  s2677 :: SWord8 = if s2648 then s2656 else s2676-  s2678 :: SWord8 = s2631 + s2666-  s2679 :: SWord1 = choose [0:0] s2678-  s2680 :: SBool = s15 /= s2679-  s2681 :: SWord8 = if s2680 then s2642 else s2643-  s2682 :: SWord8 = if s18 then s2681 else s2639-  s2683 :: SWord1 = choose [0:0] s2682-  s2684 :: SBool = s15 /= s2683-  s2685 :: SBool = s_2 == s2684-  s2686 :: SBool = s2678 < s2666-  s2687 :: SBool = s2678 < s2631-  s2688 :: SBool = s2686 | s2687-  s2689 :: SWord8 = s2678 >>> 1-  s2690 :: SWord8 = s20 | s2689-  s2691 :: SWord8 = s22 & s2689-  s2692 :: SWord8 = if s2688 then s2690 else s2691-  s2693 :: SWord8 = s2692 >>> 1-  s2694 :: SWord8 = s20 | s2693-  s2695 :: SWord8 = s22 & s2693-  s2696 :: SWord8 = if s2684 then s2694 else s2695-  s2697 :: SWord8 = s2682 >>> 1-  s2698 :: SWord8 = s20 | s2697-  s2699 :: SWord8 = s22 & s2697-  s2700 :: SWord8 = if s2658 then s2698 else s2699-  s2701 :: SWord8 = if s25 then s2681 else s2666-  s2702 :: SWord8 = if s166 then s2700 else s2701-  s2703 :: SWord8 = s2692 + s2702-  s2704 :: SBool = s2703 < s2702-  s2705 :: SBool = s2703 < s2692-  s2706 :: SBool = s2704 | s2705-  s2707 :: SWord8 = s2703 >>> 1-  s2708 :: SWord8 = s20 | s2707-  s2709 :: SWord8 = s22 & s2707-  s2710 :: SWord8 = if s2706 then s2708 else s2709-  s2711 :: SWord8 = if s2685 then s2696 else s2710-  s2712 :: SWord8 = if s2627 then s2677 else s2711-  s2713 :: SWord8 = s2612 + s2664-  s2714 :: SWord1 = choose [0:0] s2713-  s2715 :: SBool = s15 /= s2714-  s2716 :: SWord8 = if s2715 then s2621 else s2622-  s2717 :: SWord8 = if s18 then s2716 else s2618-  s2718 :: SWord1 = choose [0:0] s2717-  s2719 :: SBool = s15 /= s2718-  s2720 :: SBool = s_2 == s2719-  s2721 :: SBool = s2713 < s2664-  s2722 :: SBool = s2713 < s2612-  s2723 :: SBool = s2721 | s2722-  s2724 :: SWord8 = s2713 >>> 1-  s2725 :: SWord8 = s20 | s2724-  s2726 :: SWord8 = s22 & s2724-  s2727 :: SWord8 = if s2723 then s2725 else s2726-  s2728 :: SWord1 = choose [0:0] s2727-  s2729 :: SBool = s15 /= s2728-  s2730 :: SWord8 = s2717 >>> 1-  s2731 :: SWord8 = s20 | s2730-  s2732 :: SWord8 = s22 & s2730-  s2733 :: SWord8 = if s2635 then s2731 else s2732-  s2734 :: SWord8 = if s18 then s2733 else s2716-  s2735 :: SWord8 = s2734 >>> 1-  s2736 :: SWord8 = s20 | s2735-  s2737 :: SWord8 = s22 & s2735-  s2738 :: SWord8 = if s2729 then s2736 else s2737-  s2739 :: SWord8 = if s18 then s2738 else s2733-  s2740 :: SWord1 = choose [0:0] s2739-  s2741 :: SBool = s15 /= s2740-  s2742 :: SBool = s_2 == s2741-  s2743 :: SWord8 = s2727 >>> 1-  s2744 :: SWord8 = s20 | s2743-  s2745 :: SWord8 = s22 & s2743-  s2746 :: SWord8 = if s2719 then s2744 else s2745-  s2747 :: SWord8 = s2746 >>> 1-  s2748 :: SWord8 = s20 | s2747-  s2749 :: SWord8 = s22 & s2747-  s2750 :: SWord8 = if s2741 then s2748 else s2749-  s2751 :: SWord1 = choose [0:0] s2734-  s2752 :: SBool = s15 /= s2751-  s2753 :: SWord8 = s2739 >>> 1-  s2754 :: SWord8 = s20 | s2753-  s2755 :: SWord8 = s22 & s2753-  s2756 :: SWord8 = if s2752 then s2754 else s2755-  s2757 :: SWord8 = if s25 then s2716 else s2664-  s2758 :: SWord8 = if s166 then s2733 else s2757-  s2759 :: SWord8 = if s25 then s2738 else s2758-  s2760 :: SWord8 = if s166 then s2756 else s2759-  s2761 :: SWord8 = s2746 + s2760-  s2762 :: SBool = s2761 < s2760-  s2763 :: SBool = s2761 < s2746-  s2764 :: SBool = s2762 | s2763-  s2765 :: SWord8 = s2761 >>> 1-  s2766 :: SWord8 = s20 | s2765-  s2767 :: SWord8 = s22 & s2765-  s2768 :: SWord8 = if s2764 then s2766 else s2767-  s2769 :: SWord8 = if s2742 then s2750 else s2768-  s2770 :: SWord8 = s2727 + s2758-  s2771 :: SWord1 = choose [0:0] s2770-  s2772 :: SBool = s15 /= s2771-  s2773 :: SWord8 = if s2772 then s2736 else s2737-  s2774 :: SWord8 = if s18 then s2773 else s2733-  s2775 :: SWord1 = choose [0:0] s2774-  s2776 :: SBool = s15 /= s2775-  s2777 :: SBool = s_2 == s2776-  s2778 :: SBool = s2770 < s2758-  s2779 :: SBool = s2770 < s2727-  s2780 :: SBool = s2778 | s2779-  s2781 :: SWord8 = s2770 >>> 1-  s2782 :: SWord8 = s20 | s2781-  s2783 :: SWord8 = s22 & s2781-  s2784 :: SWord8 = if s2780 then s2782 else s2783-  s2785 :: SWord8 = s2784 >>> 1-  s2786 :: SWord8 = s20 | s2785-  s2787 :: SWord8 = s22 & s2785-  s2788 :: SWord8 = if s2776 then s2786 else s2787-  s2789 :: SWord8 = s2774 >>> 1-  s2790 :: SWord8 = s20 | s2789-  s2791 :: SWord8 = s22 & s2789-  s2792 :: SWord8 = if s2752 then s2790 else s2791-  s2793 :: SWord8 = if s25 then s2773 else s2758-  s2794 :: SWord8 = if s166 then s2792 else s2793-  s2795 :: SWord8 = s2784 + s2794-  s2796 :: SBool = s2795 < s2794-  s2797 :: SBool = s2795 < s2784-  s2798 :: SBool = s2796 | s2797-  s2799 :: SWord8 = s2795 >>> 1-  s2800 :: SWord8 = s20 | s2799-  s2801 :: SWord8 = s22 & s2799-  s2802 :: SWord8 = if s2798 then s2800 else s2801-  s2803 :: SWord8 = if s2777 then s2788 else s2802-  s2804 :: SWord8 = if s2720 then s2769 else s2803-  s2805 :: SWord8 = if s2605 then s2712 else s2804-  s2806 :: SWord8 = if s2374 then s2597 else s2805-  s2807 :: SWord8 = if s1910 then s2366 else s2806-  s2808 :: SWord8 = s1895 + s2010-  s2809 :: SWord1 = choose [0:0] s2808-  s2810 :: SBool = s15 /= s2809-  s2811 :: SWord8 = if s2810 then s1904 else s1905-  s2812 :: SWord8 = if s18 then s2811 else s1901-  s2813 :: SWord1 = choose [0:0] s2812-  s2814 :: SBool = s15 /= s2813-  s2815 :: SBool = s_2 == s2814-  s2816 :: SBool = s2808 < s2010-  s2817 :: SBool = s2808 < s1895-  s2818 :: SBool = s2816 | s2817-  s2819 :: SWord8 = s2808 >>> 1-  s2820 :: SWord8 = s20 | s2819-  s2821 :: SWord8 = s22 & s2819-  s2822 :: SWord8 = if s2818 then s2820 else s2821-  s2823 :: SWord1 = choose [0:0] s2822-  s2824 :: SBool = s15 /= s2823-  s2825 :: SWord8 = s2812 >>> 1-  s2826 :: SWord8 = s20 | s2825-  s2827 :: SWord8 = s22 & s2825-  s2828 :: SWord8 = if s1918 then s2826 else s2827-  s2829 :: SWord8 = if s18 then s2828 else s2811-  s2830 :: SWord8 = s2829 >>> 1-  s2831 :: SWord8 = s20 | s2830-  s2832 :: SWord8 = s22 & s2830-  s2833 :: SWord8 = if s2824 then s2831 else s2832-  s2834 :: SWord8 = if s18 then s2833 else s2828-  s2835 :: SWord1 = choose [0:0] s2834-  s2836 :: SBool = s15 /= s2835-  s2837 :: SBool = s_2 == s2836-  s2838 :: SWord8 = s2822 >>> 1-  s2839 :: SWord8 = s20 | s2838-  s2840 :: SWord8 = s22 & s2838-  s2841 :: SWord8 = if s2814 then s2839 else s2840-  s2842 :: SWord1 = choose [0:0] s2841-  s2843 :: SBool = s15 /= s2842-  s2844 :: SWord1 = choose [0:0] s2829-  s2845 :: SBool = s15 /= s2844-  s2846 :: SWord8 = s2834 >>> 1-  s2847 :: SWord8 = s20 | s2846-  s2848 :: SWord8 = s22 & s2846-  s2849 :: SWord8 = if s2845 then s2847 else s2848-  s2850 :: SWord8 = if s18 then s2849 else s2833-  s2851 :: SWord8 = s2850 >>> 1-  s2852 :: SWord8 = s20 | s2851-  s2853 :: SWord8 = s22 & s2851-  s2854 :: SWord8 = if s2843 then s2852 else s2853-  s2855 :: SWord8 = if s18 then s2854 else s2849-  s2856 :: SWord1 = choose [0:0] s2855-  s2857 :: SBool = s15 /= s2856-  s2858 :: SBool = s_2 == s2857-  s2859 :: SWord8 = s2841 >>> 1-  s2860 :: SWord8 = s20 | s2859-  s2861 :: SWord8 = s22 & s2859-  s2862 :: SWord8 = if s2836 then s2860 else s2861-  s2863 :: SWord1 = choose [0:0] s2862-  s2864 :: SBool = s15 /= s2863-  s2865 :: SWord1 = choose [0:0] s2850-  s2866 :: SBool = s15 /= s2865-  s2867 :: SWord8 = s2855 >>> 1-  s2868 :: SWord8 = s20 | s2867-  s2869 :: SWord8 = s22 & s2867-  s2870 :: SWord8 = if s2866 then s2868 else s2869-  s2871 :: SWord8 = if s18 then s2870 else s2854-  s2872 :: SWord8 = s2871 >>> 1-  s2873 :: SWord8 = s20 | s2872-  s2874 :: SWord8 = s22 & s2872-  s2875 :: SWord8 = if s2864 then s2873 else s2874-  s2876 :: SWord8 = if s18 then s2875 else s2870-  s2877 :: SWord1 = choose [0:0] s2876-  s2878 :: SBool = s15 /= s2877-  s2879 :: SBool = s_2 == s2878-  s2880 :: SWord8 = s2862 >>> 1-  s2881 :: SWord8 = s20 | s2880-  s2882 :: SWord8 = s22 & s2880-  s2883 :: SWord8 = if s2857 then s2881 else s2882-  s2884 :: SWord1 = choose [0:0] s2883-  s2885 :: SBool = s15 /= s2884-  s2886 :: SWord1 = choose [0:0] s2871-  s2887 :: SBool = s15 /= s2886-  s2888 :: SWord8 = s2876 >>> 1-  s2889 :: SWord8 = s20 | s2888-  s2890 :: SWord8 = s22 & s2888-  s2891 :: SWord8 = if s2887 then s2889 else s2890-  s2892 :: SWord8 = if s18 then s2891 else s2875-  s2893 :: SWord8 = s2892 >>> 1-  s2894 :: SWord8 = s20 | s2893-  s2895 :: SWord8 = s22 & s2893-  s2896 :: SWord8 = if s2885 then s2894 else s2895-  s2897 :: SWord8 = if s18 then s2896 else s2891-  s2898 :: SWord1 = choose [0:0] s2897-  s2899 :: SBool = s15 /= s2898-  s2900 :: SBool = s_2 == s2899-  s2901 :: SWord8 = s2883 >>> 1-  s2902 :: SWord8 = s20 | s2901-  s2903 :: SWord8 = s22 & s2901-  s2904 :: SWord8 = if s2878 then s2902 else s2903-  s2905 :: SWord8 = s2904 >>> 1-  s2906 :: SWord8 = s20 | s2905-  s2907 :: SWord8 = s22 & s2905-  s2908 :: SWord8 = if s2899 then s2906 else s2907-  s2909 :: SWord1 = choose [0:0] s2892-  s2910 :: SBool = s15 /= s2909-  s2911 :: SWord8 = s2897 >>> 1-  s2912 :: SWord8 = s20 | s2911-  s2913 :: SWord8 = s22 & s2911-  s2914 :: SWord8 = if s2910 then s2912 else s2913-  s2915 :: SWord8 = if s25 then s2811 else s2010-  s2916 :: SWord8 = if s166 then s2828 else s2915-  s2917 :: SWord8 = if s25 then s2833 else s2916-  s2918 :: SWord8 = if s166 then s2849 else s2917-  s2919 :: SWord8 = if s25 then s2854 else s2918-  s2920 :: SWord8 = if s166 then s2870 else s2919-  s2921 :: SWord8 = if s25 then s2875 else s2920-  s2922 :: SWord8 = if s166 then s2891 else s2921-  s2923 :: SWord8 = if s25 then s2896 else s2922-  s2924 :: SWord8 = if s166 then s2914 else s2923-  s2925 :: SWord8 = s2904 + s2924-  s2926 :: SBool = s2925 < s2924-  s2927 :: SBool = s2925 < s2904-  s2928 :: SBool = s2926 | s2927-  s2929 :: SWord8 = s2925 >>> 1-  s2930 :: SWord8 = s20 | s2929-  s2931 :: SWord8 = s22 & s2929-  s2932 :: SWord8 = if s2928 then s2930 else s2931-  s2933 :: SWord8 = if s2900 then s2908 else s2932-  s2934 :: SWord8 = s2883 + s2922-  s2935 :: SWord1 = choose [0:0] s2934-  s2936 :: SBool = s15 /= s2935-  s2937 :: SWord8 = if s2936 then s2894 else s2895-  s2938 :: SWord8 = if s18 then s2937 else s2891-  s2939 :: SWord1 = choose [0:0] s2938-  s2940 :: SBool = s15 /= s2939-  s2941 :: SBool = s_2 == s2940-  s2942 :: SBool = s2934 < s2922-  s2943 :: SBool = s2934 < s2883-  s2944 :: SBool = s2942 | s2943-  s2945 :: SWord8 = s2934 >>> 1-  s2946 :: SWord8 = s20 | s2945-  s2947 :: SWord8 = s22 & s2945-  s2948 :: SWord8 = if s2944 then s2946 else s2947-  s2949 :: SWord8 = s2948 >>> 1-  s2950 :: SWord8 = s20 | s2949-  s2951 :: SWord8 = s22 & s2949-  s2952 :: SWord8 = if s2940 then s2950 else s2951-  s2953 :: SWord8 = s2938 >>> 1-  s2954 :: SWord8 = s20 | s2953-  s2955 :: SWord8 = s22 & s2953-  s2956 :: SWord8 = if s2910 then s2954 else s2955-  s2957 :: SWord8 = if s25 then s2937 else s2922-  s2958 :: SWord8 = if s166 then s2956 else s2957-  s2959 :: SWord8 = s2948 + s2958-  s2960 :: SBool = s2959 < s2958-  s2961 :: SBool = s2959 < s2948-  s2962 :: SBool = s2960 | s2961-  s2963 :: SWord8 = s2959 >>> 1-  s2964 :: SWord8 = s20 | s2963-  s2965 :: SWord8 = s22 & s2963-  s2966 :: SWord8 = if s2962 then s2964 else s2965-  s2967 :: SWord8 = if s2941 then s2952 else s2966-  s2968 :: SWord8 = if s2879 then s2933 else s2967-  s2969 :: SWord8 = s2862 + s2920-  s2970 :: SWord1 = choose [0:0] s2969-  s2971 :: SBool = s15 /= s2970-  s2972 :: SWord8 = if s2971 then s2873 else s2874-  s2973 :: SWord8 = if s18 then s2972 else s2870-  s2974 :: SWord1 = choose [0:0] s2973-  s2975 :: SBool = s15 /= s2974-  s2976 :: SBool = s_2 == s2975-  s2977 :: SBool = s2969 < s2920-  s2978 :: SBool = s2969 < s2862-  s2979 :: SBool = s2977 | s2978-  s2980 :: SWord8 = s2969 >>> 1-  s2981 :: SWord8 = s20 | s2980-  s2982 :: SWord8 = s22 & s2980-  s2983 :: SWord8 = if s2979 then s2981 else s2982-  s2984 :: SWord1 = choose [0:0] s2983-  s2985 :: SBool = s15 /= s2984-  s2986 :: SWord8 = s2973 >>> 1-  s2987 :: SWord8 = s20 | s2986-  s2988 :: SWord8 = s22 & s2986-  s2989 :: SWord8 = if s2887 then s2987 else s2988-  s2990 :: SWord8 = if s18 then s2989 else s2972-  s2991 :: SWord8 = s2990 >>> 1-  s2992 :: SWord8 = s20 | s2991-  s2993 :: SWord8 = s22 & s2991-  s2994 :: SWord8 = if s2985 then s2992 else s2993-  s2995 :: SWord8 = if s18 then s2994 else s2989-  s2996 :: SWord1 = choose [0:0] s2995-  s2997 :: SBool = s15 /= s2996-  s2998 :: SBool = s_2 == s2997-  s2999 :: SWord8 = s2983 >>> 1-  s3000 :: SWord8 = s20 | s2999-  s3001 :: SWord8 = s22 & s2999-  s3002 :: SWord8 = if s2975 then s3000 else s3001-  s3003 :: SWord8 = s3002 >>> 1-  s3004 :: SWord8 = s20 | s3003-  s3005 :: SWord8 = s22 & s3003-  s3006 :: SWord8 = if s2997 then s3004 else s3005-  s3007 :: SWord1 = choose [0:0] s2990-  s3008 :: SBool = s15 /= s3007-  s3009 :: SWord8 = s2995 >>> 1-  s3010 :: SWord8 = s20 | s3009-  s3011 :: SWord8 = s22 & s3009-  s3012 :: SWord8 = if s3008 then s3010 else s3011-  s3013 :: SWord8 = if s25 then s2972 else s2920-  s3014 :: SWord8 = if s166 then s2989 else s3013-  s3015 :: SWord8 = if s25 then s2994 else s3014-  s3016 :: SWord8 = if s166 then s3012 else s3015-  s3017 :: SWord8 = s3002 + s3016-  s3018 :: SBool = s3017 < s3016-  s3019 :: SBool = s3017 < s3002-  s3020 :: SBool = s3018 | s3019-  s3021 :: SWord8 = s3017 >>> 1-  s3022 :: SWord8 = s20 | s3021-  s3023 :: SWord8 = s22 & s3021-  s3024 :: SWord8 = if s3020 then s3022 else s3023-  s3025 :: SWord8 = if s2998 then s3006 else s3024-  s3026 :: SWord8 = s2983 + s3014-  s3027 :: SWord1 = choose [0:0] s3026-  s3028 :: SBool = s15 /= s3027-  s3029 :: SWord8 = if s3028 then s2992 else s2993-  s3030 :: SWord8 = if s18 then s3029 else s2989-  s3031 :: SWord1 = choose [0:0] s3030-  s3032 :: SBool = s15 /= s3031-  s3033 :: SBool = s_2 == s3032-  s3034 :: SBool = s3026 < s3014-  s3035 :: SBool = s3026 < s2983-  s3036 :: SBool = s3034 | s3035-  s3037 :: SWord8 = s3026 >>> 1-  s3038 :: SWord8 = s20 | s3037-  s3039 :: SWord8 = s22 & s3037-  s3040 :: SWord8 = if s3036 then s3038 else s3039-  s3041 :: SWord8 = s3040 >>> 1-  s3042 :: SWord8 = s20 | s3041-  s3043 :: SWord8 = s22 & s3041-  s3044 :: SWord8 = if s3032 then s3042 else s3043-  s3045 :: SWord8 = s3030 >>> 1-  s3046 :: SWord8 = s20 | s3045-  s3047 :: SWord8 = s22 & s3045-  s3048 :: SWord8 = if s3008 then s3046 else s3047-  s3049 :: SWord8 = if s25 then s3029 else s3014-  s3050 :: SWord8 = if s166 then s3048 else s3049-  s3051 :: SWord8 = s3040 + s3050-  s3052 :: SBool = s3051 < s3050-  s3053 :: SBool = s3051 < s3040-  s3054 :: SBool = s3052 | s3053-  s3055 :: SWord8 = s3051 >>> 1-  s3056 :: SWord8 = s20 | s3055-  s3057 :: SWord8 = s22 & s3055-  s3058 :: SWord8 = if s3054 then s3056 else s3057-  s3059 :: SWord8 = if s3033 then s3044 else s3058-  s3060 :: SWord8 = if s2976 then s3025 else s3059-  s3061 :: SWord8 = if s2858 then s2968 else s3060-  s3062 :: SWord8 = s2841 + s2918-  s3063 :: SWord1 = choose [0:0] s3062-  s3064 :: SBool = s15 /= s3063-  s3065 :: SWord8 = if s3064 then s2852 else s2853-  s3066 :: SWord8 = if s18 then s3065 else s2849-  s3067 :: SWord1 = choose [0:0] s3066-  s3068 :: SBool = s15 /= s3067-  s3069 :: SBool = s_2 == s3068-  s3070 :: SBool = s3062 < s2918-  s3071 :: SBool = s3062 < s2841-  s3072 :: SBool = s3070 | s3071-  s3073 :: SWord8 = s3062 >>> 1-  s3074 :: SWord8 = s20 | s3073-  s3075 :: SWord8 = s22 & s3073-  s3076 :: SWord8 = if s3072 then s3074 else s3075-  s3077 :: SWord1 = choose [0:0] s3076-  s3078 :: SBool = s15 /= s3077-  s3079 :: SWord8 = s3066 >>> 1-  s3080 :: SWord8 = s20 | s3079-  s3081 :: SWord8 = s22 & s3079-  s3082 :: SWord8 = if s2866 then s3080 else s3081-  s3083 :: SWord8 = if s18 then s3082 else s3065-  s3084 :: SWord8 = s3083 >>> 1-  s3085 :: SWord8 = s20 | s3084-  s3086 :: SWord8 = s22 & s3084-  s3087 :: SWord8 = if s3078 then s3085 else s3086-  s3088 :: SWord8 = if s18 then s3087 else s3082-  s3089 :: SWord1 = choose [0:0] s3088-  s3090 :: SBool = s15 /= s3089-  s3091 :: SBool = s_2 == s3090-  s3092 :: SWord8 = s3076 >>> 1-  s3093 :: SWord8 = s20 | s3092-  s3094 :: SWord8 = s22 & s3092-  s3095 :: SWord8 = if s3068 then s3093 else s3094-  s3096 :: SWord1 = choose [0:0] s3095-  s3097 :: SBool = s15 /= s3096-  s3098 :: SWord1 = choose [0:0] s3083-  s3099 :: SBool = s15 /= s3098-  s3100 :: SWord8 = s3088 >>> 1-  s3101 :: SWord8 = s20 | s3100-  s3102 :: SWord8 = s22 & s3100-  s3103 :: SWord8 = if s3099 then s3101 else s3102-  s3104 :: SWord8 = if s18 then s3103 else s3087-  s3105 :: SWord8 = s3104 >>> 1-  s3106 :: SWord8 = s20 | s3105-  s3107 :: SWord8 = s22 & s3105-  s3108 :: SWord8 = if s3097 then s3106 else s3107-  s3109 :: SWord8 = if s18 then s3108 else s3103-  s3110 :: SWord1 = choose [0:0] s3109-  s3111 :: SBool = s15 /= s3110-  s3112 :: SBool = s_2 == s3111-  s3113 :: SWord8 = s3095 >>> 1-  s3114 :: SWord8 = s20 | s3113-  s3115 :: SWord8 = s22 & s3113-  s3116 :: SWord8 = if s3090 then s3114 else s3115-  s3117 :: SWord8 = s3116 >>> 1-  s3118 :: SWord8 = s20 | s3117-  s3119 :: SWord8 = s22 & s3117-  s3120 :: SWord8 = if s3111 then s3118 else s3119-  s3121 :: SWord1 = choose [0:0] s3104-  s3122 :: SBool = s15 /= s3121-  s3123 :: SWord8 = s3109 >>> 1-  s3124 :: SWord8 = s20 | s3123-  s3125 :: SWord8 = s22 & s3123-  s3126 :: SWord8 = if s3122 then s3124 else s3125-  s3127 :: SWord8 = if s25 then s3065 else s2918-  s3128 :: SWord8 = if s166 then s3082 else s3127-  s3129 :: SWord8 = if s25 then s3087 else s3128-  s3130 :: SWord8 = if s166 then s3103 else s3129-  s3131 :: SWord8 = if s25 then s3108 else s3130-  s3132 :: SWord8 = if s166 then s3126 else s3131-  s3133 :: SWord8 = s3116 + s3132-  s3134 :: SBool = s3133 < s3132-  s3135 :: SBool = s3133 < s3116-  s3136 :: SBool = s3134 | s3135-  s3137 :: SWord8 = s3133 >>> 1-  s3138 :: SWord8 = s20 | s3137-  s3139 :: SWord8 = s22 & s3137-  s3140 :: SWord8 = if s3136 then s3138 else s3139-  s3141 :: SWord8 = if s3112 then s3120 else s3140-  s3142 :: SWord8 = s3095 + s3130-  s3143 :: SWord1 = choose [0:0] s3142-  s3144 :: SBool = s15 /= s3143-  s3145 :: SWord8 = if s3144 then s3106 else s3107-  s3146 :: SWord8 = if s18 then s3145 else s3103-  s3147 :: SWord1 = choose [0:0] s3146-  s3148 :: SBool = s15 /= s3147-  s3149 :: SBool = s_2 == s3148-  s3150 :: SBool = s3142 < s3130-  s3151 :: SBool = s3142 < s3095-  s3152 :: SBool = s3150 | s3151-  s3153 :: SWord8 = s3142 >>> 1-  s3154 :: SWord8 = s20 | s3153-  s3155 :: SWord8 = s22 & s3153-  s3156 :: SWord8 = if s3152 then s3154 else s3155-  s3157 :: SWord8 = s3156 >>> 1-  s3158 :: SWord8 = s20 | s3157-  s3159 :: SWord8 = s22 & s3157-  s3160 :: SWord8 = if s3148 then s3158 else s3159-  s3161 :: SWord8 = s3146 >>> 1-  s3162 :: SWord8 = s20 | s3161-  s3163 :: SWord8 = s22 & s3161-  s3164 :: SWord8 = if s3122 then s3162 else s3163-  s3165 :: SWord8 = if s25 then s3145 else s3130-  s3166 :: SWord8 = if s166 then s3164 else s3165-  s3167 :: SWord8 = s3156 + s3166-  s3168 :: SBool = s3167 < s3166-  s3169 :: SBool = s3167 < s3156-  s3170 :: SBool = s3168 | s3169-  s3171 :: SWord8 = s3167 >>> 1-  s3172 :: SWord8 = s20 | s3171-  s3173 :: SWord8 = s22 & s3171-  s3174 :: SWord8 = if s3170 then s3172 else s3173-  s3175 :: SWord8 = if s3149 then s3160 else s3174-  s3176 :: SWord8 = if s3091 then s3141 else s3175-  s3177 :: SWord8 = s3076 + s3128-  s3178 :: SWord1 = choose [0:0] s3177-  s3179 :: SBool = s15 /= s3178-  s3180 :: SWord8 = if s3179 then s3085 else s3086-  s3181 :: SWord8 = if s18 then s3180 else s3082-  s3182 :: SWord1 = choose [0:0] s3181-  s3183 :: SBool = s15 /= s3182-  s3184 :: SBool = s_2 == s3183-  s3185 :: SBool = s3177 < s3128-  s3186 :: SBool = s3177 < s3076-  s3187 :: SBool = s3185 | s3186-  s3188 :: SWord8 = s3177 >>> 1-  s3189 :: SWord8 = s20 | s3188-  s3190 :: SWord8 = s22 & s3188-  s3191 :: SWord8 = if s3187 then s3189 else s3190-  s3192 :: SWord1 = choose [0:0] s3191-  s3193 :: SBool = s15 /= s3192-  s3194 :: SWord8 = s3181 >>> 1-  s3195 :: SWord8 = s20 | s3194-  s3196 :: SWord8 = s22 & s3194-  s3197 :: SWord8 = if s3099 then s3195 else s3196-  s3198 :: SWord8 = if s18 then s3197 else s3180-  s3199 :: SWord8 = s3198 >>> 1-  s3200 :: SWord8 = s20 | s3199-  s3201 :: SWord8 = s22 & s3199-  s3202 :: SWord8 = if s3193 then s3200 else s3201-  s3203 :: SWord8 = if s18 then s3202 else s3197-  s3204 :: SWord1 = choose [0:0] s3203-  s3205 :: SBool = s15 /= s3204-  s3206 :: SBool = s_2 == s3205-  s3207 :: SWord8 = s3191 >>> 1-  s3208 :: SWord8 = s20 | s3207-  s3209 :: SWord8 = s22 & s3207-  s3210 :: SWord8 = if s3183 then s3208 else s3209-  s3211 :: SWord8 = s3210 >>> 1-  s3212 :: SWord8 = s20 | s3211-  s3213 :: SWord8 = s22 & s3211-  s3214 :: SWord8 = if s3205 then s3212 else s3213-  s3215 :: SWord1 = choose [0:0] s3198-  s3216 :: SBool = s15 /= s3215-  s3217 :: SWord8 = s3203 >>> 1-  s3218 :: SWord8 = s20 | s3217-  s3219 :: SWord8 = s22 & s3217-  s3220 :: SWord8 = if s3216 then s3218 else s3219-  s3221 :: SWord8 = if s25 then s3180 else s3128-  s3222 :: SWord8 = if s166 then s3197 else s3221-  s3223 :: SWord8 = if s25 then s3202 else s3222-  s3224 :: SWord8 = if s166 then s3220 else s3223-  s3225 :: SWord8 = s3210 + s3224-  s3226 :: SBool = s3225 < s3224-  s3227 :: SBool = s3225 < s3210-  s3228 :: SBool = s3226 | s3227-  s3229 :: SWord8 = s3225 >>> 1-  s3230 :: SWord8 = s20 | s3229-  s3231 :: SWord8 = s22 & s3229-  s3232 :: SWord8 = if s3228 then s3230 else s3231-  s3233 :: SWord8 = if s3206 then s3214 else s3232-  s3234 :: SWord8 = s3191 + s3222-  s3235 :: SWord1 = choose [0:0] s3234-  s3236 :: SBool = s15 /= s3235-  s3237 :: SWord8 = if s3236 then s3200 else s3201-  s3238 :: SWord8 = if s18 then s3237 else s3197-  s3239 :: SWord1 = choose [0:0] s3238-  s3240 :: SBool = s15 /= s3239-  s3241 :: SBool = s_2 == s3240-  s3242 :: SBool = s3234 < s3222-  s3243 :: SBool = s3234 < s3191-  s3244 :: SBool = s3242 | s3243-  s3245 :: SWord8 = s3234 >>> 1-  s3246 :: SWord8 = s20 | s3245-  s3247 :: SWord8 = s22 & s3245-  s3248 :: SWord8 = if s3244 then s3246 else s3247-  s3249 :: SWord8 = s3248 >>> 1-  s3250 :: SWord8 = s20 | s3249-  s3251 :: SWord8 = s22 & s3249-  s3252 :: SWord8 = if s3240 then s3250 else s3251-  s3253 :: SWord8 = s3238 >>> 1-  s3254 :: SWord8 = s20 | s3253-  s3255 :: SWord8 = s22 & s3253-  s3256 :: SWord8 = if s3216 then s3254 else s3255-  s3257 :: SWord8 = if s25 then s3237 else s3222-  s3258 :: SWord8 = if s166 then s3256 else s3257-  s3259 :: SWord8 = s3248 + s3258-  s3260 :: SBool = s3259 < s3258-  s3261 :: SBool = s3259 < s3248-  s3262 :: SBool = s3260 | s3261-  s3263 :: SWord8 = s3259 >>> 1-  s3264 :: SWord8 = s20 | s3263-  s3265 :: SWord8 = s22 & s3263-  s3266 :: SWord8 = if s3262 then s3264 else s3265-  s3267 :: SWord8 = if s3241 then s3252 else s3266-  s3268 :: SWord8 = if s3184 then s3233 else s3267-  s3269 :: SWord8 = if s3069 then s3176 else s3268-  s3270 :: SWord8 = if s2837 then s3061 else s3269-  s3271 :: SWord8 = s2822 + s2916-  s3272 :: SWord1 = choose [0:0] s3271-  s3273 :: SBool = s15 /= s3272-  s3274 :: SWord8 = if s3273 then s2831 else s2832-  s3275 :: SWord8 = if s18 then s3274 else s2828-  s3276 :: SWord1 = choose [0:0] s3275-  s3277 :: SBool = s15 /= s3276-  s3278 :: SBool = s_2 == s3277-  s3279 :: SBool = s3271 < s2916-  s3280 :: SBool = s3271 < s2822-  s3281 :: SBool = s3279 | s3280-  s3282 :: SWord8 = s3271 >>> 1-  s3283 :: SWord8 = s20 | s3282-  s3284 :: SWord8 = s22 & s3282-  s3285 :: SWord8 = if s3281 then s3283 else s3284-  s3286 :: SWord1 = choose [0:0] s3285-  s3287 :: SBool = s15 /= s3286-  s3288 :: SWord8 = s3275 >>> 1-  s3289 :: SWord8 = s20 | s3288-  s3290 :: SWord8 = s22 & s3288-  s3291 :: SWord8 = if s2845 then s3289 else s3290-  s3292 :: SWord8 = if s18 then s3291 else s3274-  s3293 :: SWord8 = s3292 >>> 1-  s3294 :: SWord8 = s20 | s3293-  s3295 :: SWord8 = s22 & s3293-  s3296 :: SWord8 = if s3287 then s3294 else s3295-  s3297 :: SWord8 = if s18 then s3296 else s3291-  s3298 :: SWord1 = choose [0:0] s3297-  s3299 :: SBool = s15 /= s3298-  s3300 :: SBool = s_2 == s3299-  s3301 :: SWord8 = s3285 >>> 1-  s3302 :: SWord8 = s20 | s3301-  s3303 :: SWord8 = s22 & s3301-  s3304 :: SWord8 = if s3277 then s3302 else s3303-  s3305 :: SWord1 = choose [0:0] s3304-  s3306 :: SBool = s15 /= s3305-  s3307 :: SWord1 = choose [0:0] s3292-  s3308 :: SBool = s15 /= s3307-  s3309 :: SWord8 = s3297 >>> 1-  s3310 :: SWord8 = s20 | s3309-  s3311 :: SWord8 = s22 & s3309-  s3312 :: SWord8 = if s3308 then s3310 else s3311-  s3313 :: SWord8 = if s18 then s3312 else s3296-  s3314 :: SWord8 = s3313 >>> 1-  s3315 :: SWord8 = s20 | s3314-  s3316 :: SWord8 = s22 & s3314-  s3317 :: SWord8 = if s3306 then s3315 else s3316-  s3318 :: SWord8 = if s18 then s3317 else s3312-  s3319 :: SWord1 = choose [0:0] s3318-  s3320 :: SBool = s15 /= s3319-  s3321 :: SBool = s_2 == s3320-  s3322 :: SWord8 = s3304 >>> 1-  s3323 :: SWord8 = s20 | s3322-  s3324 :: SWord8 = s22 & s3322-  s3325 :: SWord8 = if s3299 then s3323 else s3324-  s3326 :: SWord1 = choose [0:0] s3325-  s3327 :: SBool = s15 /= s3326-  s3328 :: SWord1 = choose [0:0] s3313-  s3329 :: SBool = s15 /= s3328-  s3330 :: SWord8 = s3318 >>> 1-  s3331 :: SWord8 = s20 | s3330-  s3332 :: SWord8 = s22 & s3330-  s3333 :: SWord8 = if s3329 then s3331 else s3332-  s3334 :: SWord8 = if s18 then s3333 else s3317-  s3335 :: SWord8 = s3334 >>> 1-  s3336 :: SWord8 = s20 | s3335-  s3337 :: SWord8 = s22 & s3335-  s3338 :: SWord8 = if s3327 then s3336 else s3337-  s3339 :: SWord8 = if s18 then s3338 else s3333-  s3340 :: SWord1 = choose [0:0] s3339-  s3341 :: SBool = s15 /= s3340-  s3342 :: SBool = s_2 == s3341-  s3343 :: SWord8 = s3325 >>> 1-  s3344 :: SWord8 = s20 | s3343-  s3345 :: SWord8 = s22 & s3343-  s3346 :: SWord8 = if s3320 then s3344 else s3345-  s3347 :: SWord8 = s3346 >>> 1-  s3348 :: SWord8 = s20 | s3347-  s3349 :: SWord8 = s22 & s3347-  s3350 :: SWord8 = if s3341 then s3348 else s3349-  s3351 :: SWord1 = choose [0:0] s3334-  s3352 :: SBool = s15 /= s3351-  s3353 :: SWord8 = s3339 >>> 1-  s3354 :: SWord8 = s20 | s3353-  s3355 :: SWord8 = s22 & s3353-  s3356 :: SWord8 = if s3352 then s3354 else s3355-  s3357 :: SWord8 = if s25 then s3274 else s2916-  s3358 :: SWord8 = if s166 then s3291 else s3357-  s3359 :: SWord8 = if s25 then s3296 else s3358-  s3360 :: SWord8 = if s166 then s3312 else s3359-  s3361 :: SWord8 = if s25 then s3317 else s3360-  s3362 :: SWord8 = if s166 then s3333 else s3361-  s3363 :: SWord8 = if s25 then s3338 else s3362-  s3364 :: SWord8 = if s166 then s3356 else s3363-  s3365 :: SWord8 = s3346 + s3364-  s3366 :: SBool = s3365 < s3364-  s3367 :: SBool = s3365 < s3346-  s3368 :: SBool = s3366 | s3367-  s3369 :: SWord8 = s3365 >>> 1-  s3370 :: SWord8 = s20 | s3369-  s3371 :: SWord8 = s22 & s3369-  s3372 :: SWord8 = if s3368 then s3370 else s3371-  s3373 :: SWord8 = if s3342 then s3350 else s3372-  s3374 :: SWord8 = s3325 + s3362-  s3375 :: SWord1 = choose [0:0] s3374-  s3376 :: SBool = s15 /= s3375-  s3377 :: SWord8 = if s3376 then s3336 else s3337-  s3378 :: SWord8 = if s18 then s3377 else s3333-  s3379 :: SWord1 = choose [0:0] s3378-  s3380 :: SBool = s15 /= s3379-  s3381 :: SBool = s_2 == s3380-  s3382 :: SBool = s3374 < s3362-  s3383 :: SBool = s3374 < s3325-  s3384 :: SBool = s3382 | s3383-  s3385 :: SWord8 = s3374 >>> 1-  s3386 :: SWord8 = s20 | s3385-  s3387 :: SWord8 = s22 & s3385-  s3388 :: SWord8 = if s3384 then s3386 else s3387-  s3389 :: SWord8 = s3388 >>> 1-  s3390 :: SWord8 = s20 | s3389-  s3391 :: SWord8 = s22 & s3389-  s3392 :: SWord8 = if s3380 then s3390 else s3391-  s3393 :: SWord8 = s3378 >>> 1-  s3394 :: SWord8 = s20 | s3393-  s3395 :: SWord8 = s22 & s3393-  s3396 :: SWord8 = if s3352 then s3394 else s3395-  s3397 :: SWord8 = if s25 then s3377 else s3362-  s3398 :: SWord8 = if s166 then s3396 else s3397-  s3399 :: SWord8 = s3388 + s3398-  s3400 :: SBool = s3399 < s3398-  s3401 :: SBool = s3399 < s3388-  s3402 :: SBool = s3400 | s3401-  s3403 :: SWord8 = s3399 >>> 1-  s3404 :: SWord8 = s20 | s3403-  s3405 :: SWord8 = s22 & s3403-  s3406 :: SWord8 = if s3402 then s3404 else s3405-  s3407 :: SWord8 = if s3381 then s3392 else s3406-  s3408 :: SWord8 = if s3321 then s3373 else s3407-  s3409 :: SWord8 = s3304 + s3360-  s3410 :: SWord1 = choose [0:0] s3409-  s3411 :: SBool = s15 /= s3410-  s3412 :: SWord8 = if s3411 then s3315 else s3316-  s3413 :: SWord8 = if s18 then s3412 else s3312-  s3414 :: SWord1 = choose [0:0] s3413-  s3415 :: SBool = s15 /= s3414-  s3416 :: SBool = s_2 == s3415-  s3417 :: SBool = s3409 < s3360-  s3418 :: SBool = s3409 < s3304-  s3419 :: SBool = s3417 | s3418-  s3420 :: SWord8 = s3409 >>> 1-  s3421 :: SWord8 = s20 | s3420-  s3422 :: SWord8 = s22 & s3420-  s3423 :: SWord8 = if s3419 then s3421 else s3422-  s3424 :: SWord1 = choose [0:0] s3423-  s3425 :: SBool = s15 /= s3424-  s3426 :: SWord8 = s3413 >>> 1-  s3427 :: SWord8 = s20 | s3426-  s3428 :: SWord8 = s22 & s3426-  s3429 :: SWord8 = if s3329 then s3427 else s3428-  s3430 :: SWord8 = if s18 then s3429 else s3412-  s3431 :: SWord8 = s3430 >>> 1-  s3432 :: SWord8 = s20 | s3431-  s3433 :: SWord8 = s22 & s3431-  s3434 :: SWord8 = if s3425 then s3432 else s3433-  s3435 :: SWord8 = if s18 then s3434 else s3429-  s3436 :: SWord1 = choose [0:0] s3435-  s3437 :: SBool = s15 /= s3436-  s3438 :: SBool = s_2 == s3437-  s3439 :: SWord8 = s3423 >>> 1-  s3440 :: SWord8 = s20 | s3439-  s3441 :: SWord8 = s22 & s3439-  s3442 :: SWord8 = if s3415 then s3440 else s3441-  s3443 :: SWord8 = s3442 >>> 1-  s3444 :: SWord8 = s20 | s3443-  s3445 :: SWord8 = s22 & s3443-  s3446 :: SWord8 = if s3437 then s3444 else s3445-  s3447 :: SWord1 = choose [0:0] s3430-  s3448 :: SBool = s15 /= s3447-  s3449 :: SWord8 = s3435 >>> 1-  s3450 :: SWord8 = s20 | s3449-  s3451 :: SWord8 = s22 & s3449-  s3452 :: SWord8 = if s3448 then s3450 else s3451-  s3453 :: SWord8 = if s25 then s3412 else s3360-  s3454 :: SWord8 = if s166 then s3429 else s3453-  s3455 :: SWord8 = if s25 then s3434 else s3454-  s3456 :: SWord8 = if s166 then s3452 else s3455-  s3457 :: SWord8 = s3442 + s3456-  s3458 :: SBool = s3457 < s3456-  s3459 :: SBool = s3457 < s3442-  s3460 :: SBool = s3458 | s3459-  s3461 :: SWord8 = s3457 >>> 1-  s3462 :: SWord8 = s20 | s3461-  s3463 :: SWord8 = s22 & s3461-  s3464 :: SWord8 = if s3460 then s3462 else s3463-  s3465 :: SWord8 = if s3438 then s3446 else s3464-  s3466 :: SWord8 = s3423 + s3454-  s3467 :: SWord1 = choose [0:0] s3466-  s3468 :: SBool = s15 /= s3467-  s3469 :: SWord8 = if s3468 then s3432 else s3433-  s3470 :: SWord8 = if s18 then s3469 else s3429-  s3471 :: SWord1 = choose [0:0] s3470-  s3472 :: SBool = s15 /= s3471-  s3473 :: SBool = s_2 == s3472-  s3474 :: SBool = s3466 < s3454-  s3475 :: SBool = s3466 < s3423-  s3476 :: SBool = s3474 | s3475-  s3477 :: SWord8 = s3466 >>> 1-  s3478 :: SWord8 = s20 | s3477-  s3479 :: SWord8 = s22 & s3477-  s3480 :: SWord8 = if s3476 then s3478 else s3479-  s3481 :: SWord8 = s3480 >>> 1-  s3482 :: SWord8 = s20 | s3481-  s3483 :: SWord8 = s22 & s3481-  s3484 :: SWord8 = if s3472 then s3482 else s3483-  s3485 :: SWord8 = s3470 >>> 1-  s3486 :: SWord8 = s20 | s3485-  s3487 :: SWord8 = s22 & s3485-  s3488 :: SWord8 = if s3448 then s3486 else s3487-  s3489 :: SWord8 = if s25 then s3469 else s3454-  s3490 :: SWord8 = if s166 then s3488 else s3489-  s3491 :: SWord8 = s3480 + s3490-  s3492 :: SBool = s3491 < s3490-  s3493 :: SBool = s3491 < s3480-  s3494 :: SBool = s3492 | s3493-  s3495 :: SWord8 = s3491 >>> 1-  s3496 :: SWord8 = s20 | s3495-  s3497 :: SWord8 = s22 & s3495-  s3498 :: SWord8 = if s3494 then s3496 else s3497-  s3499 :: SWord8 = if s3473 then s3484 else s3498-  s3500 :: SWord8 = if s3416 then s3465 else s3499-  s3501 :: SWord8 = if s3300 then s3408 else s3500-  s3502 :: SWord8 = s3285 + s3358-  s3503 :: SWord1 = choose [0:0] s3502-  s3504 :: SBool = s15 /= s3503-  s3505 :: SWord8 = if s3504 then s3294 else s3295-  s3506 :: SWord8 = if s18 then s3505 else s3291-  s3507 :: SWord1 = choose [0:0] s3506-  s3508 :: SBool = s15 /= s3507-  s3509 :: SBool = s_2 == s3508-  s3510 :: SBool = s3502 < s3358-  s3511 :: SBool = s3502 < s3285-  s3512 :: SBool = s3510 | s3511-  s3513 :: SWord8 = s3502 >>> 1-  s3514 :: SWord8 = s20 | s3513-  s3515 :: SWord8 = s22 & s3513-  s3516 :: SWord8 = if s3512 then s3514 else s3515-  s3517 :: SWord1 = choose [0:0] s3516-  s3518 :: SBool = s15 /= s3517-  s3519 :: SWord8 = s3506 >>> 1-  s3520 :: SWord8 = s20 | s3519-  s3521 :: SWord8 = s22 & s3519-  s3522 :: SWord8 = if s3308 then s3520 else s3521-  s3523 :: SWord8 = if s18 then s3522 else s3505-  s3524 :: SWord8 = s3523 >>> 1-  s3525 :: SWord8 = s20 | s3524-  s3526 :: SWord8 = s22 & s3524-  s3527 :: SWord8 = if s3518 then s3525 else s3526-  s3528 :: SWord8 = if s18 then s3527 else s3522-  s3529 :: SWord1 = choose [0:0] s3528-  s3530 :: SBool = s15 /= s3529-  s3531 :: SBool = s_2 == s3530-  s3532 :: SWord8 = s3516 >>> 1-  s3533 :: SWord8 = s20 | s3532-  s3534 :: SWord8 = s22 & s3532-  s3535 :: SWord8 = if s3508 then s3533 else s3534-  s3536 :: SWord1 = choose [0:0] s3535-  s3537 :: SBool = s15 /= s3536-  s3538 :: SWord1 = choose [0:0] s3523-  s3539 :: SBool = s15 /= s3538-  s3540 :: SWord8 = s3528 >>> 1-  s3541 :: SWord8 = s20 | s3540-  s3542 :: SWord8 = s22 & s3540-  s3543 :: SWord8 = if s3539 then s3541 else s3542-  s3544 :: SWord8 = if s18 then s3543 else s3527-  s3545 :: SWord8 = s3544 >>> 1-  s3546 :: SWord8 = s20 | s3545-  s3547 :: SWord8 = s22 & s3545-  s3548 :: SWord8 = if s3537 then s3546 else s3547-  s3549 :: SWord8 = if s18 then s3548 else s3543-  s3550 :: SWord1 = choose [0:0] s3549-  s3551 :: SBool = s15 /= s3550-  s3552 :: SBool = s_2 == s3551-  s3553 :: SWord8 = s3535 >>> 1-  s3554 :: SWord8 = s20 | s3553-  s3555 :: SWord8 = s22 & s3553-  s3556 :: SWord8 = if s3530 then s3554 else s3555-  s3557 :: SWord8 = s3556 >>> 1-  s3558 :: SWord8 = s20 | s3557-  s3559 :: SWord8 = s22 & s3557-  s3560 :: SWord8 = if s3551 then s3558 else s3559-  s3561 :: SWord1 = choose [0:0] s3544-  s3562 :: SBool = s15 /= s3561-  s3563 :: SWord8 = s3549 >>> 1-  s3564 :: SWord8 = s20 | s3563-  s3565 :: SWord8 = s22 & s3563-  s3566 :: SWord8 = if s3562 then s3564 else s3565-  s3567 :: SWord8 = if s25 then s3505 else s3358-  s3568 :: SWord8 = if s166 then s3522 else s3567-  s3569 :: SWord8 = if s25 then s3527 else s3568-  s3570 :: SWord8 = if s166 then s3543 else s3569-  s3571 :: SWord8 = if s25 then s3548 else s3570-  s3572 :: SWord8 = if s166 then s3566 else s3571-  s3573 :: SWord8 = s3556 + s3572-  s3574 :: SBool = s3573 < s3572-  s3575 :: SBool = s3573 < s3556-  s3576 :: SBool = s3574 | s3575-  s3577 :: SWord8 = s3573 >>> 1-  s3578 :: SWord8 = s20 | s3577-  s3579 :: SWord8 = s22 & s3577-  s3580 :: SWord8 = if s3576 then s3578 else s3579-  s3581 :: SWord8 = if s3552 then s3560 else s3580-  s3582 :: SWord8 = s3535 + s3570-  s3583 :: SWord1 = choose [0:0] s3582-  s3584 :: SBool = s15 /= s3583-  s3585 :: SWord8 = if s3584 then s3546 else s3547-  s3586 :: SWord8 = if s18 then s3585 else s3543-  s3587 :: SWord1 = choose [0:0] s3586-  s3588 :: SBool = s15 /= s3587-  s3589 :: SBool = s_2 == s3588-  s3590 :: SBool = s3582 < s3570-  s3591 :: SBool = s3582 < s3535-  s3592 :: SBool = s3590 | s3591-  s3593 :: SWord8 = s3582 >>> 1-  s3594 :: SWord8 = s20 | s3593-  s3595 :: SWord8 = s22 & s3593-  s3596 :: SWord8 = if s3592 then s3594 else s3595-  s3597 :: SWord8 = s3596 >>> 1-  s3598 :: SWord8 = s20 | s3597-  s3599 :: SWord8 = s22 & s3597-  s3600 :: SWord8 = if s3588 then s3598 else s3599-  s3601 :: SWord8 = s3586 >>> 1-  s3602 :: SWord8 = s20 | s3601-  s3603 :: SWord8 = s22 & s3601-  s3604 :: SWord8 = if s3562 then s3602 else s3603-  s3605 :: SWord8 = if s25 then s3585 else s3570-  s3606 :: SWord8 = if s166 then s3604 else s3605-  s3607 :: SWord8 = s3596 + s3606-  s3608 :: SBool = s3607 < s3606-  s3609 :: SBool = s3607 < s3596-  s3610 :: SBool = s3608 | s3609-  s3611 :: SWord8 = s3607 >>> 1-  s3612 :: SWord8 = s20 | s3611-  s3613 :: SWord8 = s22 & s3611-  s3614 :: SWord8 = if s3610 then s3612 else s3613-  s3615 :: SWord8 = if s3589 then s3600 else s3614-  s3616 :: SWord8 = if s3531 then s3581 else s3615-  s3617 :: SWord8 = s3516 + s3568-  s3618 :: SWord1 = choose [0:0] s3617-  s3619 :: SBool = s15 /= s3618-  s3620 :: SWord8 = if s3619 then s3525 else s3526-  s3621 :: SWord8 = if s18 then s3620 else s3522-  s3622 :: SWord1 = choose [0:0] s3621-  s3623 :: SBool = s15 /= s3622-  s3624 :: SBool = s_2 == s3623-  s3625 :: SBool = s3617 < s3568-  s3626 :: SBool = s3617 < s3516-  s3627 :: SBool = s3625 | s3626-  s3628 :: SWord8 = s3617 >>> 1-  s3629 :: SWord8 = s20 | s3628-  s3630 :: SWord8 = s22 & s3628-  s3631 :: SWord8 = if s3627 then s3629 else s3630-  s3632 :: SWord1 = choose [0:0] s3631-  s3633 :: SBool = s15 /= s3632-  s3634 :: SWord8 = s3621 >>> 1-  s3635 :: SWord8 = s20 | s3634-  s3636 :: SWord8 = s22 & s3634-  s3637 :: SWord8 = if s3539 then s3635 else s3636-  s3638 :: SWord8 = if s18 then s3637 else s3620-  s3639 :: SWord8 = s3638 >>> 1-  s3640 :: SWord8 = s20 | s3639-  s3641 :: SWord8 = s22 & s3639-  s3642 :: SWord8 = if s3633 then s3640 else s3641-  s3643 :: SWord8 = if s18 then s3642 else s3637-  s3644 :: SWord1 = choose [0:0] s3643-  s3645 :: SBool = s15 /= s3644-  s3646 :: SBool = s_2 == s3645-  s3647 :: SWord8 = s3631 >>> 1-  s3648 :: SWord8 = s20 | s3647-  s3649 :: SWord8 = s22 & s3647-  s3650 :: SWord8 = if s3623 then s3648 else s3649-  s3651 :: SWord8 = s3650 >>> 1-  s3652 :: SWord8 = s20 | s3651-  s3653 :: SWord8 = s22 & s3651-  s3654 :: SWord8 = if s3645 then s3652 else s3653-  s3655 :: SWord1 = choose [0:0] s3638-  s3656 :: SBool = s15 /= s3655-  s3657 :: SWord8 = s3643 >>> 1-  s3658 :: SWord8 = s20 | s3657-  s3659 :: SWord8 = s22 & s3657-  s3660 :: SWord8 = if s3656 then s3658 else s3659-  s3661 :: SWord8 = if s25 then s3620 else s3568-  s3662 :: SWord8 = if s166 then s3637 else s3661-  s3663 :: SWord8 = if s25 then s3642 else s3662-  s3664 :: SWord8 = if s166 then s3660 else s3663-  s3665 :: SWord8 = s3650 + s3664-  s3666 :: SBool = s3665 < s3664-  s3667 :: SBool = s3665 < s3650-  s3668 :: SBool = s3666 | s3667-  s3669 :: SWord8 = s3665 >>> 1-  s3670 :: SWord8 = s20 | s3669-  s3671 :: SWord8 = s22 & s3669-  s3672 :: SWord8 = if s3668 then s3670 else s3671-  s3673 :: SWord8 = if s3646 then s3654 else s3672-  s3674 :: SWord8 = s3631 + s3662-  s3675 :: SWord1 = choose [0:0] s3674-  s3676 :: SBool = s15 /= s3675-  s3677 :: SWord8 = if s3676 then s3640 else s3641-  s3678 :: SWord8 = if s18 then s3677 else s3637-  s3679 :: SWord1 = choose [0:0] s3678-  s3680 :: SBool = s15 /= s3679-  s3681 :: SBool = s_2 == s3680-  s3682 :: SBool = s3674 < s3662-  s3683 :: SBool = s3674 < s3631-  s3684 :: SBool = s3682 | s3683-  s3685 :: SWord8 = s3674 >>> 1-  s3686 :: SWord8 = s20 | s3685-  s3687 :: SWord8 = s22 & s3685-  s3688 :: SWord8 = if s3684 then s3686 else s3687-  s3689 :: SWord8 = s3688 >>> 1-  s3690 :: SWord8 = s20 | s3689-  s3691 :: SWord8 = s22 & s3689-  s3692 :: SWord8 = if s3680 then s3690 else s3691-  s3693 :: SWord8 = s3678 >>> 1-  s3694 :: SWord8 = s20 | s3693-  s3695 :: SWord8 = s22 & s3693-  s3696 :: SWord8 = if s3656 then s3694 else s3695-  s3697 :: SWord8 = if s25 then s3677 else s3662-  s3698 :: SWord8 = if s166 then s3696 else s3697-  s3699 :: SWord8 = s3688 + s3698-  s3700 :: SBool = s3699 < s3698-  s3701 :: SBool = s3699 < s3688-  s3702 :: SBool = s3700 | s3701-  s3703 :: SWord8 = s3699 >>> 1-  s3704 :: SWord8 = s20 | s3703-  s3705 :: SWord8 = s22 & s3703-  s3706 :: SWord8 = if s3702 then s3704 else s3705-  s3707 :: SWord8 = if s3681 then s3692 else s3706-  s3708 :: SWord8 = if s3624 then s3673 else s3707-  s3709 :: SWord8 = if s3509 then s3616 else s3708-  s3710 :: SWord8 = if s3278 then s3501 else s3709-  s3711 :: SWord8 = if s2815 then s3270 else s3710-  s3712 :: SWord8 = if s1888 then s2807 else s3711-  s3713 :: SWord8 = if s34 then s1880 else s3712-  s3714 :: SWord1 = choose [0:0] s174-  s3715 :: SBool = s15 /= s3714-  s3716 :: SWord8 = s20 | s29-  s3717 :: SWord8 = if s3715 then s3716 else s30-  s3718 :: SWord8 = if s18 then s3717 else s24-  s3719 :: SWord1 = choose [0:0] s3718-  s3720 :: SBool = s15 /= s3719-  s3721 :: SBool = s_2 == s3720-  s3722 :: SWord8 = s174 >>> 1-  s3723 :: SWord8 = s22 & s3722-  s3724 :: SWord1 = choose [0:0] s3723-  s3725 :: SBool = s15 /= s3724-  s3726 :: SWord8 = s3718 >>> 1-  s3727 :: SWord8 = s20 | s3726-  s3728 :: SWord8 = s22 & s3726-  s3729 :: SWord8 = if s39 then s3727 else s3728-  s3730 :: SWord8 = if s18 then s3729 else s3717-  s3731 :: SWord8 = s3730 >>> 1-  s3732 :: SWord8 = s20 | s3731-  s3733 :: SWord8 = s22 & s3731-  s3734 :: SWord8 = if s3725 then s3732 else s3733-  s3735 :: SWord8 = if s18 then s3734 else s3729-  s3736 :: SWord1 = choose [0:0] s3735-  s3737 :: SBool = s15 /= s3736-  s3738 :: SBool = s_2 == s3737-  s3739 :: SWord8 = s3723 >>> 1-  s3740 :: SWord8 = s20 | s3739-  s3741 :: SWord8 = s22 & s3739-  s3742 :: SWord8 = if s3720 then s3740 else s3741-  s3743 :: SWord1 = choose [0:0] s3742-  s3744 :: SBool = s15 /= s3743-  s3745 :: SWord1 = choose [0:0] s3730-  s3746 :: SBool = s15 /= s3745-  s3747 :: SWord8 = s3735 >>> 1-  s3748 :: SWord8 = s20 | s3747-  s3749 :: SWord8 = s22 & s3747-  s3750 :: SWord8 = if s3746 then s3748 else s3749-  s3751 :: SWord8 = if s18 then s3750 else s3734-  s3752 :: SWord8 = s3751 >>> 1-  s3753 :: SWord8 = s20 | s3752-  s3754 :: SWord8 = s22 & s3752-  s3755 :: SWord8 = if s3744 then s3753 else s3754-  s3756 :: SWord8 = if s18 then s3755 else s3750-  s3757 :: SWord1 = choose [0:0] s3756-  s3758 :: SBool = s15 /= s3757-  s3759 :: SBool = s_2 == s3758-  s3760 :: SWord8 = s3742 >>> 1-  s3761 :: SWord8 = s20 | s3760-  s3762 :: SWord8 = s22 & s3760-  s3763 :: SWord8 = if s3737 then s3761 else s3762-  s3764 :: SWord1 = choose [0:0] s3763-  s3765 :: SBool = s15 /= s3764-  s3766 :: SWord1 = choose [0:0] s3751-  s3767 :: SBool = s15 /= s3766-  s3768 :: SWord8 = s3756 >>> 1-  s3769 :: SWord8 = s20 | s3768-  s3770 :: SWord8 = s22 & s3768-  s3771 :: SWord8 = if s3767 then s3769 else s3770-  s3772 :: SWord8 = if s18 then s3771 else s3755-  s3773 :: SWord8 = s3772 >>> 1-  s3774 :: SWord8 = s20 | s3773-  s3775 :: SWord8 = s22 & s3773-  s3776 :: SWord8 = if s3765 then s3774 else s3775-  s3777 :: SWord8 = if s18 then s3776 else s3771-  s3778 :: SWord1 = choose [0:0] s3777-  s3779 :: SBool = s15 /= s3778-  s3780 :: SBool = s_2 == s3779-  s3781 :: SWord8 = s3763 >>> 1-  s3782 :: SWord8 = s20 | s3781-  s3783 :: SWord8 = s22 & s3781-  s3784 :: SWord8 = if s3758 then s3782 else s3783-  s3785 :: SWord1 = choose [0:0] s3784-  s3786 :: SBool = s15 /= s3785-  s3787 :: SWord1 = choose [0:0] s3772-  s3788 :: SBool = s15 /= s3787-  s3789 :: SWord8 = s3777 >>> 1-  s3790 :: SWord8 = s20 | s3789-  s3791 :: SWord8 = s22 & s3789-  s3792 :: SWord8 = if s3788 then s3790 else s3791-  s3793 :: SWord8 = if s18 then s3792 else s3776-  s3794 :: SWord8 = s3793 >>> 1-  s3795 :: SWord8 = s20 | s3794-  s3796 :: SWord8 = s22 & s3794-  s3797 :: SWord8 = if s3786 then s3795 else s3796-  s3798 :: SWord8 = if s18 then s3797 else s3792-  s3799 :: SWord1 = choose [0:0] s3798-  s3800 :: SBool = s15 /= s3799-  s3801 :: SBool = s_2 == s3800-  s3802 :: SWord8 = s3784 >>> 1-  s3803 :: SWord8 = s20 | s3802-  s3804 :: SWord8 = s22 & s3802-  s3805 :: SWord8 = if s3779 then s3803 else s3804-  s3806 :: SWord1 = choose [0:0] s3805-  s3807 :: SBool = s15 /= s3806-  s3808 :: SWord1 = choose [0:0] s3793-  s3809 :: SBool = s15 /= s3808-  s3810 :: SWord8 = s3798 >>> 1-  s3811 :: SWord8 = s20 | s3810-  s3812 :: SWord8 = s22 & s3810-  s3813 :: SWord8 = if s3809 then s3811 else s3812-  s3814 :: SWord8 = if s18 then s3813 else s3797-  s3815 :: SWord8 = s3814 >>> 1-  s3816 :: SWord8 = s20 | s3815-  s3817 :: SWord8 = s22 & s3815-  s3818 :: SWord8 = if s3807 then s3816 else s3817-  s3819 :: SWord8 = if s18 then s3818 else s3813-  s3820 :: SWord1 = choose [0:0] s3819-  s3821 :: SBool = s15 /= s3820-  s3822 :: SBool = s_2 == s3821-  s3823 :: SWord8 = s3805 >>> 1-  s3824 :: SWord8 = s20 | s3823-  s3825 :: SWord8 = s22 & s3823-  s3826 :: SWord8 = if s3800 then s3824 else s3825-  s3827 :: SWord1 = choose [0:0] s3826-  s3828 :: SBool = s15 /= s3827-  s3829 :: SWord1 = choose [0:0] s3814-  s3830 :: SBool = s15 /= s3829-  s3831 :: SWord8 = s3819 >>> 1-  s3832 :: SWord8 = s20 | s3831-  s3833 :: SWord8 = s22 & s3831-  s3834 :: SWord8 = if s3830 then s3832 else s3833-  s3835 :: SWord8 = if s18 then s3834 else s3818-  s3836 :: SWord8 = s3835 >>> 1-  s3837 :: SWord8 = s20 | s3836-  s3838 :: SWord8 = s22 & s3836-  s3839 :: SWord8 = if s3828 then s3837 else s3838-  s3840 :: SWord8 = if s18 then s3839 else s3834-  s3841 :: SWord1 = choose [0:0] s3840-  s3842 :: SBool = s15 /= s3841-  s3843 :: SBool = s_2 == s3842-  s3844 :: SWord8 = s3826 >>> 1-  s3845 :: SWord8 = s20 | s3844-  s3846 :: SWord8 = s22 & s3844-  s3847 :: SWord8 = if s3821 then s3845 else s3846-  s3848 :: SWord8 = s3847 >>> 1-  s3849 :: SWord8 = s20 | s3848-  s3850 :: SWord8 = s22 & s3848-  s3851 :: SWord8 = if s3842 then s3849 else s3850-  s3852 :: SWord1 = choose [0:0] s3835-  s3853 :: SBool = s15 /= s3852-  s3854 :: SWord8 = s3840 >>> 1-  s3855 :: SWord8 = s20 | s3854-  s3856 :: SWord8 = s22 & s3854-  s3857 :: SWord8 = if s3853 then s3855 else s3856-  s3858 :: SWord8 = if s25 then s3717 else s174-  s3859 :: SWord8 = if s166 then s3729 else s3858-  s3860 :: SWord8 = if s25 then s3734 else s3859-  s3861 :: SWord8 = if s166 then s3750 else s3860-  s3862 :: SWord8 = if s25 then s3755 else s3861-  s3863 :: SWord8 = if s166 then s3771 else s3862-  s3864 :: SWord8 = if s25 then s3776 else s3863-  s3865 :: SWord8 = if s166 then s3792 else s3864-  s3866 :: SWord8 = if s25 then s3797 else s3865-  s3867 :: SWord8 = if s166 then s3813 else s3866-  s3868 :: SWord8 = if s25 then s3818 else s3867-  s3869 :: SWord8 = if s166 then s3834 else s3868-  s3870 :: SWord8 = if s25 then s3839 else s3869-  s3871 :: SWord8 = if s166 then s3857 else s3870-  s3872 :: SWord8 = s3847 + s3871-  s3873 :: SBool = s3872 < s3871-  s3874 :: SBool = s3872 < s3847-  s3875 :: SBool = s3873 | s3874-  s3876 :: SWord8 = s3872 >>> 1-  s3877 :: SWord8 = s20 | s3876-  s3878 :: SWord8 = s22 & s3876-  s3879 :: SWord8 = if s3875 then s3877 else s3878-  s3880 :: SWord8 = if s3843 then s3851 else s3879-  s3881 :: SWord8 = s3826 + s3869-  s3882 :: SWord1 = choose [0:0] s3881-  s3883 :: SBool = s15 /= s3882-  s3884 :: SWord8 = if s3883 then s3837 else s3838-  s3885 :: SWord8 = if s18 then s3884 else s3834-  s3886 :: SWord1 = choose [0:0] s3885-  s3887 :: SBool = s15 /= s3886-  s3888 :: SBool = s_2 == s3887-  s3889 :: SBool = s3881 < s3869-  s3890 :: SBool = s3881 < s3826-  s3891 :: SBool = s3889 | s3890-  s3892 :: SWord8 = s3881 >>> 1-  s3893 :: SWord8 = s20 | s3892-  s3894 :: SWord8 = s22 & s3892-  s3895 :: SWord8 = if s3891 then s3893 else s3894-  s3896 :: SWord8 = s3895 >>> 1-  s3897 :: SWord8 = s20 | s3896-  s3898 :: SWord8 = s22 & s3896-  s3899 :: SWord8 = if s3887 then s3897 else s3898-  s3900 :: SWord8 = s3885 >>> 1-  s3901 :: SWord8 = s20 | s3900-  s3902 :: SWord8 = s22 & s3900-  s3903 :: SWord8 = if s3853 then s3901 else s3902-  s3904 :: SWord8 = if s25 then s3884 else s3869-  s3905 :: SWord8 = if s166 then s3903 else s3904-  s3906 :: SWord8 = s3895 + s3905-  s3907 :: SBool = s3906 < s3905-  s3908 :: SBool = s3906 < s3895-  s3909 :: SBool = s3907 | s3908-  s3910 :: SWord8 = s3906 >>> 1-  s3911 :: SWord8 = s20 | s3910-  s3912 :: SWord8 = s22 & s3910-  s3913 :: SWord8 = if s3909 then s3911 else s3912-  s3914 :: SWord8 = if s3888 then s3899 else s3913-  s3915 :: SWord8 = if s3822 then s3880 else s3914-  s3916 :: SWord8 = s3805 + s3867-  s3917 :: SWord1 = choose [0:0] s3916-  s3918 :: SBool = s15 /= s3917-  s3919 :: SWord8 = if s3918 then s3816 else s3817-  s3920 :: SWord8 = if s18 then s3919 else s3813-  s3921 :: SWord1 = choose [0:0] s3920-  s3922 :: SBool = s15 /= s3921-  s3923 :: SBool = s_2 == s3922-  s3924 :: SBool = s3916 < s3867-  s3925 :: SBool = s3916 < s3805-  s3926 :: SBool = s3924 | s3925-  s3927 :: SWord8 = s3916 >>> 1-  s3928 :: SWord8 = s20 | s3927-  s3929 :: SWord8 = s22 & s3927-  s3930 :: SWord8 = if s3926 then s3928 else s3929-  s3931 :: SWord1 = choose [0:0] s3930-  s3932 :: SBool = s15 /= s3931-  s3933 :: SWord8 = s3920 >>> 1-  s3934 :: SWord8 = s20 | s3933-  s3935 :: SWord8 = s22 & s3933-  s3936 :: SWord8 = if s3830 then s3934 else s3935-  s3937 :: SWord8 = if s18 then s3936 else s3919-  s3938 :: SWord8 = s3937 >>> 1-  s3939 :: SWord8 = s20 | s3938-  s3940 :: SWord8 = s22 & s3938-  s3941 :: SWord8 = if s3932 then s3939 else s3940-  s3942 :: SWord8 = if s18 then s3941 else s3936-  s3943 :: SWord1 = choose [0:0] s3942-  s3944 :: SBool = s15 /= s3943-  s3945 :: SBool = s_2 == s3944-  s3946 :: SWord8 = s3930 >>> 1-  s3947 :: SWord8 = s20 | s3946-  s3948 :: SWord8 = s22 & s3946-  s3949 :: SWord8 = if s3922 then s3947 else s3948-  s3950 :: SWord8 = s3949 >>> 1-  s3951 :: SWord8 = s20 | s3950-  s3952 :: SWord8 = s22 & s3950-  s3953 :: SWord8 = if s3944 then s3951 else s3952-  s3954 :: SWord1 = choose [0:0] s3937-  s3955 :: SBool = s15 /= s3954-  s3956 :: SWord8 = s3942 >>> 1-  s3957 :: SWord8 = s20 | s3956-  s3958 :: SWord8 = s22 & s3956-  s3959 :: SWord8 = if s3955 then s3957 else s3958-  s3960 :: SWord8 = if s25 then s3919 else s3867-  s3961 :: SWord8 = if s166 then s3936 else s3960-  s3962 :: SWord8 = if s25 then s3941 else s3961-  s3963 :: SWord8 = if s166 then s3959 else s3962-  s3964 :: SWord8 = s3949 + s3963-  s3965 :: SBool = s3964 < s3963-  s3966 :: SBool = s3964 < s3949-  s3967 :: SBool = s3965 | s3966-  s3968 :: SWord8 = s3964 >>> 1-  s3969 :: SWord8 = s20 | s3968-  s3970 :: SWord8 = s22 & s3968-  s3971 :: SWord8 = if s3967 then s3969 else s3970-  s3972 :: SWord8 = if s3945 then s3953 else s3971-  s3973 :: SWord8 = s3930 + s3961-  s3974 :: SWord1 = choose [0:0] s3973-  s3975 :: SBool = s15 /= s3974-  s3976 :: SWord8 = if s3975 then s3939 else s3940-  s3977 :: SWord8 = if s18 then s3976 else s3936-  s3978 :: SWord1 = choose [0:0] s3977-  s3979 :: SBool = s15 /= s3978-  s3980 :: SBool = s_2 == s3979-  s3981 :: SBool = s3973 < s3961-  s3982 :: SBool = s3973 < s3930-  s3983 :: SBool = s3981 | s3982-  s3984 :: SWord8 = s3973 >>> 1-  s3985 :: SWord8 = s20 | s3984-  s3986 :: SWord8 = s22 & s3984-  s3987 :: SWord8 = if s3983 then s3985 else s3986-  s3988 :: SWord8 = s3987 >>> 1-  s3989 :: SWord8 = s20 | s3988-  s3990 :: SWord8 = s22 & s3988-  s3991 :: SWord8 = if s3979 then s3989 else s3990-  s3992 :: SWord8 = s3977 >>> 1-  s3993 :: SWord8 = s20 | s3992-  s3994 :: SWord8 = s22 & s3992-  s3995 :: SWord8 = if s3955 then s3993 else s3994-  s3996 :: SWord8 = if s25 then s3976 else s3961-  s3997 :: SWord8 = if s166 then s3995 else s3996-  s3998 :: SWord8 = s3987 + s3997-  s3999 :: SBool = s3998 < s3997-  s4000 :: SBool = s3998 < s3987-  s4001 :: SBool = s3999 | s4000-  s4002 :: SWord8 = s3998 >>> 1-  s4003 :: SWord8 = s20 | s4002-  s4004 :: SWord8 = s22 & s4002-  s4005 :: SWord8 = if s4001 then s4003 else s4004-  s4006 :: SWord8 = if s3980 then s3991 else s4005-  s4007 :: SWord8 = if s3923 then s3972 else s4006-  s4008 :: SWord8 = if s3801 then s3915 else s4007-  s4009 :: SWord8 = s3784 + s3865-  s4010 :: SWord1 = choose [0:0] s4009-  s4011 :: SBool = s15 /= s4010-  s4012 :: SWord8 = if s4011 then s3795 else s3796-  s4013 :: SWord8 = if s18 then s4012 else s3792-  s4014 :: SWord1 = choose [0:0] s4013-  s4015 :: SBool = s15 /= s4014-  s4016 :: SBool = s_2 == s4015-  s4017 :: SBool = s4009 < s3865-  s4018 :: SBool = s4009 < s3784-  s4019 :: SBool = s4017 | s4018-  s4020 :: SWord8 = s4009 >>> 1-  s4021 :: SWord8 = s20 | s4020-  s4022 :: SWord8 = s22 & s4020-  s4023 :: SWord8 = if s4019 then s4021 else s4022-  s4024 :: SWord1 = choose [0:0] s4023-  s4025 :: SBool = s15 /= s4024-  s4026 :: SWord8 = s4013 >>> 1-  s4027 :: SWord8 = s20 | s4026-  s4028 :: SWord8 = s22 & s4026-  s4029 :: SWord8 = if s3809 then s4027 else s4028-  s4030 :: SWord8 = if s18 then s4029 else s4012-  s4031 :: SWord8 = s4030 >>> 1-  s4032 :: SWord8 = s20 | s4031-  s4033 :: SWord8 = s22 & s4031-  s4034 :: SWord8 = if s4025 then s4032 else s4033-  s4035 :: SWord8 = if s18 then s4034 else s4029-  s4036 :: SWord1 = choose [0:0] s4035-  s4037 :: SBool = s15 /= s4036-  s4038 :: SBool = s_2 == s4037-  s4039 :: SWord8 = s4023 >>> 1-  s4040 :: SWord8 = s20 | s4039-  s4041 :: SWord8 = s22 & s4039-  s4042 :: SWord8 = if s4015 then s4040 else s4041-  s4043 :: SWord1 = choose [0:0] s4042-  s4044 :: SBool = s15 /= s4043-  s4045 :: SWord1 = choose [0:0] s4030-  s4046 :: SBool = s15 /= s4045-  s4047 :: SWord8 = s4035 >>> 1-  s4048 :: SWord8 = s20 | s4047-  s4049 :: SWord8 = s22 & s4047-  s4050 :: SWord8 = if s4046 then s4048 else s4049-  s4051 :: SWord8 = if s18 then s4050 else s4034-  s4052 :: SWord8 = s4051 >>> 1-  s4053 :: SWord8 = s20 | s4052-  s4054 :: SWord8 = s22 & s4052-  s4055 :: SWord8 = if s4044 then s4053 else s4054-  s4056 :: SWord8 = if s18 then s4055 else s4050-  s4057 :: SWord1 = choose [0:0] s4056-  s4058 :: SBool = s15 /= s4057-  s4059 :: SBool = s_2 == s4058-  s4060 :: SWord8 = s4042 >>> 1-  s4061 :: SWord8 = s20 | s4060-  s4062 :: SWord8 = s22 & s4060-  s4063 :: SWord8 = if s4037 then s4061 else s4062-  s4064 :: SWord8 = s4063 >>> 1-  s4065 :: SWord8 = s20 | s4064-  s4066 :: SWord8 = s22 & s4064-  s4067 :: SWord8 = if s4058 then s4065 else s4066-  s4068 :: SWord1 = choose [0:0] s4051-  s4069 :: SBool = s15 /= s4068-  s4070 :: SWord8 = s4056 >>> 1-  s4071 :: SWord8 = s20 | s4070-  s4072 :: SWord8 = s22 & s4070-  s4073 :: SWord8 = if s4069 then s4071 else s4072-  s4074 :: SWord8 = if s25 then s4012 else s3865-  s4075 :: SWord8 = if s166 then s4029 else s4074-  s4076 :: SWord8 = if s25 then s4034 else s4075-  s4077 :: SWord8 = if s166 then s4050 else s4076-  s4078 :: SWord8 = if s25 then s4055 else s4077-  s4079 :: SWord8 = if s166 then s4073 else s4078-  s4080 :: SWord8 = s4063 + s4079-  s4081 :: SBool = s4080 < s4079-  s4082 :: SBool = s4080 < s4063-  s4083 :: SBool = s4081 | s4082-  s4084 :: SWord8 = s4080 >>> 1-  s4085 :: SWord8 = s20 | s4084-  s4086 :: SWord8 = s22 & s4084-  s4087 :: SWord8 = if s4083 then s4085 else s4086-  s4088 :: SWord8 = if s4059 then s4067 else s4087-  s4089 :: SWord8 = s4042 + s4077-  s4090 :: SWord1 = choose [0:0] s4089-  s4091 :: SBool = s15 /= s4090-  s4092 :: SWord8 = if s4091 then s4053 else s4054-  s4093 :: SWord8 = if s18 then s4092 else s4050-  s4094 :: SWord1 = choose [0:0] s4093-  s4095 :: SBool = s15 /= s4094-  s4096 :: SBool = s_2 == s4095-  s4097 :: SBool = s4089 < s4077-  s4098 :: SBool = s4089 < s4042-  s4099 :: SBool = s4097 | s4098-  s4100 :: SWord8 = s4089 >>> 1-  s4101 :: SWord8 = s20 | s4100-  s4102 :: SWord8 = s22 & s4100-  s4103 :: SWord8 = if s4099 then s4101 else s4102-  s4104 :: SWord8 = s4103 >>> 1-  s4105 :: SWord8 = s20 | s4104-  s4106 :: SWord8 = s22 & s4104-  s4107 :: SWord8 = if s4095 then s4105 else s4106-  s4108 :: SWord8 = s4093 >>> 1-  s4109 :: SWord8 = s20 | s4108-  s4110 :: SWord8 = s22 & s4108-  s4111 :: SWord8 = if s4069 then s4109 else s4110-  s4112 :: SWord8 = if s25 then s4092 else s4077-  s4113 :: SWord8 = if s166 then s4111 else s4112-  s4114 :: SWord8 = s4103 + s4113-  s4115 :: SBool = s4114 < s4113-  s4116 :: SBool = s4114 < s4103-  s4117 :: SBool = s4115 | s4116-  s4118 :: SWord8 = s4114 >>> 1-  s4119 :: SWord8 = s20 | s4118-  s4120 :: SWord8 = s22 & s4118-  s4121 :: SWord8 = if s4117 then s4119 else s4120-  s4122 :: SWord8 = if s4096 then s4107 else s4121-  s4123 :: SWord8 = if s4038 then s4088 else s4122-  s4124 :: SWord8 = s4023 + s4075-  s4125 :: SWord1 = choose [0:0] s4124-  s4126 :: SBool = s15 /= s4125-  s4127 :: SWord8 = if s4126 then s4032 else s4033-  s4128 :: SWord8 = if s18 then s4127 else s4029-  s4129 :: SWord1 = choose [0:0] s4128-  s4130 :: SBool = s15 /= s4129-  s4131 :: SBool = s_2 == s4130-  s4132 :: SBool = s4124 < s4075-  s4133 :: SBool = s4124 < s4023-  s4134 :: SBool = s4132 | s4133-  s4135 :: SWord8 = s4124 >>> 1-  s4136 :: SWord8 = s20 | s4135-  s4137 :: SWord8 = s22 & s4135-  s4138 :: SWord8 = if s4134 then s4136 else s4137-  s4139 :: SWord1 = choose [0:0] s4138-  s4140 :: SBool = s15 /= s4139-  s4141 :: SWord8 = s4128 >>> 1-  s4142 :: SWord8 = s20 | s4141-  s4143 :: SWord8 = s22 & s4141-  s4144 :: SWord8 = if s4046 then s4142 else s4143-  s4145 :: SWord8 = if s18 then s4144 else s4127-  s4146 :: SWord8 = s4145 >>> 1-  s4147 :: SWord8 = s20 | s4146-  s4148 :: SWord8 = s22 & s4146-  s4149 :: SWord8 = if s4140 then s4147 else s4148-  s4150 :: SWord8 = if s18 then s4149 else s4144-  s4151 :: SWord1 = choose [0:0] s4150-  s4152 :: SBool = s15 /= s4151-  s4153 :: SBool = s_2 == s4152-  s4154 :: SWord8 = s4138 >>> 1-  s4155 :: SWord8 = s20 | s4154-  s4156 :: SWord8 = s22 & s4154-  s4157 :: SWord8 = if s4130 then s4155 else s4156-  s4158 :: SWord8 = s4157 >>> 1-  s4159 :: SWord8 = s20 | s4158-  s4160 :: SWord8 = s22 & s4158-  s4161 :: SWord8 = if s4152 then s4159 else s4160-  s4162 :: SWord1 = choose [0:0] s4145-  s4163 :: SBool = s15 /= s4162-  s4164 :: SWord8 = s4150 >>> 1-  s4165 :: SWord8 = s20 | s4164-  s4166 :: SWord8 = s22 & s4164-  s4167 :: SWord8 = if s4163 then s4165 else s4166-  s4168 :: SWord8 = if s25 then s4127 else s4075-  s4169 :: SWord8 = if s166 then s4144 else s4168-  s4170 :: SWord8 = if s25 then s4149 else s4169-  s4171 :: SWord8 = if s166 then s4167 else s4170-  s4172 :: SWord8 = s4157 + s4171-  s4173 :: SBool = s4172 < s4171-  s4174 :: SBool = s4172 < s4157-  s4175 :: SBool = s4173 | s4174-  s4176 :: SWord8 = s4172 >>> 1-  s4177 :: SWord8 = s20 | s4176-  s4178 :: SWord8 = s22 & s4176-  s4179 :: SWord8 = if s4175 then s4177 else s4178-  s4180 :: SWord8 = if s4153 then s4161 else s4179-  s4181 :: SWord8 = s4138 + s4169-  s4182 :: SWord1 = choose [0:0] s4181-  s4183 :: SBool = s15 /= s4182-  s4184 :: SWord8 = if s4183 then s4147 else s4148-  s4185 :: SWord8 = if s18 then s4184 else s4144-  s4186 :: SWord1 = choose [0:0] s4185-  s4187 :: SBool = s15 /= s4186-  s4188 :: SBool = s_2 == s4187-  s4189 :: SBool = s4181 < s4169-  s4190 :: SBool = s4181 < s4138-  s4191 :: SBool = s4189 | s4190-  s4192 :: SWord8 = s4181 >>> 1-  s4193 :: SWord8 = s20 | s4192-  s4194 :: SWord8 = s22 & s4192-  s4195 :: SWord8 = if s4191 then s4193 else s4194-  s4196 :: SWord8 = s4195 >>> 1-  s4197 :: SWord8 = s20 | s4196-  s4198 :: SWord8 = s22 & s4196-  s4199 :: SWord8 = if s4187 then s4197 else s4198-  s4200 :: SWord8 = s4185 >>> 1-  s4201 :: SWord8 = s20 | s4200-  s4202 :: SWord8 = s22 & s4200-  s4203 :: SWord8 = if s4163 then s4201 else s4202-  s4204 :: SWord8 = if s25 then s4184 else s4169-  s4205 :: SWord8 = if s166 then s4203 else s4204-  s4206 :: SWord8 = s4195 + s4205-  s4207 :: SBool = s4206 < s4205-  s4208 :: SBool = s4206 < s4195-  s4209 :: SBool = s4207 | s4208-  s4210 :: SWord8 = s4206 >>> 1-  s4211 :: SWord8 = s20 | s4210-  s4212 :: SWord8 = s22 & s4210-  s4213 :: SWord8 = if s4209 then s4211 else s4212-  s4214 :: SWord8 = if s4188 then s4199 else s4213-  s4215 :: SWord8 = if s4131 then s4180 else s4214-  s4216 :: SWord8 = if s4016 then s4123 else s4215-  s4217 :: SWord8 = if s3780 then s4008 else s4216-  s4218 :: SWord8 = s3763 + s3863-  s4219 :: SWord1 = choose [0:0] s4218-  s4220 :: SBool = s15 /= s4219-  s4221 :: SWord8 = if s4220 then s3774 else s3775-  s4222 :: SWord8 = if s18 then s4221 else s3771-  s4223 :: SWord1 = choose [0:0] s4222-  s4224 :: SBool = s15 /= s4223-  s4225 :: SBool = s_2 == s4224-  s4226 :: SBool = s4218 < s3863-  s4227 :: SBool = s4218 < s3763-  s4228 :: SBool = s4226 | s4227-  s4229 :: SWord8 = s4218 >>> 1-  s4230 :: SWord8 = s20 | s4229-  s4231 :: SWord8 = s22 & s4229-  s4232 :: SWord8 = if s4228 then s4230 else s4231-  s4233 :: SWord1 = choose [0:0] s4232-  s4234 :: SBool = s15 /= s4233-  s4235 :: SWord8 = s4222 >>> 1-  s4236 :: SWord8 = s20 | s4235-  s4237 :: SWord8 = s22 & s4235-  s4238 :: SWord8 = if s3788 then s4236 else s4237-  s4239 :: SWord8 = if s18 then s4238 else s4221-  s4240 :: SWord8 = s4239 >>> 1-  s4241 :: SWord8 = s20 | s4240-  s4242 :: SWord8 = s22 & s4240-  s4243 :: SWord8 = if s4234 then s4241 else s4242-  s4244 :: SWord8 = if s18 then s4243 else s4238-  s4245 :: SWord1 = choose [0:0] s4244-  s4246 :: SBool = s15 /= s4245-  s4247 :: SBool = s_2 == s4246-  s4248 :: SWord8 = s4232 >>> 1-  s4249 :: SWord8 = s20 | s4248-  s4250 :: SWord8 = s22 & s4248-  s4251 :: SWord8 = if s4224 then s4249 else s4250-  s4252 :: SWord1 = choose [0:0] s4251-  s4253 :: SBool = s15 /= s4252-  s4254 :: SWord1 = choose [0:0] s4239-  s4255 :: SBool = s15 /= s4254-  s4256 :: SWord8 = s4244 >>> 1-  s4257 :: SWord8 = s20 | s4256-  s4258 :: SWord8 = s22 & s4256-  s4259 :: SWord8 = if s4255 then s4257 else s4258-  s4260 :: SWord8 = if s18 then s4259 else s4243-  s4261 :: SWord8 = s4260 >>> 1-  s4262 :: SWord8 = s20 | s4261-  s4263 :: SWord8 = s22 & s4261-  s4264 :: SWord8 = if s4253 then s4262 else s4263-  s4265 :: SWord8 = if s18 then s4264 else s4259-  s4266 :: SWord1 = choose [0:0] s4265-  s4267 :: SBool = s15 /= s4266-  s4268 :: SBool = s_2 == s4267-  s4269 :: SWord8 = s4251 >>> 1-  s4270 :: SWord8 = s20 | s4269-  s4271 :: SWord8 = s22 & s4269-  s4272 :: SWord8 = if s4246 then s4270 else s4271-  s4273 :: SWord1 = choose [0:0] s4272-  s4274 :: SBool = s15 /= s4273-  s4275 :: SWord1 = choose [0:0] s4260-  s4276 :: SBool = s15 /= s4275-  s4277 :: SWord8 = s4265 >>> 1-  s4278 :: SWord8 = s20 | s4277-  s4279 :: SWord8 = s22 & s4277-  s4280 :: SWord8 = if s4276 then s4278 else s4279-  s4281 :: SWord8 = if s18 then s4280 else s4264-  s4282 :: SWord8 = s4281 >>> 1-  s4283 :: SWord8 = s20 | s4282-  s4284 :: SWord8 = s22 & s4282-  s4285 :: SWord8 = if s4274 then s4283 else s4284-  s4286 :: SWord8 = if s18 then s4285 else s4280-  s4287 :: SWord1 = choose [0:0] s4286-  s4288 :: SBool = s15 /= s4287-  s4289 :: SBool = s_2 == s4288-  s4290 :: SWord8 = s4272 >>> 1-  s4291 :: SWord8 = s20 | s4290-  s4292 :: SWord8 = s22 & s4290-  s4293 :: SWord8 = if s4267 then s4291 else s4292-  s4294 :: SWord8 = s4293 >>> 1-  s4295 :: SWord8 = s20 | s4294-  s4296 :: SWord8 = s22 & s4294-  s4297 :: SWord8 = if s4288 then s4295 else s4296-  s4298 :: SWord1 = choose [0:0] s4281-  s4299 :: SBool = s15 /= s4298-  s4300 :: SWord8 = s4286 >>> 1-  s4301 :: SWord8 = s20 | s4300-  s4302 :: SWord8 = s22 & s4300-  s4303 :: SWord8 = if s4299 then s4301 else s4302-  s4304 :: SWord8 = if s25 then s4221 else s3863-  s4305 :: SWord8 = if s166 then s4238 else s4304-  s4306 :: SWord8 = if s25 then s4243 else s4305-  s4307 :: SWord8 = if s166 then s4259 else s4306-  s4308 :: SWord8 = if s25 then s4264 else s4307-  s4309 :: SWord8 = if s166 then s4280 else s4308-  s4310 :: SWord8 = if s25 then s4285 else s4309-  s4311 :: SWord8 = if s166 then s4303 else s4310-  s4312 :: SWord8 = s4293 + s4311-  s4313 :: SBool = s4312 < s4311-  s4314 :: SBool = s4312 < s4293-  s4315 :: SBool = s4313 | s4314-  s4316 :: SWord8 = s4312 >>> 1-  s4317 :: SWord8 = s20 | s4316-  s4318 :: SWord8 = s22 & s4316-  s4319 :: SWord8 = if s4315 then s4317 else s4318-  s4320 :: SWord8 = if s4289 then s4297 else s4319-  s4321 :: SWord8 = s4272 + s4309-  s4322 :: SWord1 = choose [0:0] s4321-  s4323 :: SBool = s15 /= s4322-  s4324 :: SWord8 = if s4323 then s4283 else s4284-  s4325 :: SWord8 = if s18 then s4324 else s4280-  s4326 :: SWord1 = choose [0:0] s4325-  s4327 :: SBool = s15 /= s4326-  s4328 :: SBool = s_2 == s4327-  s4329 :: SBool = s4321 < s4309-  s4330 :: SBool = s4321 < s4272-  s4331 :: SBool = s4329 | s4330-  s4332 :: SWord8 = s4321 >>> 1-  s4333 :: SWord8 = s20 | s4332-  s4334 :: SWord8 = s22 & s4332-  s4335 :: SWord8 = if s4331 then s4333 else s4334-  s4336 :: SWord8 = s4335 >>> 1-  s4337 :: SWord8 = s20 | s4336-  s4338 :: SWord8 = s22 & s4336-  s4339 :: SWord8 = if s4327 then s4337 else s4338-  s4340 :: SWord8 = s4325 >>> 1-  s4341 :: SWord8 = s20 | s4340-  s4342 :: SWord8 = s22 & s4340-  s4343 :: SWord8 = if s4299 then s4341 else s4342-  s4344 :: SWord8 = if s25 then s4324 else s4309-  s4345 :: SWord8 = if s166 then s4343 else s4344-  s4346 :: SWord8 = s4335 + s4345-  s4347 :: SBool = s4346 < s4345-  s4348 :: SBool = s4346 < s4335-  s4349 :: SBool = s4347 | s4348-  s4350 :: SWord8 = s4346 >>> 1-  s4351 :: SWord8 = s20 | s4350-  s4352 :: SWord8 = s22 & s4350-  s4353 :: SWord8 = if s4349 then s4351 else s4352-  s4354 :: SWord8 = if s4328 then s4339 else s4353-  s4355 :: SWord8 = if s4268 then s4320 else s4354-  s4356 :: SWord8 = s4251 + s4307-  s4357 :: SWord1 = choose [0:0] s4356-  s4358 :: SBool = s15 /= s4357-  s4359 :: SWord8 = if s4358 then s4262 else s4263-  s4360 :: SWord8 = if s18 then s4359 else s4259-  s4361 :: SWord1 = choose [0:0] s4360-  s4362 :: SBool = s15 /= s4361-  s4363 :: SBool = s_2 == s4362-  s4364 :: SBool = s4356 < s4307-  s4365 :: SBool = s4356 < s4251-  s4366 :: SBool = s4364 | s4365-  s4367 :: SWord8 = s4356 >>> 1-  s4368 :: SWord8 = s20 | s4367-  s4369 :: SWord8 = s22 & s4367-  s4370 :: SWord8 = if s4366 then s4368 else s4369-  s4371 :: SWord1 = choose [0:0] s4370-  s4372 :: SBool = s15 /= s4371-  s4373 :: SWord8 = s4360 >>> 1-  s4374 :: SWord8 = s20 | s4373-  s4375 :: SWord8 = s22 & s4373-  s4376 :: SWord8 = if s4276 then s4374 else s4375-  s4377 :: SWord8 = if s18 then s4376 else s4359-  s4378 :: SWord8 = s4377 >>> 1-  s4379 :: SWord8 = s20 | s4378-  s4380 :: SWord8 = s22 & s4378-  s4381 :: SWord8 = if s4372 then s4379 else s4380-  s4382 :: SWord8 = if s18 then s4381 else s4376-  s4383 :: SWord1 = choose [0:0] s4382-  s4384 :: SBool = s15 /= s4383-  s4385 :: SBool = s_2 == s4384-  s4386 :: SWord8 = s4370 >>> 1-  s4387 :: SWord8 = s20 | s4386-  s4388 :: SWord8 = s22 & s4386-  s4389 :: SWord8 = if s4362 then s4387 else s4388-  s4390 :: SWord8 = s4389 >>> 1-  s4391 :: SWord8 = s20 | s4390-  s4392 :: SWord8 = s22 & s4390-  s4393 :: SWord8 = if s4384 then s4391 else s4392-  s4394 :: SWord1 = choose [0:0] s4377-  s4395 :: SBool = s15 /= s4394-  s4396 :: SWord8 = s4382 >>> 1-  s4397 :: SWord8 = s20 | s4396-  s4398 :: SWord8 = s22 & s4396-  s4399 :: SWord8 = if s4395 then s4397 else s4398-  s4400 :: SWord8 = if s25 then s4359 else s4307-  s4401 :: SWord8 = if s166 then s4376 else s4400-  s4402 :: SWord8 = if s25 then s4381 else s4401-  s4403 :: SWord8 = if s166 then s4399 else s4402-  s4404 :: SWord8 = s4389 + s4403-  s4405 :: SBool = s4404 < s4403-  s4406 :: SBool = s4404 < s4389-  s4407 :: SBool = s4405 | s4406-  s4408 :: SWord8 = s4404 >>> 1-  s4409 :: SWord8 = s20 | s4408-  s4410 :: SWord8 = s22 & s4408-  s4411 :: SWord8 = if s4407 then s4409 else s4410-  s4412 :: SWord8 = if s4385 then s4393 else s4411-  s4413 :: SWord8 = s4370 + s4401-  s4414 :: SWord1 = choose [0:0] s4413-  s4415 :: SBool = s15 /= s4414-  s4416 :: SWord8 = if s4415 then s4379 else s4380-  s4417 :: SWord8 = if s18 then s4416 else s4376-  s4418 :: SWord1 = choose [0:0] s4417-  s4419 :: SBool = s15 /= s4418-  s4420 :: SBool = s_2 == s4419-  s4421 :: SBool = s4413 < s4401-  s4422 :: SBool = s4413 < s4370-  s4423 :: SBool = s4421 | s4422-  s4424 :: SWord8 = s4413 >>> 1-  s4425 :: SWord8 = s20 | s4424-  s4426 :: SWord8 = s22 & s4424-  s4427 :: SWord8 = if s4423 then s4425 else s4426-  s4428 :: SWord8 = s4427 >>> 1-  s4429 :: SWord8 = s20 | s4428-  s4430 :: SWord8 = s22 & s4428-  s4431 :: SWord8 = if s4419 then s4429 else s4430-  s4432 :: SWord8 = s4417 >>> 1-  s4433 :: SWord8 = s20 | s4432-  s4434 :: SWord8 = s22 & s4432-  s4435 :: SWord8 = if s4395 then s4433 else s4434-  s4436 :: SWord8 = if s25 then s4416 else s4401-  s4437 :: SWord8 = if s166 then s4435 else s4436-  s4438 :: SWord8 = s4427 + s4437-  s4439 :: SBool = s4438 < s4437-  s4440 :: SBool = s4438 < s4427-  s4441 :: SBool = s4439 | s4440-  s4442 :: SWord8 = s4438 >>> 1-  s4443 :: SWord8 = s20 | s4442-  s4444 :: SWord8 = s22 & s4442-  s4445 :: SWord8 = if s4441 then s4443 else s4444-  s4446 :: SWord8 = if s4420 then s4431 else s4445-  s4447 :: SWord8 = if s4363 then s4412 else s4446-  s4448 :: SWord8 = if s4247 then s4355 else s4447-  s4449 :: SWord8 = s4232 + s4305-  s4450 :: SWord1 = choose [0:0] s4449-  s4451 :: SBool = s15 /= s4450-  s4452 :: SWord8 = if s4451 then s4241 else s4242-  s4453 :: SWord8 = if s18 then s4452 else s4238-  s4454 :: SWord1 = choose [0:0] s4453-  s4455 :: SBool = s15 /= s4454-  s4456 :: SBool = s_2 == s4455-  s4457 :: SBool = s4449 < s4305-  s4458 :: SBool = s4449 < s4232-  s4459 :: SBool = s4457 | s4458-  s4460 :: SWord8 = s4449 >>> 1-  s4461 :: SWord8 = s20 | s4460-  s4462 :: SWord8 = s22 & s4460-  s4463 :: SWord8 = if s4459 then s4461 else s4462-  s4464 :: SWord1 = choose [0:0] s4463-  s4465 :: SBool = s15 /= s4464-  s4466 :: SWord8 = s4453 >>> 1-  s4467 :: SWord8 = s20 | s4466-  s4468 :: SWord8 = s22 & s4466-  s4469 :: SWord8 = if s4255 then s4467 else s4468-  s4470 :: SWord8 = if s18 then s4469 else s4452-  s4471 :: SWord8 = s4470 >>> 1-  s4472 :: SWord8 = s20 | s4471-  s4473 :: SWord8 = s22 & s4471-  s4474 :: SWord8 = if s4465 then s4472 else s4473-  s4475 :: SWord8 = if s18 then s4474 else s4469-  s4476 :: SWord1 = choose [0:0] s4475-  s4477 :: SBool = s15 /= s4476-  s4478 :: SBool = s_2 == s4477-  s4479 :: SWord8 = s4463 >>> 1-  s4480 :: SWord8 = s20 | s4479-  s4481 :: SWord8 = s22 & s4479-  s4482 :: SWord8 = if s4455 then s4480 else s4481-  s4483 :: SWord1 = choose [0:0] s4482-  s4484 :: SBool = s15 /= s4483-  s4485 :: SWord1 = choose [0:0] s4470-  s4486 :: SBool = s15 /= s4485-  s4487 :: SWord8 = s4475 >>> 1-  s4488 :: SWord8 = s20 | s4487-  s4489 :: SWord8 = s22 & s4487-  s4490 :: SWord8 = if s4486 then s4488 else s4489-  s4491 :: SWord8 = if s18 then s4490 else s4474-  s4492 :: SWord8 = s4491 >>> 1-  s4493 :: SWord8 = s20 | s4492-  s4494 :: SWord8 = s22 & s4492-  s4495 :: SWord8 = if s4484 then s4493 else s4494-  s4496 :: SWord8 = if s18 then s4495 else s4490-  s4497 :: SWord1 = choose [0:0] s4496-  s4498 :: SBool = s15 /= s4497-  s4499 :: SBool = s_2 == s4498-  s4500 :: SWord8 = s4482 >>> 1-  s4501 :: SWord8 = s20 | s4500-  s4502 :: SWord8 = s22 & s4500-  s4503 :: SWord8 = if s4477 then s4501 else s4502-  s4504 :: SWord8 = s4503 >>> 1-  s4505 :: SWord8 = s20 | s4504-  s4506 :: SWord8 = s22 & s4504-  s4507 :: SWord8 = if s4498 then s4505 else s4506-  s4508 :: SWord1 = choose [0:0] s4491-  s4509 :: SBool = s15 /= s4508-  s4510 :: SWord8 = s4496 >>> 1-  s4511 :: SWord8 = s20 | s4510-  s4512 :: SWord8 = s22 & s4510-  s4513 :: SWord8 = if s4509 then s4511 else s4512-  s4514 :: SWord8 = if s25 then s4452 else s4305-  s4515 :: SWord8 = if s166 then s4469 else s4514-  s4516 :: SWord8 = if s25 then s4474 else s4515-  s4517 :: SWord8 = if s166 then s4490 else s4516-  s4518 :: SWord8 = if s25 then s4495 else s4517-  s4519 :: SWord8 = if s166 then s4513 else s4518-  s4520 :: SWord8 = s4503 + s4519-  s4521 :: SBool = s4520 < s4519-  s4522 :: SBool = s4520 < s4503-  s4523 :: SBool = s4521 | s4522-  s4524 :: SWord8 = s4520 >>> 1-  s4525 :: SWord8 = s20 | s4524-  s4526 :: SWord8 = s22 & s4524-  s4527 :: SWord8 = if s4523 then s4525 else s4526-  s4528 :: SWord8 = if s4499 then s4507 else s4527-  s4529 :: SWord8 = s4482 + s4517-  s4530 :: SWord1 = choose [0:0] s4529-  s4531 :: SBool = s15 /= s4530-  s4532 :: SWord8 = if s4531 then s4493 else s4494-  s4533 :: SWord8 = if s18 then s4532 else s4490-  s4534 :: SWord1 = choose [0:0] s4533-  s4535 :: SBool = s15 /= s4534-  s4536 :: SBool = s_2 == s4535-  s4537 :: SBool = s4529 < s4517-  s4538 :: SBool = s4529 < s4482-  s4539 :: SBool = s4537 | s4538-  s4540 :: SWord8 = s4529 >>> 1-  s4541 :: SWord8 = s20 | s4540-  s4542 :: SWord8 = s22 & s4540-  s4543 :: SWord8 = if s4539 then s4541 else s4542-  s4544 :: SWord8 = s4543 >>> 1-  s4545 :: SWord8 = s20 | s4544-  s4546 :: SWord8 = s22 & s4544-  s4547 :: SWord8 = if s4535 then s4545 else s4546-  s4548 :: SWord8 = s4533 >>> 1-  s4549 :: SWord8 = s20 | s4548-  s4550 :: SWord8 = s22 & s4548-  s4551 :: SWord8 = if s4509 then s4549 else s4550-  s4552 :: SWord8 = if s25 then s4532 else s4517-  s4553 :: SWord8 = if s166 then s4551 else s4552-  s4554 :: SWord8 = s4543 + s4553-  s4555 :: SBool = s4554 < s4553-  s4556 :: SBool = s4554 < s4543-  s4557 :: SBool = s4555 | s4556-  s4558 :: SWord8 = s4554 >>> 1-  s4559 :: SWord8 = s20 | s4558-  s4560 :: SWord8 = s22 & s4558-  s4561 :: SWord8 = if s4557 then s4559 else s4560-  s4562 :: SWord8 = if s4536 then s4547 else s4561-  s4563 :: SWord8 = if s4478 then s4528 else s4562-  s4564 :: SWord8 = s4463 + s4515-  s4565 :: SWord1 = choose [0:0] s4564-  s4566 :: SBool = s15 /= s4565-  s4567 :: SWord8 = if s4566 then s4472 else s4473-  s4568 :: SWord8 = if s18 then s4567 else s4469-  s4569 :: SWord1 = choose [0:0] s4568-  s4570 :: SBool = s15 /= s4569-  s4571 :: SBool = s_2 == s4570-  s4572 :: SBool = s4564 < s4515-  s4573 :: SBool = s4564 < s4463-  s4574 :: SBool = s4572 | s4573-  s4575 :: SWord8 = s4564 >>> 1-  s4576 :: SWord8 = s20 | s4575-  s4577 :: SWord8 = s22 & s4575-  s4578 :: SWord8 = if s4574 then s4576 else s4577-  s4579 :: SWord1 = choose [0:0] s4578-  s4580 :: SBool = s15 /= s4579-  s4581 :: SWord8 = s4568 >>> 1-  s4582 :: SWord8 = s20 | s4581-  s4583 :: SWord8 = s22 & s4581-  s4584 :: SWord8 = if s4486 then s4582 else s4583-  s4585 :: SWord8 = if s18 then s4584 else s4567-  s4586 :: SWord8 = s4585 >>> 1-  s4587 :: SWord8 = s20 | s4586-  s4588 :: SWord8 = s22 & s4586-  s4589 :: SWord8 = if s4580 then s4587 else s4588-  s4590 :: SWord8 = if s18 then s4589 else s4584-  s4591 :: SWord1 = choose [0:0] s4590-  s4592 :: SBool = s15 /= s4591-  s4593 :: SBool = s_2 == s4592-  s4594 :: SWord8 = s4578 >>> 1-  s4595 :: SWord8 = s20 | s4594-  s4596 :: SWord8 = s22 & s4594-  s4597 :: SWord8 = if s4570 then s4595 else s4596-  s4598 :: SWord8 = s4597 >>> 1-  s4599 :: SWord8 = s20 | s4598-  s4600 :: SWord8 = s22 & s4598-  s4601 :: SWord8 = if s4592 then s4599 else s4600-  s4602 :: SWord1 = choose [0:0] s4585-  s4603 :: SBool = s15 /= s4602-  s4604 :: SWord8 = s4590 >>> 1-  s4605 :: SWord8 = s20 | s4604-  s4606 :: SWord8 = s22 & s4604-  s4607 :: SWord8 = if s4603 then s4605 else s4606-  s4608 :: SWord8 = if s25 then s4567 else s4515-  s4609 :: SWord8 = if s166 then s4584 else s4608-  s4610 :: SWord8 = if s25 then s4589 else s4609-  s4611 :: SWord8 = if s166 then s4607 else s4610-  s4612 :: SWord8 = s4597 + s4611-  s4613 :: SBool = s4612 < s4611-  s4614 :: SBool = s4612 < s4597-  s4615 :: SBool = s4613 | s4614-  s4616 :: SWord8 = s4612 >>> 1-  s4617 :: SWord8 = s20 | s4616-  s4618 :: SWord8 = s22 & s4616-  s4619 :: SWord8 = if s4615 then s4617 else s4618-  s4620 :: SWord8 = if s4593 then s4601 else s4619-  s4621 :: SWord8 = s4578 + s4609-  s4622 :: SWord1 = choose [0:0] s4621-  s4623 :: SBool = s15 /= s4622-  s4624 :: SWord8 = if s4623 then s4587 else s4588-  s4625 :: SWord8 = if s18 then s4624 else s4584-  s4626 :: SWord1 = choose [0:0] s4625-  s4627 :: SBool = s15 /= s4626-  s4628 :: SBool = s_2 == s4627-  s4629 :: SBool = s4621 < s4609-  s4630 :: SBool = s4621 < s4578-  s4631 :: SBool = s4629 | s4630-  s4632 :: SWord8 = s4621 >>> 1-  s4633 :: SWord8 = s20 | s4632-  s4634 :: SWord8 = s22 & s4632-  s4635 :: SWord8 = if s4631 then s4633 else s4634-  s4636 :: SWord8 = s4635 >>> 1-  s4637 :: SWord8 = s20 | s4636-  s4638 :: SWord8 = s22 & s4636-  s4639 :: SWord8 = if s4627 then s4637 else s4638-  s4640 :: SWord8 = s4625 >>> 1-  s4641 :: SWord8 = s20 | s4640-  s4642 :: SWord8 = s22 & s4640-  s4643 :: SWord8 = if s4603 then s4641 else s4642-  s4644 :: SWord8 = if s25 then s4624 else s4609-  s4645 :: SWord8 = if s166 then s4643 else s4644-  s4646 :: SWord8 = s4635 + s4645-  s4647 :: SBool = s4646 < s4645-  s4648 :: SBool = s4646 < s4635-  s4649 :: SBool = s4647 | s4648-  s4650 :: SWord8 = s4646 >>> 1-  s4651 :: SWord8 = s20 | s4650-  s4652 :: SWord8 = s22 & s4650-  s4653 :: SWord8 = if s4649 then s4651 else s4652-  s4654 :: SWord8 = if s4628 then s4639 else s4653-  s4655 :: SWord8 = if s4571 then s4620 else s4654-  s4656 :: SWord8 = if s4456 then s4563 else s4655-  s4657 :: SWord8 = if s4225 then s4448 else s4656-  s4658 :: SWord8 = if s3759 then s4217 else s4657-  s4659 :: SWord8 = s3742 + s3861-  s4660 :: SWord1 = choose [0:0] s4659-  s4661 :: SBool = s15 /= s4660-  s4662 :: SWord8 = if s4661 then s3753 else s3754-  s4663 :: SWord8 = if s18 then s4662 else s3750-  s4664 :: SWord1 = choose [0:0] s4663-  s4665 :: SBool = s15 /= s4664-  s4666 :: SBool = s_2 == s4665-  s4667 :: SBool = s4659 < s3861-  s4668 :: SBool = s4659 < s3742-  s4669 :: SBool = s4667 | s4668-  s4670 :: SWord8 = s4659 >>> 1-  s4671 :: SWord8 = s20 | s4670-  s4672 :: SWord8 = s22 & s4670-  s4673 :: SWord8 = if s4669 then s4671 else s4672-  s4674 :: SWord1 = choose [0:0] s4673-  s4675 :: SBool = s15 /= s4674-  s4676 :: SWord8 = s4663 >>> 1-  s4677 :: SWord8 = s20 | s4676-  s4678 :: SWord8 = s22 & s4676-  s4679 :: SWord8 = if s3767 then s4677 else s4678-  s4680 :: SWord8 = if s18 then s4679 else s4662-  s4681 :: SWord8 = s4680 >>> 1-  s4682 :: SWord8 = s20 | s4681-  s4683 :: SWord8 = s22 & s4681-  s4684 :: SWord8 = if s4675 then s4682 else s4683-  s4685 :: SWord8 = if s18 then s4684 else s4679-  s4686 :: SWord1 = choose [0:0] s4685-  s4687 :: SBool = s15 /= s4686-  s4688 :: SBool = s_2 == s4687-  s4689 :: SWord8 = s4673 >>> 1-  s4690 :: SWord8 = s20 | s4689-  s4691 :: SWord8 = s22 & s4689-  s4692 :: SWord8 = if s4665 then s4690 else s4691-  s4693 :: SWord1 = choose [0:0] s4692-  s4694 :: SBool = s15 /= s4693-  s4695 :: SWord1 = choose [0:0] s4680-  s4696 :: SBool = s15 /= s4695-  s4697 :: SWord8 = s4685 >>> 1-  s4698 :: SWord8 = s20 | s4697-  s4699 :: SWord8 = s22 & s4697-  s4700 :: SWord8 = if s4696 then s4698 else s4699-  s4701 :: SWord8 = if s18 then s4700 else s4684-  s4702 :: SWord8 = s4701 >>> 1-  s4703 :: SWord8 = s20 | s4702-  s4704 :: SWord8 = s22 & s4702-  s4705 :: SWord8 = if s4694 then s4703 else s4704-  s4706 :: SWord8 = if s18 then s4705 else s4700-  s4707 :: SWord1 = choose [0:0] s4706-  s4708 :: SBool = s15 /= s4707-  s4709 :: SBool = s_2 == s4708-  s4710 :: SWord8 = s4692 >>> 1-  s4711 :: SWord8 = s20 | s4710-  s4712 :: SWord8 = s22 & s4710-  s4713 :: SWord8 = if s4687 then s4711 else s4712-  s4714 :: SWord1 = choose [0:0] s4713-  s4715 :: SBool = s15 /= s4714-  s4716 :: SWord1 = choose [0:0] s4701-  s4717 :: SBool = s15 /= s4716-  s4718 :: SWord8 = s4706 >>> 1-  s4719 :: SWord8 = s20 | s4718-  s4720 :: SWord8 = s22 & s4718-  s4721 :: SWord8 = if s4717 then s4719 else s4720-  s4722 :: SWord8 = if s18 then s4721 else s4705-  s4723 :: SWord8 = s4722 >>> 1-  s4724 :: SWord8 = s20 | s4723-  s4725 :: SWord8 = s22 & s4723-  s4726 :: SWord8 = if s4715 then s4724 else s4725-  s4727 :: SWord8 = if s18 then s4726 else s4721-  s4728 :: SWord1 = choose [0:0] s4727-  s4729 :: SBool = s15 /= s4728-  s4730 :: SBool = s_2 == s4729-  s4731 :: SWord8 = s4713 >>> 1-  s4732 :: SWord8 = s20 | s4731-  s4733 :: SWord8 = s22 & s4731-  s4734 :: SWord8 = if s4708 then s4732 else s4733-  s4735 :: SWord1 = choose [0:0] s4734-  s4736 :: SBool = s15 /= s4735-  s4737 :: SWord1 = choose [0:0] s4722-  s4738 :: SBool = s15 /= s4737-  s4739 :: SWord8 = s4727 >>> 1-  s4740 :: SWord8 = s20 | s4739-  s4741 :: SWord8 = s22 & s4739-  s4742 :: SWord8 = if s4738 then s4740 else s4741-  s4743 :: SWord8 = if s18 then s4742 else s4726-  s4744 :: SWord8 = s4743 >>> 1-  s4745 :: SWord8 = s20 | s4744-  s4746 :: SWord8 = s22 & s4744-  s4747 :: SWord8 = if s4736 then s4745 else s4746-  s4748 :: SWord8 = if s18 then s4747 else s4742-  s4749 :: SWord1 = choose [0:0] s4748-  s4750 :: SBool = s15 /= s4749-  s4751 :: SBool = s_2 == s4750-  s4752 :: SWord8 = s4734 >>> 1-  s4753 :: SWord8 = s20 | s4752-  s4754 :: SWord8 = s22 & s4752-  s4755 :: SWord8 = if s4729 then s4753 else s4754-  s4756 :: SWord8 = s4755 >>> 1-  s4757 :: SWord8 = s20 | s4756-  s4758 :: SWord8 = s22 & s4756-  s4759 :: SWord8 = if s4750 then s4757 else s4758-  s4760 :: SWord1 = choose [0:0] s4743-  s4761 :: SBool = s15 /= s4760-  s4762 :: SWord8 = s4748 >>> 1-  s4763 :: SWord8 = s20 | s4762-  s4764 :: SWord8 = s22 & s4762-  s4765 :: SWord8 = if s4761 then s4763 else s4764-  s4766 :: SWord8 = if s25 then s4662 else s3861-  s4767 :: SWord8 = if s166 then s4679 else s4766-  s4768 :: SWord8 = if s25 then s4684 else s4767-  s4769 :: SWord8 = if s166 then s4700 else s4768-  s4770 :: SWord8 = if s25 then s4705 else s4769-  s4771 :: SWord8 = if s166 then s4721 else s4770-  s4772 :: SWord8 = if s25 then s4726 else s4771-  s4773 :: SWord8 = if s166 then s4742 else s4772-  s4774 :: SWord8 = if s25 then s4747 else s4773-  s4775 :: SWord8 = if s166 then s4765 else s4774-  s4776 :: SWord8 = s4755 + s4775-  s4777 :: SBool = s4776 < s4775-  s4778 :: SBool = s4776 < s4755-  s4779 :: SBool = s4777 | s4778-  s4780 :: SWord8 = s4776 >>> 1-  s4781 :: SWord8 = s20 | s4780-  s4782 :: SWord8 = s22 & s4780-  s4783 :: SWord8 = if s4779 then s4781 else s4782-  s4784 :: SWord8 = if s4751 then s4759 else s4783-  s4785 :: SWord8 = s4734 + s4773-  s4786 :: SWord1 = choose [0:0] s4785-  s4787 :: SBool = s15 /= s4786-  s4788 :: SWord8 = if s4787 then s4745 else s4746-  s4789 :: SWord8 = if s18 then s4788 else s4742-  s4790 :: SWord1 = choose [0:0] s4789-  s4791 :: SBool = s15 /= s4790-  s4792 :: SBool = s_2 == s4791-  s4793 :: SBool = s4785 < s4773-  s4794 :: SBool = s4785 < s4734-  s4795 :: SBool = s4793 | s4794-  s4796 :: SWord8 = s4785 >>> 1-  s4797 :: SWord8 = s20 | s4796-  s4798 :: SWord8 = s22 & s4796-  s4799 :: SWord8 = if s4795 then s4797 else s4798-  s4800 :: SWord8 = s4799 >>> 1-  s4801 :: SWord8 = s20 | s4800-  s4802 :: SWord8 = s22 & s4800-  s4803 :: SWord8 = if s4791 then s4801 else s4802-  s4804 :: SWord8 = s4789 >>> 1-  s4805 :: SWord8 = s20 | s4804-  s4806 :: SWord8 = s22 & s4804-  s4807 :: SWord8 = if s4761 then s4805 else s4806-  s4808 :: SWord8 = if s25 then s4788 else s4773-  s4809 :: SWord8 = if s166 then s4807 else s4808-  s4810 :: SWord8 = s4799 + s4809-  s4811 :: SBool = s4810 < s4809-  s4812 :: SBool = s4810 < s4799-  s4813 :: SBool = s4811 | s4812-  s4814 :: SWord8 = s4810 >>> 1-  s4815 :: SWord8 = s20 | s4814-  s4816 :: SWord8 = s22 & s4814-  s4817 :: SWord8 = if s4813 then s4815 else s4816-  s4818 :: SWord8 = if s4792 then s4803 else s4817-  s4819 :: SWord8 = if s4730 then s4784 else s4818-  s4820 :: SWord8 = s4713 + s4771-  s4821 :: SWord1 = choose [0:0] s4820-  s4822 :: SBool = s15 /= s4821-  s4823 :: SWord8 = if s4822 then s4724 else s4725-  s4824 :: SWord8 = if s18 then s4823 else s4721-  s4825 :: SWord1 = choose [0:0] s4824-  s4826 :: SBool = s15 /= s4825-  s4827 :: SBool = s_2 == s4826-  s4828 :: SBool = s4820 < s4771-  s4829 :: SBool = s4820 < s4713-  s4830 :: SBool = s4828 | s4829-  s4831 :: SWord8 = s4820 >>> 1-  s4832 :: SWord8 = s20 | s4831-  s4833 :: SWord8 = s22 & s4831-  s4834 :: SWord8 = if s4830 then s4832 else s4833-  s4835 :: SWord1 = choose [0:0] s4834-  s4836 :: SBool = s15 /= s4835-  s4837 :: SWord8 = s4824 >>> 1-  s4838 :: SWord8 = s20 | s4837-  s4839 :: SWord8 = s22 & s4837-  s4840 :: SWord8 = if s4738 then s4838 else s4839-  s4841 :: SWord8 = if s18 then s4840 else s4823-  s4842 :: SWord8 = s4841 >>> 1-  s4843 :: SWord8 = s20 | s4842-  s4844 :: SWord8 = s22 & s4842-  s4845 :: SWord8 = if s4836 then s4843 else s4844-  s4846 :: SWord8 = if s18 then s4845 else s4840-  s4847 :: SWord1 = choose [0:0] s4846-  s4848 :: SBool = s15 /= s4847-  s4849 :: SBool = s_2 == s4848-  s4850 :: SWord8 = s4834 >>> 1-  s4851 :: SWord8 = s20 | s4850-  s4852 :: SWord8 = s22 & s4850-  s4853 :: SWord8 = if s4826 then s4851 else s4852-  s4854 :: SWord8 = s4853 >>> 1-  s4855 :: SWord8 = s20 | s4854-  s4856 :: SWord8 = s22 & s4854-  s4857 :: SWord8 = if s4848 then s4855 else s4856-  s4858 :: SWord1 = choose [0:0] s4841-  s4859 :: SBool = s15 /= s4858-  s4860 :: SWord8 = s4846 >>> 1-  s4861 :: SWord8 = s20 | s4860-  s4862 :: SWord8 = s22 & s4860-  s4863 :: SWord8 = if s4859 then s4861 else s4862-  s4864 :: SWord8 = if s25 then s4823 else s4771-  s4865 :: SWord8 = if s166 then s4840 else s4864-  s4866 :: SWord8 = if s25 then s4845 else s4865-  s4867 :: SWord8 = if s166 then s4863 else s4866-  s4868 :: SWord8 = s4853 + s4867-  s4869 :: SBool = s4868 < s4867-  s4870 :: SBool = s4868 < s4853-  s4871 :: SBool = s4869 | s4870-  s4872 :: SWord8 = s4868 >>> 1-  s4873 :: SWord8 = s20 | s4872-  s4874 :: SWord8 = s22 & s4872-  s4875 :: SWord8 = if s4871 then s4873 else s4874-  s4876 :: SWord8 = if s4849 then s4857 else s4875-  s4877 :: SWord8 = s4834 + s4865-  s4878 :: SWord1 = choose [0:0] s4877-  s4879 :: SBool = s15 /= s4878-  s4880 :: SWord8 = if s4879 then s4843 else s4844-  s4881 :: SWord8 = if s18 then s4880 else s4840-  s4882 :: SWord1 = choose [0:0] s4881-  s4883 :: SBool = s15 /= s4882-  s4884 :: SBool = s_2 == s4883-  s4885 :: SBool = s4877 < s4865-  s4886 :: SBool = s4877 < s4834-  s4887 :: SBool = s4885 | s4886-  s4888 :: SWord8 = s4877 >>> 1-  s4889 :: SWord8 = s20 | s4888-  s4890 :: SWord8 = s22 & s4888-  s4891 :: SWord8 = if s4887 then s4889 else s4890-  s4892 :: SWord8 = s4891 >>> 1-  s4893 :: SWord8 = s20 | s4892-  s4894 :: SWord8 = s22 & s4892-  s4895 :: SWord8 = if s4883 then s4893 else s4894-  s4896 :: SWord8 = s4881 >>> 1-  s4897 :: SWord8 = s20 | s4896-  s4898 :: SWord8 = s22 & s4896-  s4899 :: SWord8 = if s4859 then s4897 else s4898-  s4900 :: SWord8 = if s25 then s4880 else s4865-  s4901 :: SWord8 = if s166 then s4899 else s4900-  s4902 :: SWord8 = s4891 + s4901-  s4903 :: SBool = s4902 < s4901-  s4904 :: SBool = s4902 < s4891-  s4905 :: SBool = s4903 | s4904-  s4906 :: SWord8 = s4902 >>> 1-  s4907 :: SWord8 = s20 | s4906-  s4908 :: SWord8 = s22 & s4906-  s4909 :: SWord8 = if s4905 then s4907 else s4908-  s4910 :: SWord8 = if s4884 then s4895 else s4909-  s4911 :: SWord8 = if s4827 then s4876 else s4910-  s4912 :: SWord8 = if s4709 then s4819 else s4911-  s4913 :: SWord8 = s4692 + s4769-  s4914 :: SWord1 = choose [0:0] s4913-  s4915 :: SBool = s15 /= s4914-  s4916 :: SWord8 = if s4915 then s4703 else s4704-  s4917 :: SWord8 = if s18 then s4916 else s4700-  s4918 :: SWord1 = choose [0:0] s4917-  s4919 :: SBool = s15 /= s4918-  s4920 :: SBool = s_2 == s4919-  s4921 :: SBool = s4913 < s4769-  s4922 :: SBool = s4913 < s4692-  s4923 :: SBool = s4921 | s4922-  s4924 :: SWord8 = s4913 >>> 1-  s4925 :: SWord8 = s20 | s4924-  s4926 :: SWord8 = s22 & s4924-  s4927 :: SWord8 = if s4923 then s4925 else s4926-  s4928 :: SWord1 = choose [0:0] s4927-  s4929 :: SBool = s15 /= s4928-  s4930 :: SWord8 = s4917 >>> 1-  s4931 :: SWord8 = s20 | s4930-  s4932 :: SWord8 = s22 & s4930-  s4933 :: SWord8 = if s4717 then s4931 else s4932-  s4934 :: SWord8 = if s18 then s4933 else s4916-  s4935 :: SWord8 = s4934 >>> 1-  s4936 :: SWord8 = s20 | s4935-  s4937 :: SWord8 = s22 & s4935-  s4938 :: SWord8 = if s4929 then s4936 else s4937-  s4939 :: SWord8 = if s18 then s4938 else s4933-  s4940 :: SWord1 = choose [0:0] s4939-  s4941 :: SBool = s15 /= s4940-  s4942 :: SBool = s_2 == s4941-  s4943 :: SWord8 = s4927 >>> 1-  s4944 :: SWord8 = s20 | s4943-  s4945 :: SWord8 = s22 & s4943-  s4946 :: SWord8 = if s4919 then s4944 else s4945-  s4947 :: SWord1 = choose [0:0] s4946-  s4948 :: SBool = s15 /= s4947-  s4949 :: SWord1 = choose [0:0] s4934-  s4950 :: SBool = s15 /= s4949-  s4951 :: SWord8 = s4939 >>> 1-  s4952 :: SWord8 = s20 | s4951-  s4953 :: SWord8 = s22 & s4951-  s4954 :: SWord8 = if s4950 then s4952 else s4953-  s4955 :: SWord8 = if s18 then s4954 else s4938-  s4956 :: SWord8 = s4955 >>> 1-  s4957 :: SWord8 = s20 | s4956-  s4958 :: SWord8 = s22 & s4956-  s4959 :: SWord8 = if s4948 then s4957 else s4958-  s4960 :: SWord8 = if s18 then s4959 else s4954-  s4961 :: SWord1 = choose [0:0] s4960-  s4962 :: SBool = s15 /= s4961-  s4963 :: SBool = s_2 == s4962-  s4964 :: SWord8 = s4946 >>> 1-  s4965 :: SWord8 = s20 | s4964-  s4966 :: SWord8 = s22 & s4964-  s4967 :: SWord8 = if s4941 then s4965 else s4966-  s4968 :: SWord8 = s4967 >>> 1-  s4969 :: SWord8 = s20 | s4968-  s4970 :: SWord8 = s22 & s4968-  s4971 :: SWord8 = if s4962 then s4969 else s4970-  s4972 :: SWord1 = choose [0:0] s4955-  s4973 :: SBool = s15 /= s4972-  s4974 :: SWord8 = s4960 >>> 1-  s4975 :: SWord8 = s20 | s4974-  s4976 :: SWord8 = s22 & s4974-  s4977 :: SWord8 = if s4973 then s4975 else s4976-  s4978 :: SWord8 = if s25 then s4916 else s4769-  s4979 :: SWord8 = if s166 then s4933 else s4978-  s4980 :: SWord8 = if s25 then s4938 else s4979-  s4981 :: SWord8 = if s166 then s4954 else s4980-  s4982 :: SWord8 = if s25 then s4959 else s4981-  s4983 :: SWord8 = if s166 then s4977 else s4982-  s4984 :: SWord8 = s4967 + s4983-  s4985 :: SBool = s4984 < s4983-  s4986 :: SBool = s4984 < s4967-  s4987 :: SBool = s4985 | s4986-  s4988 :: SWord8 = s4984 >>> 1-  s4989 :: SWord8 = s20 | s4988-  s4990 :: SWord8 = s22 & s4988-  s4991 :: SWord8 = if s4987 then s4989 else s4990-  s4992 :: SWord8 = if s4963 then s4971 else s4991-  s4993 :: SWord8 = s4946 + s4981-  s4994 :: SWord1 = choose [0:0] s4993-  s4995 :: SBool = s15 /= s4994-  s4996 :: SWord8 = if s4995 then s4957 else s4958-  s4997 :: SWord8 = if s18 then s4996 else s4954-  s4998 :: SWord1 = choose [0:0] s4997-  s4999 :: SBool = s15 /= s4998-  s5000 :: SBool = s_2 == s4999-  s5001 :: SBool = s4993 < s4981-  s5002 :: SBool = s4993 < s4946-  s5003 :: SBool = s5001 | s5002-  s5004 :: SWord8 = s4993 >>> 1-  s5005 :: SWord8 = s20 | s5004-  s5006 :: SWord8 = s22 & s5004-  s5007 :: SWord8 = if s5003 then s5005 else s5006-  s5008 :: SWord8 = s5007 >>> 1-  s5009 :: SWord8 = s20 | s5008-  s5010 :: SWord8 = s22 & s5008-  s5011 :: SWord8 = if s4999 then s5009 else s5010-  s5012 :: SWord8 = s4997 >>> 1-  s5013 :: SWord8 = s20 | s5012-  s5014 :: SWord8 = s22 & s5012-  s5015 :: SWord8 = if s4973 then s5013 else s5014-  s5016 :: SWord8 = if s25 then s4996 else s4981-  s5017 :: SWord8 = if s166 then s5015 else s5016-  s5018 :: SWord8 = s5007 + s5017-  s5019 :: SBool = s5018 < s5017-  s5020 :: SBool = s5018 < s5007-  s5021 :: SBool = s5019 | s5020-  s5022 :: SWord8 = s5018 >>> 1-  s5023 :: SWord8 = s20 | s5022-  s5024 :: SWord8 = s22 & s5022-  s5025 :: SWord8 = if s5021 then s5023 else s5024-  s5026 :: SWord8 = if s5000 then s5011 else s5025-  s5027 :: SWord8 = if s4942 then s4992 else s5026-  s5028 :: SWord8 = s4927 + s4979-  s5029 :: SWord1 = choose [0:0] s5028-  s5030 :: SBool = s15 /= s5029-  s5031 :: SWord8 = if s5030 then s4936 else s4937-  s5032 :: SWord8 = if s18 then s5031 else s4933-  s5033 :: SWord1 = choose [0:0] s5032-  s5034 :: SBool = s15 /= s5033-  s5035 :: SBool = s_2 == s5034-  s5036 :: SBool = s5028 < s4979-  s5037 :: SBool = s5028 < s4927-  s5038 :: SBool = s5036 | s5037-  s5039 :: SWord8 = s5028 >>> 1-  s5040 :: SWord8 = s20 | s5039-  s5041 :: SWord8 = s22 & s5039-  s5042 :: SWord8 = if s5038 then s5040 else s5041-  s5043 :: SWord1 = choose [0:0] s5042-  s5044 :: SBool = s15 /= s5043-  s5045 :: SWord8 = s5032 >>> 1-  s5046 :: SWord8 = s20 | s5045-  s5047 :: SWord8 = s22 & s5045-  s5048 :: SWord8 = if s4950 then s5046 else s5047-  s5049 :: SWord8 = if s18 then s5048 else s5031-  s5050 :: SWord8 = s5049 >>> 1-  s5051 :: SWord8 = s20 | s5050-  s5052 :: SWord8 = s22 & s5050-  s5053 :: SWord8 = if s5044 then s5051 else s5052-  s5054 :: SWord8 = if s18 then s5053 else s5048-  s5055 :: SWord1 = choose [0:0] s5054-  s5056 :: SBool = s15 /= s5055-  s5057 :: SBool = s_2 == s5056-  s5058 :: SWord8 = s5042 >>> 1-  s5059 :: SWord8 = s20 | s5058-  s5060 :: SWord8 = s22 & s5058-  s5061 :: SWord8 = if s5034 then s5059 else s5060-  s5062 :: SWord8 = s5061 >>> 1-  s5063 :: SWord8 = s20 | s5062-  s5064 :: SWord8 = s22 & s5062-  s5065 :: SWord8 = if s5056 then s5063 else s5064-  s5066 :: SWord1 = choose [0:0] s5049-  s5067 :: SBool = s15 /= s5066-  s5068 :: SWord8 = s5054 >>> 1-  s5069 :: SWord8 = s20 | s5068-  s5070 :: SWord8 = s22 & s5068-  s5071 :: SWord8 = if s5067 then s5069 else s5070-  s5072 :: SWord8 = if s25 then s5031 else s4979-  s5073 :: SWord8 = if s166 then s5048 else s5072-  s5074 :: SWord8 = if s25 then s5053 else s5073-  s5075 :: SWord8 = if s166 then s5071 else s5074-  s5076 :: SWord8 = s5061 + s5075-  s5077 :: SBool = s5076 < s5075-  s5078 :: SBool = s5076 < s5061-  s5079 :: SBool = s5077 | s5078-  s5080 :: SWord8 = s5076 >>> 1-  s5081 :: SWord8 = s20 | s5080-  s5082 :: SWord8 = s22 & s5080-  s5083 :: SWord8 = if s5079 then s5081 else s5082-  s5084 :: SWord8 = if s5057 then s5065 else s5083-  s5085 :: SWord8 = s5042 + s5073-  s5086 :: SWord1 = choose [0:0] s5085-  s5087 :: SBool = s15 /= s5086-  s5088 :: SWord8 = if s5087 then s5051 else s5052-  s5089 :: SWord8 = if s18 then s5088 else s5048-  s5090 :: SWord1 = choose [0:0] s5089-  s5091 :: SBool = s15 /= s5090-  s5092 :: SBool = s_2 == s5091-  s5093 :: SBool = s5085 < s5073-  s5094 :: SBool = s5085 < s5042-  s5095 :: SBool = s5093 | s5094-  s5096 :: SWord8 = s5085 >>> 1-  s5097 :: SWord8 = s20 | s5096-  s5098 :: SWord8 = s22 & s5096-  s5099 :: SWord8 = if s5095 then s5097 else s5098-  s5100 :: SWord8 = s5099 >>> 1-  s5101 :: SWord8 = s20 | s5100-  s5102 :: SWord8 = s22 & s5100-  s5103 :: SWord8 = if s5091 then s5101 else s5102-  s5104 :: SWord8 = s5089 >>> 1-  s5105 :: SWord8 = s20 | s5104-  s5106 :: SWord8 = s22 & s5104-  s5107 :: SWord8 = if s5067 then s5105 else s5106-  s5108 :: SWord8 = if s25 then s5088 else s5073-  s5109 :: SWord8 = if s166 then s5107 else s5108-  s5110 :: SWord8 = s5099 + s5109-  s5111 :: SBool = s5110 < s5109-  s5112 :: SBool = s5110 < s5099-  s5113 :: SBool = s5111 | s5112-  s5114 :: SWord8 = s5110 >>> 1-  s5115 :: SWord8 = s20 | s5114-  s5116 :: SWord8 = s22 & s5114-  s5117 :: SWord8 = if s5113 then s5115 else s5116-  s5118 :: SWord8 = if s5092 then s5103 else s5117-  s5119 :: SWord8 = if s5035 then s5084 else s5118-  s5120 :: SWord8 = if s4920 then s5027 else s5119-  s5121 :: SWord8 = if s4688 then s4912 else s5120-  s5122 :: SWord8 = s4673 + s4767-  s5123 :: SWord1 = choose [0:0] s5122-  s5124 :: SBool = s15 /= s5123-  s5125 :: SWord8 = if s5124 then s4682 else s4683-  s5126 :: SWord8 = if s18 then s5125 else s4679-  s5127 :: SWord1 = choose [0:0] s5126-  s5128 :: SBool = s15 /= s5127-  s5129 :: SBool = s_2 == s5128-  s5130 :: SBool = s5122 < s4767-  s5131 :: SBool = s5122 < s4673-  s5132 :: SBool = s5130 | s5131-  s5133 :: SWord8 = s5122 >>> 1-  s5134 :: SWord8 = s20 | s5133-  s5135 :: SWord8 = s22 & s5133-  s5136 :: SWord8 = if s5132 then s5134 else s5135-  s5137 :: SWord1 = choose [0:0] s5136-  s5138 :: SBool = s15 /= s5137-  s5139 :: SWord8 = s5126 >>> 1-  s5140 :: SWord8 = s20 | s5139-  s5141 :: SWord8 = s22 & s5139-  s5142 :: SWord8 = if s4696 then s5140 else s5141-  s5143 :: SWord8 = if s18 then s5142 else s5125-  s5144 :: SWord8 = s5143 >>> 1-  s5145 :: SWord8 = s20 | s5144-  s5146 :: SWord8 = s22 & s5144-  s5147 :: SWord8 = if s5138 then s5145 else s5146-  s5148 :: SWord8 = if s18 then s5147 else s5142-  s5149 :: SWord1 = choose [0:0] s5148-  s5150 :: SBool = s15 /= s5149-  s5151 :: SBool = s_2 == s5150-  s5152 :: SWord8 = s5136 >>> 1-  s5153 :: SWord8 = s20 | s5152-  s5154 :: SWord8 = s22 & s5152-  s5155 :: SWord8 = if s5128 then s5153 else s5154-  s5156 :: SWord1 = choose [0:0] s5155-  s5157 :: SBool = s15 /= s5156-  s5158 :: SWord1 = choose [0:0] s5143-  s5159 :: SBool = s15 /= s5158-  s5160 :: SWord8 = s5148 >>> 1-  s5161 :: SWord8 = s20 | s5160-  s5162 :: SWord8 = s22 & s5160-  s5163 :: SWord8 = if s5159 then s5161 else s5162-  s5164 :: SWord8 = if s18 then s5163 else s5147-  s5165 :: SWord8 = s5164 >>> 1-  s5166 :: SWord8 = s20 | s5165-  s5167 :: SWord8 = s22 & s5165-  s5168 :: SWord8 = if s5157 then s5166 else s5167-  s5169 :: SWord8 = if s18 then s5168 else s5163-  s5170 :: SWord1 = choose [0:0] s5169-  s5171 :: SBool = s15 /= s5170-  s5172 :: SBool = s_2 == s5171-  s5173 :: SWord8 = s5155 >>> 1-  s5174 :: SWord8 = s20 | s5173-  s5175 :: SWord8 = s22 & s5173-  s5176 :: SWord8 = if s5150 then s5174 else s5175-  s5177 :: SWord1 = choose [0:0] s5176-  s5178 :: SBool = s15 /= s5177-  s5179 :: SWord1 = choose [0:0] s5164-  s5180 :: SBool = s15 /= s5179-  s5181 :: SWord8 = s5169 >>> 1-  s5182 :: SWord8 = s20 | s5181-  s5183 :: SWord8 = s22 & s5181-  s5184 :: SWord8 = if s5180 then s5182 else s5183-  s5185 :: SWord8 = if s18 then s5184 else s5168-  s5186 :: SWord8 = s5185 >>> 1-  s5187 :: SWord8 = s20 | s5186-  s5188 :: SWord8 = s22 & s5186-  s5189 :: SWord8 = if s5178 then s5187 else s5188-  s5190 :: SWord8 = if s18 then s5189 else s5184-  s5191 :: SWord1 = choose [0:0] s5190-  s5192 :: SBool = s15 /= s5191-  s5193 :: SBool = s_2 == s5192-  s5194 :: SWord8 = s5176 >>> 1-  s5195 :: SWord8 = s20 | s5194-  s5196 :: SWord8 = s22 & s5194-  s5197 :: SWord8 = if s5171 then s5195 else s5196-  s5198 :: SWord8 = s5197 >>> 1-  s5199 :: SWord8 = s20 | s5198-  s5200 :: SWord8 = s22 & s5198-  s5201 :: SWord8 = if s5192 then s5199 else s5200-  s5202 :: SWord1 = choose [0:0] s5185-  s5203 :: SBool = s15 /= s5202-  s5204 :: SWord8 = s5190 >>> 1-  s5205 :: SWord8 = s20 | s5204-  s5206 :: SWord8 = s22 & s5204-  s5207 :: SWord8 = if s5203 then s5205 else s5206-  s5208 :: SWord8 = if s25 then s5125 else s4767-  s5209 :: SWord8 = if s166 then s5142 else s5208-  s5210 :: SWord8 = if s25 then s5147 else s5209-  s5211 :: SWord8 = if s166 then s5163 else s5210-  s5212 :: SWord8 = if s25 then s5168 else s5211-  s5213 :: SWord8 = if s166 then s5184 else s5212-  s5214 :: SWord8 = if s25 then s5189 else s5213-  s5215 :: SWord8 = if s166 then s5207 else s5214-  s5216 :: SWord8 = s5197 + s5215-  s5217 :: SBool = s5216 < s5215-  s5218 :: SBool = s5216 < s5197-  s5219 :: SBool = s5217 | s5218-  s5220 :: SWord8 = s5216 >>> 1-  s5221 :: SWord8 = s20 | s5220-  s5222 :: SWord8 = s22 & s5220-  s5223 :: SWord8 = if s5219 then s5221 else s5222-  s5224 :: SWord8 = if s5193 then s5201 else s5223-  s5225 :: SWord8 = s5176 + s5213-  s5226 :: SWord1 = choose [0:0] s5225-  s5227 :: SBool = s15 /= s5226-  s5228 :: SWord8 = if s5227 then s5187 else s5188-  s5229 :: SWord8 = if s18 then s5228 else s5184-  s5230 :: SWord1 = choose [0:0] s5229-  s5231 :: SBool = s15 /= s5230-  s5232 :: SBool = s_2 == s5231-  s5233 :: SBool = s5225 < s5213-  s5234 :: SBool = s5225 < s5176-  s5235 :: SBool = s5233 | s5234-  s5236 :: SWord8 = s5225 >>> 1-  s5237 :: SWord8 = s20 | s5236-  s5238 :: SWord8 = s22 & s5236-  s5239 :: SWord8 = if s5235 then s5237 else s5238-  s5240 :: SWord8 = s5239 >>> 1-  s5241 :: SWord8 = s20 | s5240-  s5242 :: SWord8 = s22 & s5240-  s5243 :: SWord8 = if s5231 then s5241 else s5242-  s5244 :: SWord8 = s5229 >>> 1-  s5245 :: SWord8 = s20 | s5244-  s5246 :: SWord8 = s22 & s5244-  s5247 :: SWord8 = if s5203 then s5245 else s5246-  s5248 :: SWord8 = if s25 then s5228 else s5213-  s5249 :: SWord8 = if s166 then s5247 else s5248-  s5250 :: SWord8 = s5239 + s5249-  s5251 :: SBool = s5250 < s5249-  s5252 :: SBool = s5250 < s5239-  s5253 :: SBool = s5251 | s5252-  s5254 :: SWord8 = s5250 >>> 1-  s5255 :: SWord8 = s20 | s5254-  s5256 :: SWord8 = s22 & s5254-  s5257 :: SWord8 = if s5253 then s5255 else s5256-  s5258 :: SWord8 = if s5232 then s5243 else s5257-  s5259 :: SWord8 = if s5172 then s5224 else s5258-  s5260 :: SWord8 = s5155 + s5211-  s5261 :: SWord1 = choose [0:0] s5260-  s5262 :: SBool = s15 /= s5261-  s5263 :: SWord8 = if s5262 then s5166 else s5167-  s5264 :: SWord8 = if s18 then s5263 else s5163-  s5265 :: SWord1 = choose [0:0] s5264-  s5266 :: SBool = s15 /= s5265-  s5267 :: SBool = s_2 == s5266-  s5268 :: SBool = s5260 < s5211-  s5269 :: SBool = s5260 < s5155-  s5270 :: SBool = s5268 | s5269-  s5271 :: SWord8 = s5260 >>> 1-  s5272 :: SWord8 = s20 | s5271-  s5273 :: SWord8 = s22 & s5271-  s5274 :: SWord8 = if s5270 then s5272 else s5273-  s5275 :: SWord1 = choose [0:0] s5274-  s5276 :: SBool = s15 /= s5275-  s5277 :: SWord8 = s5264 >>> 1-  s5278 :: SWord8 = s20 | s5277-  s5279 :: SWord8 = s22 & s5277-  s5280 :: SWord8 = if s5180 then s5278 else s5279-  s5281 :: SWord8 = if s18 then s5280 else s5263-  s5282 :: SWord8 = s5281 >>> 1-  s5283 :: SWord8 = s20 | s5282-  s5284 :: SWord8 = s22 & s5282-  s5285 :: SWord8 = if s5276 then s5283 else s5284-  s5286 :: SWord8 = if s18 then s5285 else s5280-  s5287 :: SWord1 = choose [0:0] s5286-  s5288 :: SBool = s15 /= s5287-  s5289 :: SBool = s_2 == s5288-  s5290 :: SWord8 = s5274 >>> 1-  s5291 :: SWord8 = s20 | s5290-  s5292 :: SWord8 = s22 & s5290-  s5293 :: SWord8 = if s5266 then s5291 else s5292-  s5294 :: SWord8 = s5293 >>> 1-  s5295 :: SWord8 = s20 | s5294-  s5296 :: SWord8 = s22 & s5294-  s5297 :: SWord8 = if s5288 then s5295 else s5296-  s5298 :: SWord1 = choose [0:0] s5281-  s5299 :: SBool = s15 /= s5298-  s5300 :: SWord8 = s5286 >>> 1-  s5301 :: SWord8 = s20 | s5300-  s5302 :: SWord8 = s22 & s5300-  s5303 :: SWord8 = if s5299 then s5301 else s5302-  s5304 :: SWord8 = if s25 then s5263 else s5211-  s5305 :: SWord8 = if s166 then s5280 else s5304-  s5306 :: SWord8 = if s25 then s5285 else s5305-  s5307 :: SWord8 = if s166 then s5303 else s5306-  s5308 :: SWord8 = s5293 + s5307-  s5309 :: SBool = s5308 < s5307-  s5310 :: SBool = s5308 < s5293-  s5311 :: SBool = s5309 | s5310-  s5312 :: SWord8 = s5308 >>> 1-  s5313 :: SWord8 = s20 | s5312-  s5314 :: SWord8 = s22 & s5312-  s5315 :: SWord8 = if s5311 then s5313 else s5314-  s5316 :: SWord8 = if s5289 then s5297 else s5315-  s5317 :: SWord8 = s5274 + s5305-  s5318 :: SWord1 = choose [0:0] s5317-  s5319 :: SBool = s15 /= s5318-  s5320 :: SWord8 = if s5319 then s5283 else s5284-  s5321 :: SWord8 = if s18 then s5320 else s5280-  s5322 :: SWord1 = choose [0:0] s5321-  s5323 :: SBool = s15 /= s5322-  s5324 :: SBool = s_2 == s5323-  s5325 :: SBool = s5317 < s5305-  s5326 :: SBool = s5317 < s5274-  s5327 :: SBool = s5325 | s5326-  s5328 :: SWord8 = s5317 >>> 1-  s5329 :: SWord8 = s20 | s5328-  s5330 :: SWord8 = s22 & s5328-  s5331 :: SWord8 = if s5327 then s5329 else s5330-  s5332 :: SWord8 = s5331 >>> 1-  s5333 :: SWord8 = s20 | s5332-  s5334 :: SWord8 = s22 & s5332-  s5335 :: SWord8 = if s5323 then s5333 else s5334-  s5336 :: SWord8 = s5321 >>> 1-  s5337 :: SWord8 = s20 | s5336-  s5338 :: SWord8 = s22 & s5336-  s5339 :: SWord8 = if s5299 then s5337 else s5338-  s5340 :: SWord8 = if s25 then s5320 else s5305-  s5341 :: SWord8 = if s166 then s5339 else s5340-  s5342 :: SWord8 = s5331 + s5341-  s5343 :: SBool = s5342 < s5341-  s5344 :: SBool = s5342 < s5331-  s5345 :: SBool = s5343 | s5344-  s5346 :: SWord8 = s5342 >>> 1-  s5347 :: SWord8 = s20 | s5346-  s5348 :: SWord8 = s22 & s5346-  s5349 :: SWord8 = if s5345 then s5347 else s5348-  s5350 :: SWord8 = if s5324 then s5335 else s5349-  s5351 :: SWord8 = if s5267 then s5316 else s5350-  s5352 :: SWord8 = if s5151 then s5259 else s5351-  s5353 :: SWord8 = s5136 + s5209-  s5354 :: SWord1 = choose [0:0] s5353-  s5355 :: SBool = s15 /= s5354-  s5356 :: SWord8 = if s5355 then s5145 else s5146-  s5357 :: SWord8 = if s18 then s5356 else s5142-  s5358 :: SWord1 = choose [0:0] s5357-  s5359 :: SBool = s15 /= s5358-  s5360 :: SBool = s_2 == s5359-  s5361 :: SBool = s5353 < s5209-  s5362 :: SBool = s5353 < s5136-  s5363 :: SBool = s5361 | s5362-  s5364 :: SWord8 = s5353 >>> 1-  s5365 :: SWord8 = s20 | s5364-  s5366 :: SWord8 = s22 & s5364-  s5367 :: SWord8 = if s5363 then s5365 else s5366-  s5368 :: SWord1 = choose [0:0] s5367-  s5369 :: SBool = s15 /= s5368-  s5370 :: SWord8 = s5357 >>> 1-  s5371 :: SWord8 = s20 | s5370-  s5372 :: SWord8 = s22 & s5370-  s5373 :: SWord8 = if s5159 then s5371 else s5372-  s5374 :: SWord8 = if s18 then s5373 else s5356-  s5375 :: SWord8 = s5374 >>> 1-  s5376 :: SWord8 = s20 | s5375-  s5377 :: SWord8 = s22 & s5375-  s5378 :: SWord8 = if s5369 then s5376 else s5377-  s5379 :: SWord8 = if s18 then s5378 else s5373-  s5380 :: SWord1 = choose [0:0] s5379-  s5381 :: SBool = s15 /= s5380-  s5382 :: SBool = s_2 == s5381-  s5383 :: SWord8 = s5367 >>> 1-  s5384 :: SWord8 = s20 | s5383-  s5385 :: SWord8 = s22 & s5383-  s5386 :: SWord8 = if s5359 then s5384 else s5385-  s5387 :: SWord1 = choose [0:0] s5386-  s5388 :: SBool = s15 /= s5387-  s5389 :: SWord1 = choose [0:0] s5374-  s5390 :: SBool = s15 /= s5389-  s5391 :: SWord8 = s5379 >>> 1-  s5392 :: SWord8 = s20 | s5391-  s5393 :: SWord8 = s22 & s5391-  s5394 :: SWord8 = if s5390 then s5392 else s5393-  s5395 :: SWord8 = if s18 then s5394 else s5378-  s5396 :: SWord8 = s5395 >>> 1-  s5397 :: SWord8 = s20 | s5396-  s5398 :: SWord8 = s22 & s5396-  s5399 :: SWord8 = if s5388 then s5397 else s5398-  s5400 :: SWord8 = if s18 then s5399 else s5394-  s5401 :: SWord1 = choose [0:0] s5400-  s5402 :: SBool = s15 /= s5401-  s5403 :: SBool = s_2 == s5402-  s5404 :: SWord8 = s5386 >>> 1-  s5405 :: SWord8 = s20 | s5404-  s5406 :: SWord8 = s22 & s5404-  s5407 :: SWord8 = if s5381 then s5405 else s5406-  s5408 :: SWord8 = s5407 >>> 1-  s5409 :: SWord8 = s20 | s5408-  s5410 :: SWord8 = s22 & s5408-  s5411 :: SWord8 = if s5402 then s5409 else s5410-  s5412 :: SWord1 = choose [0:0] s5395-  s5413 :: SBool = s15 /= s5412-  s5414 :: SWord8 = s5400 >>> 1-  s5415 :: SWord8 = s20 | s5414-  s5416 :: SWord8 = s22 & s5414-  s5417 :: SWord8 = if s5413 then s5415 else s5416-  s5418 :: SWord8 = if s25 then s5356 else s5209-  s5419 :: SWord8 = if s166 then s5373 else s5418-  s5420 :: SWord8 = if s25 then s5378 else s5419-  s5421 :: SWord8 = if s166 then s5394 else s5420-  s5422 :: SWord8 = if s25 then s5399 else s5421-  s5423 :: SWord8 = if s166 then s5417 else s5422-  s5424 :: SWord8 = s5407 + s5423-  s5425 :: SBool = s5424 < s5423-  s5426 :: SBool = s5424 < s5407-  s5427 :: SBool = s5425 | s5426-  s5428 :: SWord8 = s5424 >>> 1-  s5429 :: SWord8 = s20 | s5428-  s5430 :: SWord8 = s22 & s5428-  s5431 :: SWord8 = if s5427 then s5429 else s5430-  s5432 :: SWord8 = if s5403 then s5411 else s5431-  s5433 :: SWord8 = s5386 + s5421-  s5434 :: SWord1 = choose [0:0] s5433-  s5435 :: SBool = s15 /= s5434-  s5436 :: SWord8 = if s5435 then s5397 else s5398-  s5437 :: SWord8 = if s18 then s5436 else s5394-  s5438 :: SWord1 = choose [0:0] s5437-  s5439 :: SBool = s15 /= s5438-  s5440 :: SBool = s_2 == s5439-  s5441 :: SBool = s5433 < s5421-  s5442 :: SBool = s5433 < s5386-  s5443 :: SBool = s5441 | s5442-  s5444 :: SWord8 = s5433 >>> 1-  s5445 :: SWord8 = s20 | s5444-  s5446 :: SWord8 = s22 & s5444-  s5447 :: SWord8 = if s5443 then s5445 else s5446-  s5448 :: SWord8 = s5447 >>> 1-  s5449 :: SWord8 = s20 | s5448-  s5450 :: SWord8 = s22 & s5448-  s5451 :: SWord8 = if s5439 then s5449 else s5450-  s5452 :: SWord8 = s5437 >>> 1-  s5453 :: SWord8 = s20 | s5452-  s5454 :: SWord8 = s22 & s5452-  s5455 :: SWord8 = if s5413 then s5453 else s5454-  s5456 :: SWord8 = if s25 then s5436 else s5421-  s5457 :: SWord8 = if s166 then s5455 else s5456-  s5458 :: SWord8 = s5447 + s5457-  s5459 :: SBool = s5458 < s5457-  s5460 :: SBool = s5458 < s5447-  s5461 :: SBool = s5459 | s5460-  s5462 :: SWord8 = s5458 >>> 1-  s5463 :: SWord8 = s20 | s5462-  s5464 :: SWord8 = s22 & s5462-  s5465 :: SWord8 = if s5461 then s5463 else s5464-  s5466 :: SWord8 = if s5440 then s5451 else s5465-  s5467 :: SWord8 = if s5382 then s5432 else s5466-  s5468 :: SWord8 = s5367 + s5419-  s5469 :: SWord1 = choose [0:0] s5468-  s5470 :: SBool = s15 /= s5469-  s5471 :: SWord8 = if s5470 then s5376 else s5377-  s5472 :: SWord8 = if s18 then s5471 else s5373-  s5473 :: SWord1 = choose [0:0] s5472-  s5474 :: SBool = s15 /= s5473-  s5475 :: SBool = s_2 == s5474-  s5476 :: SBool = s5468 < s5419-  s5477 :: SBool = s5468 < s5367-  s5478 :: SBool = s5476 | s5477-  s5479 :: SWord8 = s5468 >>> 1-  s5480 :: SWord8 = s20 | s5479-  s5481 :: SWord8 = s22 & s5479-  s5482 :: SWord8 = if s5478 then s5480 else s5481-  s5483 :: SWord1 = choose [0:0] s5482-  s5484 :: SBool = s15 /= s5483-  s5485 :: SWord8 = s5472 >>> 1-  s5486 :: SWord8 = s20 | s5485-  s5487 :: SWord8 = s22 & s5485-  s5488 :: SWord8 = if s5390 then s5486 else s5487-  s5489 :: SWord8 = if s18 then s5488 else s5471-  s5490 :: SWord8 = s5489 >>> 1-  s5491 :: SWord8 = s20 | s5490-  s5492 :: SWord8 = s22 & s5490-  s5493 :: SWord8 = if s5484 then s5491 else s5492-  s5494 :: SWord8 = if s18 then s5493 else s5488-  s5495 :: SWord1 = choose [0:0] s5494-  s5496 :: SBool = s15 /= s5495-  s5497 :: SBool = s_2 == s5496-  s5498 :: SWord8 = s5482 >>> 1-  s5499 :: SWord8 = s20 | s5498-  s5500 :: SWord8 = s22 & s5498-  s5501 :: SWord8 = if s5474 then s5499 else s5500-  s5502 :: SWord8 = s5501 >>> 1-  s5503 :: SWord8 = s20 | s5502-  s5504 :: SWord8 = s22 & s5502-  s5505 :: SWord8 = if s5496 then s5503 else s5504-  s5506 :: SWord1 = choose [0:0] s5489-  s5507 :: SBool = s15 /= s5506-  s5508 :: SWord8 = s5494 >>> 1-  s5509 :: SWord8 = s20 | s5508-  s5510 :: SWord8 = s22 & s5508-  s5511 :: SWord8 = if s5507 then s5509 else s5510-  s5512 :: SWord8 = if s25 then s5471 else s5419-  s5513 :: SWord8 = if s166 then s5488 else s5512-  s5514 :: SWord8 = if s25 then s5493 else s5513-  s5515 :: SWord8 = if s166 then s5511 else s5514-  s5516 :: SWord8 = s5501 + s5515-  s5517 :: SBool = s5516 < s5515-  s5518 :: SBool = s5516 < s5501-  s5519 :: SBool = s5517 | s5518-  s5520 :: SWord8 = s5516 >>> 1-  s5521 :: SWord8 = s20 | s5520-  s5522 :: SWord8 = s22 & s5520-  s5523 :: SWord8 = if s5519 then s5521 else s5522-  s5524 :: SWord8 = if s5497 then s5505 else s5523-  s5525 :: SWord8 = s5482 + s5513-  s5526 :: SWord1 = choose [0:0] s5525-  s5527 :: SBool = s15 /= s5526-  s5528 :: SWord8 = if s5527 then s5491 else s5492-  s5529 :: SWord8 = if s18 then s5528 else s5488-  s5530 :: SWord1 = choose [0:0] s5529-  s5531 :: SBool = s15 /= s5530-  s5532 :: SBool = s_2 == s5531-  s5533 :: SBool = s5525 < s5513-  s5534 :: SBool = s5525 < s5482-  s5535 :: SBool = s5533 | s5534-  s5536 :: SWord8 = s5525 >>> 1-  s5537 :: SWord8 = s20 | s5536-  s5538 :: SWord8 = s22 & s5536-  s5539 :: SWord8 = if s5535 then s5537 else s5538-  s5540 :: SWord8 = s5539 >>> 1-  s5541 :: SWord8 = s20 | s5540-  s5542 :: SWord8 = s22 & s5540-  s5543 :: SWord8 = if s5531 then s5541 else s5542-  s5544 :: SWord8 = s5529 >>> 1-  s5545 :: SWord8 = s20 | s5544-  s5546 :: SWord8 = s22 & s5544-  s5547 :: SWord8 = if s5507 then s5545 else s5546-  s5548 :: SWord8 = if s25 then s5528 else s5513-  s5549 :: SWord8 = if s166 then s5547 else s5548-  s5550 :: SWord8 = s5539 + s5549-  s5551 :: SBool = s5550 < s5549-  s5552 :: SBool = s5550 < s5539-  s5553 :: SBool = s5551 | s5552-  s5554 :: SWord8 = s5550 >>> 1-  s5555 :: SWord8 = s20 | s5554-  s5556 :: SWord8 = s22 & s5554-  s5557 :: SWord8 = if s5553 then s5555 else s5556-  s5558 :: SWord8 = if s5532 then s5543 else s5557-  s5559 :: SWord8 = if s5475 then s5524 else s5558-  s5560 :: SWord8 = if s5360 then s5467 else s5559-  s5561 :: SWord8 = if s5129 then s5352 else s5560-  s5562 :: SWord8 = if s4666 then s5121 else s5561-  s5563 :: SWord8 = if s3738 then s4658 else s5562-  s5564 :: SWord8 = s3723 + s3859-  s5565 :: SWord1 = choose [0:0] s5564-  s5566 :: SBool = s15 /= s5565-  s5567 :: SWord8 = if s5566 then s3732 else s3733-  s5568 :: SWord8 = if s18 then s5567 else s3729-  s5569 :: SWord1 = choose [0:0] s5568-  s5570 :: SBool = s15 /= s5569-  s5571 :: SBool = s_2 == s5570-  s5572 :: SBool = s5564 < s3859-  s5573 :: SBool = s5564 < s3723-  s5574 :: SBool = s5572 | s5573-  s5575 :: SWord8 = s5564 >>> 1-  s5576 :: SWord8 = s20 | s5575-  s5577 :: SWord8 = s22 & s5575-  s5578 :: SWord8 = if s5574 then s5576 else s5577-  s5579 :: SWord1 = choose [0:0] s5578-  s5580 :: SBool = s15 /= s5579-  s5581 :: SWord8 = s5568 >>> 1-  s5582 :: SWord8 = s20 | s5581-  s5583 :: SWord8 = s22 & s5581-  s5584 :: SWord8 = if s3746 then s5582 else s5583-  s5585 :: SWord8 = if s18 then s5584 else s5567-  s5586 :: SWord8 = s5585 >>> 1-  s5587 :: SWord8 = s20 | s5586-  s5588 :: SWord8 = s22 & s5586-  s5589 :: SWord8 = if s5580 then s5587 else s5588-  s5590 :: SWord8 = if s18 then s5589 else s5584-  s5591 :: SWord1 = choose [0:0] s5590-  s5592 :: SBool = s15 /= s5591-  s5593 :: SBool = s_2 == s5592-  s5594 :: SWord8 = s5578 >>> 1-  s5595 :: SWord8 = s20 | s5594-  s5596 :: SWord8 = s22 & s5594-  s5597 :: SWord8 = if s5570 then s5595 else s5596-  s5598 :: SWord1 = choose [0:0] s5597-  s5599 :: SBool = s15 /= s5598-  s5600 :: SWord1 = choose [0:0] s5585-  s5601 :: SBool = s15 /= s5600-  s5602 :: SWord8 = s5590 >>> 1-  s5603 :: SWord8 = s20 | s5602-  s5604 :: SWord8 = s22 & s5602-  s5605 :: SWord8 = if s5601 then s5603 else s5604-  s5606 :: SWord8 = if s18 then s5605 else s5589-  s5607 :: SWord8 = s5606 >>> 1-  s5608 :: SWord8 = s20 | s5607-  s5609 :: SWord8 = s22 & s5607-  s5610 :: SWord8 = if s5599 then s5608 else s5609-  s5611 :: SWord8 = if s18 then s5610 else s5605-  s5612 :: SWord1 = choose [0:0] s5611-  s5613 :: SBool = s15 /= s5612-  s5614 :: SBool = s_2 == s5613-  s5615 :: SWord8 = s5597 >>> 1-  s5616 :: SWord8 = s20 | s5615-  s5617 :: SWord8 = s22 & s5615-  s5618 :: SWord8 = if s5592 then s5616 else s5617-  s5619 :: SWord1 = choose [0:0] s5618-  s5620 :: SBool = s15 /= s5619-  s5621 :: SWord1 = choose [0:0] s5606-  s5622 :: SBool = s15 /= s5621-  s5623 :: SWord8 = s5611 >>> 1-  s5624 :: SWord8 = s20 | s5623-  s5625 :: SWord8 = s22 & s5623-  s5626 :: SWord8 = if s5622 then s5624 else s5625-  s5627 :: SWord8 = if s18 then s5626 else s5610-  s5628 :: SWord8 = s5627 >>> 1-  s5629 :: SWord8 = s20 | s5628-  s5630 :: SWord8 = s22 & s5628-  s5631 :: SWord8 = if s5620 then s5629 else s5630-  s5632 :: SWord8 = if s18 then s5631 else s5626-  s5633 :: SWord1 = choose [0:0] s5632-  s5634 :: SBool = s15 /= s5633-  s5635 :: SBool = s_2 == s5634-  s5636 :: SWord8 = s5618 >>> 1-  s5637 :: SWord8 = s20 | s5636-  s5638 :: SWord8 = s22 & s5636-  s5639 :: SWord8 = if s5613 then s5637 else s5638-  s5640 :: SWord1 = choose [0:0] s5639-  s5641 :: SBool = s15 /= s5640-  s5642 :: SWord1 = choose [0:0] s5627-  s5643 :: SBool = s15 /= s5642-  s5644 :: SWord8 = s5632 >>> 1-  s5645 :: SWord8 = s20 | s5644-  s5646 :: SWord8 = s22 & s5644-  s5647 :: SWord8 = if s5643 then s5645 else s5646-  s5648 :: SWord8 = if s18 then s5647 else s5631-  s5649 :: SWord8 = s5648 >>> 1-  s5650 :: SWord8 = s20 | s5649-  s5651 :: SWord8 = s22 & s5649-  s5652 :: SWord8 = if s5641 then s5650 else s5651-  s5653 :: SWord8 = if s18 then s5652 else s5647-  s5654 :: SWord1 = choose [0:0] s5653-  s5655 :: SBool = s15 /= s5654-  s5656 :: SBool = s_2 == s5655-  s5657 :: SWord8 = s5639 >>> 1-  s5658 :: SWord8 = s20 | s5657-  s5659 :: SWord8 = s22 & s5657-  s5660 :: SWord8 = if s5634 then s5658 else s5659-  s5661 :: SWord1 = choose [0:0] s5660-  s5662 :: SBool = s15 /= s5661-  s5663 :: SWord1 = choose [0:0] s5648-  s5664 :: SBool = s15 /= s5663-  s5665 :: SWord8 = s5653 >>> 1-  s5666 :: SWord8 = s20 | s5665-  s5667 :: SWord8 = s22 & s5665-  s5668 :: SWord8 = if s5664 then s5666 else s5667-  s5669 :: SWord8 = if s18 then s5668 else s5652-  s5670 :: SWord8 = s5669 >>> 1-  s5671 :: SWord8 = s20 | s5670-  s5672 :: SWord8 = s22 & s5670-  s5673 :: SWord8 = if s5662 then s5671 else s5672-  s5674 :: SWord8 = if s18 then s5673 else s5668-  s5675 :: SWord1 = choose [0:0] s5674-  s5676 :: SBool = s15 /= s5675-  s5677 :: SBool = s_2 == s5676-  s5678 :: SWord8 = s5660 >>> 1-  s5679 :: SWord8 = s20 | s5678-  s5680 :: SWord8 = s22 & s5678-  s5681 :: SWord8 = if s5655 then s5679 else s5680-  s5682 :: SWord8 = s5681 >>> 1-  s5683 :: SWord8 = s20 | s5682-  s5684 :: SWord8 = s22 & s5682-  s5685 :: SWord8 = if s5676 then s5683 else s5684-  s5686 :: SWord1 = choose [0:0] s5669-  s5687 :: SBool = s15 /= s5686-  s5688 :: SWord8 = s5674 >>> 1-  s5689 :: SWord8 = s20 | s5688-  s5690 :: SWord8 = s22 & s5688-  s5691 :: SWord8 = if s5687 then s5689 else s5690-  s5692 :: SWord8 = if s25 then s5567 else s3859-  s5693 :: SWord8 = if s166 then s5584 else s5692-  s5694 :: SWord8 = if s25 then s5589 else s5693-  s5695 :: SWord8 = if s166 then s5605 else s5694-  s5696 :: SWord8 = if s25 then s5610 else s5695-  s5697 :: SWord8 = if s166 then s5626 else s5696-  s5698 :: SWord8 = if s25 then s5631 else s5697-  s5699 :: SWord8 = if s166 then s5647 else s5698-  s5700 :: SWord8 = if s25 then s5652 else s5699-  s5701 :: SWord8 = if s166 then s5668 else s5700-  s5702 :: SWord8 = if s25 then s5673 else s5701-  s5703 :: SWord8 = if s166 then s5691 else s5702-  s5704 :: SWord8 = s5681 + s5703-  s5705 :: SBool = s5704 < s5703-  s5706 :: SBool = s5704 < s5681-  s5707 :: SBool = s5705 | s5706-  s5708 :: SWord8 = s5704 >>> 1-  s5709 :: SWord8 = s20 | s5708-  s5710 :: SWord8 = s22 & s5708-  s5711 :: SWord8 = if s5707 then s5709 else s5710-  s5712 :: SWord8 = if s5677 then s5685 else s5711-  s5713 :: SWord8 = s5660 + s5701-  s5714 :: SWord1 = choose [0:0] s5713-  s5715 :: SBool = s15 /= s5714-  s5716 :: SWord8 = if s5715 then s5671 else s5672-  s5717 :: SWord8 = if s18 then s5716 else s5668-  s5718 :: SWord1 = choose [0:0] s5717-  s5719 :: SBool = s15 /= s5718-  s5720 :: SBool = s_2 == s5719-  s5721 :: SBool = s5713 < s5701-  s5722 :: SBool = s5713 < s5660-  s5723 :: SBool = s5721 | s5722-  s5724 :: SWord8 = s5713 >>> 1-  s5725 :: SWord8 = s20 | s5724-  s5726 :: SWord8 = s22 & s5724-  s5727 :: SWord8 = if s5723 then s5725 else s5726-  s5728 :: SWord8 = s5727 >>> 1-  s5729 :: SWord8 = s20 | s5728-  s5730 :: SWord8 = s22 & s5728-  s5731 :: SWord8 = if s5719 then s5729 else s5730-  s5732 :: SWord8 = s5717 >>> 1-  s5733 :: SWord8 = s20 | s5732-  s5734 :: SWord8 = s22 & s5732-  s5735 :: SWord8 = if s5687 then s5733 else s5734-  s5736 :: SWord8 = if s25 then s5716 else s5701-  s5737 :: SWord8 = if s166 then s5735 else s5736-  s5738 :: SWord8 = s5727 + s5737-  s5739 :: SBool = s5738 < s5737-  s5740 :: SBool = s5738 < s5727-  s5741 :: SBool = s5739 | s5740-  s5742 :: SWord8 = s5738 >>> 1-  s5743 :: SWord8 = s20 | s5742-  s5744 :: SWord8 = s22 & s5742-  s5745 :: SWord8 = if s5741 then s5743 else s5744-  s5746 :: SWord8 = if s5720 then s5731 else s5745-  s5747 :: SWord8 = if s5656 then s5712 else s5746-  s5748 :: SWord8 = s5639 + s5699-  s5749 :: SWord1 = choose [0:0] s5748-  s5750 :: SBool = s15 /= s5749-  s5751 :: SWord8 = if s5750 then s5650 else s5651-  s5752 :: SWord8 = if s18 then s5751 else s5647-  s5753 :: SWord1 = choose [0:0] s5752-  s5754 :: SBool = s15 /= s5753-  s5755 :: SBool = s_2 == s5754-  s5756 :: SBool = s5748 < s5699-  s5757 :: SBool = s5748 < s5639-  s5758 :: SBool = s5756 | s5757-  s5759 :: SWord8 = s5748 >>> 1-  s5760 :: SWord8 = s20 | s5759-  s5761 :: SWord8 = s22 & s5759-  s5762 :: SWord8 = if s5758 then s5760 else s5761-  s5763 :: SWord1 = choose [0:0] s5762-  s5764 :: SBool = s15 /= s5763-  s5765 :: SWord8 = s5752 >>> 1-  s5766 :: SWord8 = s20 | s5765-  s5767 :: SWord8 = s22 & s5765-  s5768 :: SWord8 = if s5664 then s5766 else s5767-  s5769 :: SWord8 = if s18 then s5768 else s5751-  s5770 :: SWord8 = s5769 >>> 1-  s5771 :: SWord8 = s20 | s5770-  s5772 :: SWord8 = s22 & s5770-  s5773 :: SWord8 = if s5764 then s5771 else s5772-  s5774 :: SWord8 = if s18 then s5773 else s5768-  s5775 :: SWord1 = choose [0:0] s5774-  s5776 :: SBool = s15 /= s5775-  s5777 :: SBool = s_2 == s5776-  s5778 :: SWord8 = s5762 >>> 1-  s5779 :: SWord8 = s20 | s5778-  s5780 :: SWord8 = s22 & s5778-  s5781 :: SWord8 = if s5754 then s5779 else s5780-  s5782 :: SWord8 = s5781 >>> 1-  s5783 :: SWord8 = s20 | s5782-  s5784 :: SWord8 = s22 & s5782-  s5785 :: SWord8 = if s5776 then s5783 else s5784-  s5786 :: SWord1 = choose [0:0] s5769-  s5787 :: SBool = s15 /= s5786-  s5788 :: SWord8 = s5774 >>> 1-  s5789 :: SWord8 = s20 | s5788-  s5790 :: SWord8 = s22 & s5788-  s5791 :: SWord8 = if s5787 then s5789 else s5790-  s5792 :: SWord8 = if s25 then s5751 else s5699-  s5793 :: SWord8 = if s166 then s5768 else s5792-  s5794 :: SWord8 = if s25 then s5773 else s5793-  s5795 :: SWord8 = if s166 then s5791 else s5794-  s5796 :: SWord8 = s5781 + s5795-  s5797 :: SBool = s5796 < s5795-  s5798 :: SBool = s5796 < s5781-  s5799 :: SBool = s5797 | s5798-  s5800 :: SWord8 = s5796 >>> 1-  s5801 :: SWord8 = s20 | s5800-  s5802 :: SWord8 = s22 & s5800-  s5803 :: SWord8 = if s5799 then s5801 else s5802-  s5804 :: SWord8 = if s5777 then s5785 else s5803-  s5805 :: SWord8 = s5762 + s5793-  s5806 :: SWord1 = choose [0:0] s5805-  s5807 :: SBool = s15 /= s5806-  s5808 :: SWord8 = if s5807 then s5771 else s5772-  s5809 :: SWord8 = if s18 then s5808 else s5768-  s5810 :: SWord1 = choose [0:0] s5809-  s5811 :: SBool = s15 /= s5810-  s5812 :: SBool = s_2 == s5811-  s5813 :: SBool = s5805 < s5793-  s5814 :: SBool = s5805 < s5762-  s5815 :: SBool = s5813 | s5814-  s5816 :: SWord8 = s5805 >>> 1-  s5817 :: SWord8 = s20 | s5816-  s5818 :: SWord8 = s22 & s5816-  s5819 :: SWord8 = if s5815 then s5817 else s5818-  s5820 :: SWord8 = s5819 >>> 1-  s5821 :: SWord8 = s20 | s5820-  s5822 :: SWord8 = s22 & s5820-  s5823 :: SWord8 = if s5811 then s5821 else s5822-  s5824 :: SWord8 = s5809 >>> 1-  s5825 :: SWord8 = s20 | s5824-  s5826 :: SWord8 = s22 & s5824-  s5827 :: SWord8 = if s5787 then s5825 else s5826-  s5828 :: SWord8 = if s25 then s5808 else s5793-  s5829 :: SWord8 = if s166 then s5827 else s5828-  s5830 :: SWord8 = s5819 + s5829-  s5831 :: SBool = s5830 < s5829-  s5832 :: SBool = s5830 < s5819-  s5833 :: SBool = s5831 | s5832-  s5834 :: SWord8 = s5830 >>> 1-  s5835 :: SWord8 = s20 | s5834-  s5836 :: SWord8 = s22 & s5834-  s5837 :: SWord8 = if s5833 then s5835 else s5836-  s5838 :: SWord8 = if s5812 then s5823 else s5837-  s5839 :: SWord8 = if s5755 then s5804 else s5838-  s5840 :: SWord8 = if s5635 then s5747 else s5839-  s5841 :: SWord8 = s5618 + s5697-  s5842 :: SWord1 = choose [0:0] s5841-  s5843 :: SBool = s15 /= s5842-  s5844 :: SWord8 = if s5843 then s5629 else s5630-  s5845 :: SWord8 = if s18 then s5844 else s5626-  s5846 :: SWord1 = choose [0:0] s5845-  s5847 :: SBool = s15 /= s5846-  s5848 :: SBool = s_2 == s5847-  s5849 :: SBool = s5841 < s5697-  s5850 :: SBool = s5841 < s5618-  s5851 :: SBool = s5849 | s5850-  s5852 :: SWord8 = s5841 >>> 1-  s5853 :: SWord8 = s20 | s5852-  s5854 :: SWord8 = s22 & s5852-  s5855 :: SWord8 = if s5851 then s5853 else s5854-  s5856 :: SWord1 = choose [0:0] s5855-  s5857 :: SBool = s15 /= s5856-  s5858 :: SWord8 = s5845 >>> 1-  s5859 :: SWord8 = s20 | s5858-  s5860 :: SWord8 = s22 & s5858-  s5861 :: SWord8 = if s5643 then s5859 else s5860-  s5862 :: SWord8 = if s18 then s5861 else s5844-  s5863 :: SWord8 = s5862 >>> 1-  s5864 :: SWord8 = s20 | s5863-  s5865 :: SWord8 = s22 & s5863-  s5866 :: SWord8 = if s5857 then s5864 else s5865-  s5867 :: SWord8 = if s18 then s5866 else s5861-  s5868 :: SWord1 = choose [0:0] s5867-  s5869 :: SBool = s15 /= s5868-  s5870 :: SBool = s_2 == s5869-  s5871 :: SWord8 = s5855 >>> 1-  s5872 :: SWord8 = s20 | s5871-  s5873 :: SWord8 = s22 & s5871-  s5874 :: SWord8 = if s5847 then s5872 else s5873-  s5875 :: SWord1 = choose [0:0] s5874-  s5876 :: SBool = s15 /= s5875-  s5877 :: SWord1 = choose [0:0] s5862-  s5878 :: SBool = s15 /= s5877-  s5879 :: SWord8 = s5867 >>> 1-  s5880 :: SWord8 = s20 | s5879-  s5881 :: SWord8 = s22 & s5879-  s5882 :: SWord8 = if s5878 then s5880 else s5881-  s5883 :: SWord8 = if s18 then s5882 else s5866-  s5884 :: SWord8 = s5883 >>> 1-  s5885 :: SWord8 = s20 | s5884-  s5886 :: SWord8 = s22 & s5884-  s5887 :: SWord8 = if s5876 then s5885 else s5886-  s5888 :: SWord8 = if s18 then s5887 else s5882-  s5889 :: SWord1 = choose [0:0] s5888-  s5890 :: SBool = s15 /= s5889-  s5891 :: SBool = s_2 == s5890-  s5892 :: SWord8 = s5874 >>> 1-  s5893 :: SWord8 = s20 | s5892-  s5894 :: SWord8 = s22 & s5892-  s5895 :: SWord8 = if s5869 then s5893 else s5894-  s5896 :: SWord8 = s5895 >>> 1-  s5897 :: SWord8 = s20 | s5896-  s5898 :: SWord8 = s22 & s5896-  s5899 :: SWord8 = if s5890 then s5897 else s5898-  s5900 :: SWord1 = choose [0:0] s5883-  s5901 :: SBool = s15 /= s5900-  s5902 :: SWord8 = s5888 >>> 1-  s5903 :: SWord8 = s20 | s5902-  s5904 :: SWord8 = s22 & s5902-  s5905 :: SWord8 = if s5901 then s5903 else s5904-  s5906 :: SWord8 = if s25 then s5844 else s5697-  s5907 :: SWord8 = if s166 then s5861 else s5906-  s5908 :: SWord8 = if s25 then s5866 else s5907-  s5909 :: SWord8 = if s166 then s5882 else s5908-  s5910 :: SWord8 = if s25 then s5887 else s5909-  s5911 :: SWord8 = if s166 then s5905 else s5910-  s5912 :: SWord8 = s5895 + s5911-  s5913 :: SBool = s5912 < s5911-  s5914 :: SBool = s5912 < s5895-  s5915 :: SBool = s5913 | s5914-  s5916 :: SWord8 = s5912 >>> 1-  s5917 :: SWord8 = s20 | s5916-  s5918 :: SWord8 = s22 & s5916-  s5919 :: SWord8 = if s5915 then s5917 else s5918-  s5920 :: SWord8 = if s5891 then s5899 else s5919-  s5921 :: SWord8 = s5874 + s5909-  s5922 :: SWord1 = choose [0:0] s5921-  s5923 :: SBool = s15 /= s5922-  s5924 :: SWord8 = if s5923 then s5885 else s5886-  s5925 :: SWord8 = if s18 then s5924 else s5882-  s5926 :: SWord1 = choose [0:0] s5925-  s5927 :: SBool = s15 /= s5926-  s5928 :: SBool = s_2 == s5927-  s5929 :: SBool = s5921 < s5909-  s5930 :: SBool = s5921 < s5874-  s5931 :: SBool = s5929 | s5930-  s5932 :: SWord8 = s5921 >>> 1-  s5933 :: SWord8 = s20 | s5932-  s5934 :: SWord8 = s22 & s5932-  s5935 :: SWord8 = if s5931 then s5933 else s5934-  s5936 :: SWord8 = s5935 >>> 1-  s5937 :: SWord8 = s20 | s5936-  s5938 :: SWord8 = s22 & s5936-  s5939 :: SWord8 = if s5927 then s5937 else s5938-  s5940 :: SWord8 = s5925 >>> 1-  s5941 :: SWord8 = s20 | s5940-  s5942 :: SWord8 = s22 & s5940-  s5943 :: SWord8 = if s5901 then s5941 else s5942-  s5944 :: SWord8 = if s25 then s5924 else s5909-  s5945 :: SWord8 = if s166 then s5943 else s5944-  s5946 :: SWord8 = s5935 + s5945-  s5947 :: SBool = s5946 < s5945-  s5948 :: SBool = s5946 < s5935-  s5949 :: SBool = s5947 | s5948-  s5950 :: SWord8 = s5946 >>> 1-  s5951 :: SWord8 = s20 | s5950-  s5952 :: SWord8 = s22 & s5950-  s5953 :: SWord8 = if s5949 then s5951 else s5952-  s5954 :: SWord8 = if s5928 then s5939 else s5953-  s5955 :: SWord8 = if s5870 then s5920 else s5954-  s5956 :: SWord8 = s5855 + s5907-  s5957 :: SWord1 = choose [0:0] s5956-  s5958 :: SBool = s15 /= s5957-  s5959 :: SWord8 = if s5958 then s5864 else s5865-  s5960 :: SWord8 = if s18 then s5959 else s5861-  s5961 :: SWord1 = choose [0:0] s5960-  s5962 :: SBool = s15 /= s5961-  s5963 :: SBool = s_2 == s5962-  s5964 :: SBool = s5956 < s5907-  s5965 :: SBool = s5956 < s5855-  s5966 :: SBool = s5964 | s5965-  s5967 :: SWord8 = s5956 >>> 1-  s5968 :: SWord8 = s20 | s5967-  s5969 :: SWord8 = s22 & s5967-  s5970 :: SWord8 = if s5966 then s5968 else s5969-  s5971 :: SWord1 = choose [0:0] s5970-  s5972 :: SBool = s15 /= s5971-  s5973 :: SWord8 = s5960 >>> 1-  s5974 :: SWord8 = s20 | s5973-  s5975 :: SWord8 = s22 & s5973-  s5976 :: SWord8 = if s5878 then s5974 else s5975-  s5977 :: SWord8 = if s18 then s5976 else s5959-  s5978 :: SWord8 = s5977 >>> 1-  s5979 :: SWord8 = s20 | s5978-  s5980 :: SWord8 = s22 & s5978-  s5981 :: SWord8 = if s5972 then s5979 else s5980-  s5982 :: SWord8 = if s18 then s5981 else s5976-  s5983 :: SWord1 = choose [0:0] s5982-  s5984 :: SBool = s15 /= s5983-  s5985 :: SBool = s_2 == s5984-  s5986 :: SWord8 = s5970 >>> 1-  s5987 :: SWord8 = s20 | s5986-  s5988 :: SWord8 = s22 & s5986-  s5989 :: SWord8 = if s5962 then s5987 else s5988-  s5990 :: SWord8 = s5989 >>> 1-  s5991 :: SWord8 = s20 | s5990-  s5992 :: SWord8 = s22 & s5990-  s5993 :: SWord8 = if s5984 then s5991 else s5992-  s5994 :: SWord1 = choose [0:0] s5977-  s5995 :: SBool = s15 /= s5994-  s5996 :: SWord8 = s5982 >>> 1-  s5997 :: SWord8 = s20 | s5996-  s5998 :: SWord8 = s22 & s5996-  s5999 :: SWord8 = if s5995 then s5997 else s5998-  s6000 :: SWord8 = if s25 then s5959 else s5907-  s6001 :: SWord8 = if s166 then s5976 else s6000-  s6002 :: SWord8 = if s25 then s5981 else s6001-  s6003 :: SWord8 = if s166 then s5999 else s6002-  s6004 :: SWord8 = s5989 + s6003-  s6005 :: SBool = s6004 < s6003-  s6006 :: SBool = s6004 < s5989-  s6007 :: SBool = s6005 | s6006-  s6008 :: SWord8 = s6004 >>> 1-  s6009 :: SWord8 = s20 | s6008-  s6010 :: SWord8 = s22 & s6008-  s6011 :: SWord8 = if s6007 then s6009 else s6010-  s6012 :: SWord8 = if s5985 then s5993 else s6011-  s6013 :: SWord8 = s5970 + s6001-  s6014 :: SWord1 = choose [0:0] s6013-  s6015 :: SBool = s15 /= s6014-  s6016 :: SWord8 = if s6015 then s5979 else s5980-  s6017 :: SWord8 = if s18 then s6016 else s5976-  s6018 :: SWord1 = choose [0:0] s6017-  s6019 :: SBool = s15 /= s6018-  s6020 :: SBool = s_2 == s6019-  s6021 :: SBool = s6013 < s6001-  s6022 :: SBool = s6013 < s5970-  s6023 :: SBool = s6021 | s6022-  s6024 :: SWord8 = s6013 >>> 1-  s6025 :: SWord8 = s20 | s6024-  s6026 :: SWord8 = s22 & s6024-  s6027 :: SWord8 = if s6023 then s6025 else s6026-  s6028 :: SWord8 = s6027 >>> 1-  s6029 :: SWord8 = s20 | s6028-  s6030 :: SWord8 = s22 & s6028-  s6031 :: SWord8 = if s6019 then s6029 else s6030-  s6032 :: SWord8 = s6017 >>> 1-  s6033 :: SWord8 = s20 | s6032-  s6034 :: SWord8 = s22 & s6032-  s6035 :: SWord8 = if s5995 then s6033 else s6034-  s6036 :: SWord8 = if s25 then s6016 else s6001-  s6037 :: SWord8 = if s166 then s6035 else s6036-  s6038 :: SWord8 = s6027 + s6037-  s6039 :: SBool = s6038 < s6037-  s6040 :: SBool = s6038 < s6027-  s6041 :: SBool = s6039 | s6040-  s6042 :: SWord8 = s6038 >>> 1-  s6043 :: SWord8 = s20 | s6042-  s6044 :: SWord8 = s22 & s6042-  s6045 :: SWord8 = if s6041 then s6043 else s6044-  s6046 :: SWord8 = if s6020 then s6031 else s6045-  s6047 :: SWord8 = if s5963 then s6012 else s6046-  s6048 :: SWord8 = if s5848 then s5955 else s6047-  s6049 :: SWord8 = if s5614 then s5840 else s6048-  s6050 :: SWord8 = s5597 + s5695-  s6051 :: SWord1 = choose [0:0] s6050-  s6052 :: SBool = s15 /= s6051-  s6053 :: SWord8 = if s6052 then s5608 else s5609-  s6054 :: SWord8 = if s18 then s6053 else s5605-  s6055 :: SWord1 = choose [0:0] s6054-  s6056 :: SBool = s15 /= s6055-  s6057 :: SBool = s_2 == s6056-  s6058 :: SBool = s6050 < s5695-  s6059 :: SBool = s6050 < s5597-  s6060 :: SBool = s6058 | s6059-  s6061 :: SWord8 = s6050 >>> 1-  s6062 :: SWord8 = s20 | s6061-  s6063 :: SWord8 = s22 & s6061-  s6064 :: SWord8 = if s6060 then s6062 else s6063-  s6065 :: SWord1 = choose [0:0] s6064-  s6066 :: SBool = s15 /= s6065-  s6067 :: SWord8 = s6054 >>> 1-  s6068 :: SWord8 = s20 | s6067-  s6069 :: SWord8 = s22 & s6067-  s6070 :: SWord8 = if s5622 then s6068 else s6069-  s6071 :: SWord8 = if s18 then s6070 else s6053-  s6072 :: SWord8 = s6071 >>> 1-  s6073 :: SWord8 = s20 | s6072-  s6074 :: SWord8 = s22 & s6072-  s6075 :: SWord8 = if s6066 then s6073 else s6074-  s6076 :: SWord8 = if s18 then s6075 else s6070-  s6077 :: SWord1 = choose [0:0] s6076-  s6078 :: SBool = s15 /= s6077-  s6079 :: SBool = s_2 == s6078-  s6080 :: SWord8 = s6064 >>> 1-  s6081 :: SWord8 = s20 | s6080-  s6082 :: SWord8 = s22 & s6080-  s6083 :: SWord8 = if s6056 then s6081 else s6082-  s6084 :: SWord1 = choose [0:0] s6083-  s6085 :: SBool = s15 /= s6084-  s6086 :: SWord1 = choose [0:0] s6071-  s6087 :: SBool = s15 /= s6086-  s6088 :: SWord8 = s6076 >>> 1-  s6089 :: SWord8 = s20 | s6088-  s6090 :: SWord8 = s22 & s6088-  s6091 :: SWord8 = if s6087 then s6089 else s6090-  s6092 :: SWord8 = if s18 then s6091 else s6075-  s6093 :: SWord8 = s6092 >>> 1-  s6094 :: SWord8 = s20 | s6093-  s6095 :: SWord8 = s22 & s6093-  s6096 :: SWord8 = if s6085 then s6094 else s6095-  s6097 :: SWord8 = if s18 then s6096 else s6091-  s6098 :: SWord1 = choose [0:0] s6097-  s6099 :: SBool = s15 /= s6098-  s6100 :: SBool = s_2 == s6099-  s6101 :: SWord8 = s6083 >>> 1-  s6102 :: SWord8 = s20 | s6101-  s6103 :: SWord8 = s22 & s6101-  s6104 :: SWord8 = if s6078 then s6102 else s6103-  s6105 :: SWord1 = choose [0:0] s6104-  s6106 :: SBool = s15 /= s6105-  s6107 :: SWord1 = choose [0:0] s6092-  s6108 :: SBool = s15 /= s6107-  s6109 :: SWord8 = s6097 >>> 1-  s6110 :: SWord8 = s20 | s6109-  s6111 :: SWord8 = s22 & s6109-  s6112 :: SWord8 = if s6108 then s6110 else s6111-  s6113 :: SWord8 = if s18 then s6112 else s6096-  s6114 :: SWord8 = s6113 >>> 1-  s6115 :: SWord8 = s20 | s6114-  s6116 :: SWord8 = s22 & s6114-  s6117 :: SWord8 = if s6106 then s6115 else s6116-  s6118 :: SWord8 = if s18 then s6117 else s6112-  s6119 :: SWord1 = choose [0:0] s6118-  s6120 :: SBool = s15 /= s6119-  s6121 :: SBool = s_2 == s6120-  s6122 :: SWord8 = s6104 >>> 1-  s6123 :: SWord8 = s20 | s6122-  s6124 :: SWord8 = s22 & s6122-  s6125 :: SWord8 = if s6099 then s6123 else s6124-  s6126 :: SWord8 = s6125 >>> 1-  s6127 :: SWord8 = s20 | s6126-  s6128 :: SWord8 = s22 & s6126-  s6129 :: SWord8 = if s6120 then s6127 else s6128-  s6130 :: SWord1 = choose [0:0] s6113-  s6131 :: SBool = s15 /= s6130-  s6132 :: SWord8 = s6118 >>> 1-  s6133 :: SWord8 = s20 | s6132-  s6134 :: SWord8 = s22 & s6132-  s6135 :: SWord8 = if s6131 then s6133 else s6134-  s6136 :: SWord8 = if s25 then s6053 else s5695-  s6137 :: SWord8 = if s166 then s6070 else s6136-  s6138 :: SWord8 = if s25 then s6075 else s6137-  s6139 :: SWord8 = if s166 then s6091 else s6138-  s6140 :: SWord8 = if s25 then s6096 else s6139-  s6141 :: SWord8 = if s166 then s6112 else s6140-  s6142 :: SWord8 = if s25 then s6117 else s6141-  s6143 :: SWord8 = if s166 then s6135 else s6142-  s6144 :: SWord8 = s6125 + s6143-  s6145 :: SBool = s6144 < s6143-  s6146 :: SBool = s6144 < s6125-  s6147 :: SBool = s6145 | s6146-  s6148 :: SWord8 = s6144 >>> 1-  s6149 :: SWord8 = s20 | s6148-  s6150 :: SWord8 = s22 & s6148-  s6151 :: SWord8 = if s6147 then s6149 else s6150-  s6152 :: SWord8 = if s6121 then s6129 else s6151-  s6153 :: SWord8 = s6104 + s6141-  s6154 :: SWord1 = choose [0:0] s6153-  s6155 :: SBool = s15 /= s6154-  s6156 :: SWord8 = if s6155 then s6115 else s6116-  s6157 :: SWord8 = if s18 then s6156 else s6112-  s6158 :: SWord1 = choose [0:0] s6157-  s6159 :: SBool = s15 /= s6158-  s6160 :: SBool = s_2 == s6159-  s6161 :: SBool = s6153 < s6141-  s6162 :: SBool = s6153 < s6104-  s6163 :: SBool = s6161 | s6162-  s6164 :: SWord8 = s6153 >>> 1-  s6165 :: SWord8 = s20 | s6164-  s6166 :: SWord8 = s22 & s6164-  s6167 :: SWord8 = if s6163 then s6165 else s6166-  s6168 :: SWord8 = s6167 >>> 1-  s6169 :: SWord8 = s20 | s6168-  s6170 :: SWord8 = s22 & s6168-  s6171 :: SWord8 = if s6159 then s6169 else s6170-  s6172 :: SWord8 = s6157 >>> 1-  s6173 :: SWord8 = s20 | s6172-  s6174 :: SWord8 = s22 & s6172-  s6175 :: SWord8 = if s6131 then s6173 else s6174-  s6176 :: SWord8 = if s25 then s6156 else s6141-  s6177 :: SWord8 = if s166 then s6175 else s6176-  s6178 :: SWord8 = s6167 + s6177-  s6179 :: SBool = s6178 < s6177-  s6180 :: SBool = s6178 < s6167-  s6181 :: SBool = s6179 | s6180-  s6182 :: SWord8 = s6178 >>> 1-  s6183 :: SWord8 = s20 | s6182-  s6184 :: SWord8 = s22 & s6182-  s6185 :: SWord8 = if s6181 then s6183 else s6184-  s6186 :: SWord8 = if s6160 then s6171 else s6185-  s6187 :: SWord8 = if s6100 then s6152 else s6186-  s6188 :: SWord8 = s6083 + s6139-  s6189 :: SWord1 = choose [0:0] s6188-  s6190 :: SBool = s15 /= s6189-  s6191 :: SWord8 = if s6190 then s6094 else s6095-  s6192 :: SWord8 = if s18 then s6191 else s6091-  s6193 :: SWord1 = choose [0:0] s6192-  s6194 :: SBool = s15 /= s6193-  s6195 :: SBool = s_2 == s6194-  s6196 :: SBool = s6188 < s6139-  s6197 :: SBool = s6188 < s6083-  s6198 :: SBool = s6196 | s6197-  s6199 :: SWord8 = s6188 >>> 1-  s6200 :: SWord8 = s20 | s6199-  s6201 :: SWord8 = s22 & s6199-  s6202 :: SWord8 = if s6198 then s6200 else s6201-  s6203 :: SWord1 = choose [0:0] s6202-  s6204 :: SBool = s15 /= s6203-  s6205 :: SWord8 = s6192 >>> 1-  s6206 :: SWord8 = s20 | s6205-  s6207 :: SWord8 = s22 & s6205-  s6208 :: SWord8 = if s6108 then s6206 else s6207-  s6209 :: SWord8 = if s18 then s6208 else s6191-  s6210 :: SWord8 = s6209 >>> 1-  s6211 :: SWord8 = s20 | s6210-  s6212 :: SWord8 = s22 & s6210-  s6213 :: SWord8 = if s6204 then s6211 else s6212-  s6214 :: SWord8 = if s18 then s6213 else s6208-  s6215 :: SWord1 = choose [0:0] s6214-  s6216 :: SBool = s15 /= s6215-  s6217 :: SBool = s_2 == s6216-  s6218 :: SWord8 = s6202 >>> 1-  s6219 :: SWord8 = s20 | s6218-  s6220 :: SWord8 = s22 & s6218-  s6221 :: SWord8 = if s6194 then s6219 else s6220-  s6222 :: SWord8 = s6221 >>> 1-  s6223 :: SWord8 = s20 | s6222-  s6224 :: SWord8 = s22 & s6222-  s6225 :: SWord8 = if s6216 then s6223 else s6224-  s6226 :: SWord1 = choose [0:0] s6209-  s6227 :: SBool = s15 /= s6226-  s6228 :: SWord8 = s6214 >>> 1-  s6229 :: SWord8 = s20 | s6228-  s6230 :: SWord8 = s22 & s6228-  s6231 :: SWord8 = if s6227 then s6229 else s6230-  s6232 :: SWord8 = if s25 then s6191 else s6139-  s6233 :: SWord8 = if s166 then s6208 else s6232-  s6234 :: SWord8 = if s25 then s6213 else s6233-  s6235 :: SWord8 = if s166 then s6231 else s6234-  s6236 :: SWord8 = s6221 + s6235-  s6237 :: SBool = s6236 < s6235-  s6238 :: SBool = s6236 < s6221-  s6239 :: SBool = s6237 | s6238-  s6240 :: SWord8 = s6236 >>> 1-  s6241 :: SWord8 = s20 | s6240-  s6242 :: SWord8 = s22 & s6240-  s6243 :: SWord8 = if s6239 then s6241 else s6242-  s6244 :: SWord8 = if s6217 then s6225 else s6243-  s6245 :: SWord8 = s6202 + s6233-  s6246 :: SWord1 = choose [0:0] s6245-  s6247 :: SBool = s15 /= s6246-  s6248 :: SWord8 = if s6247 then s6211 else s6212-  s6249 :: SWord8 = if s18 then s6248 else s6208-  s6250 :: SWord1 = choose [0:0] s6249-  s6251 :: SBool = s15 /= s6250-  s6252 :: SBool = s_2 == s6251-  s6253 :: SBool = s6245 < s6233-  s6254 :: SBool = s6245 < s6202-  s6255 :: SBool = s6253 | s6254-  s6256 :: SWord8 = s6245 >>> 1-  s6257 :: SWord8 = s20 | s6256-  s6258 :: SWord8 = s22 & s6256-  s6259 :: SWord8 = if s6255 then s6257 else s6258-  s6260 :: SWord8 = s6259 >>> 1-  s6261 :: SWord8 = s20 | s6260-  s6262 :: SWord8 = s22 & s6260-  s6263 :: SWord8 = if s6251 then s6261 else s6262-  s6264 :: SWord8 = s6249 >>> 1-  s6265 :: SWord8 = s20 | s6264-  s6266 :: SWord8 = s22 & s6264-  s6267 :: SWord8 = if s6227 then s6265 else s6266-  s6268 :: SWord8 = if s25 then s6248 else s6233-  s6269 :: SWord8 = if s166 then s6267 else s6268-  s6270 :: SWord8 = s6259 + s6269-  s6271 :: SBool = s6270 < s6269-  s6272 :: SBool = s6270 < s6259-  s6273 :: SBool = s6271 | s6272-  s6274 :: SWord8 = s6270 >>> 1-  s6275 :: SWord8 = s20 | s6274-  s6276 :: SWord8 = s22 & s6274-  s6277 :: SWord8 = if s6273 then s6275 else s6276-  s6278 :: SWord8 = if s6252 then s6263 else s6277-  s6279 :: SWord8 = if s6195 then s6244 else s6278-  s6280 :: SWord8 = if s6079 then s6187 else s6279-  s6281 :: SWord8 = s6064 + s6137-  s6282 :: SWord1 = choose [0:0] s6281-  s6283 :: SBool = s15 /= s6282-  s6284 :: SWord8 = if s6283 then s6073 else s6074-  s6285 :: SWord8 = if s18 then s6284 else s6070-  s6286 :: SWord1 = choose [0:0] s6285-  s6287 :: SBool = s15 /= s6286-  s6288 :: SBool = s_2 == s6287-  s6289 :: SBool = s6281 < s6137-  s6290 :: SBool = s6281 < s6064-  s6291 :: SBool = s6289 | s6290-  s6292 :: SWord8 = s6281 >>> 1-  s6293 :: SWord8 = s20 | s6292-  s6294 :: SWord8 = s22 & s6292-  s6295 :: SWord8 = if s6291 then s6293 else s6294-  s6296 :: SWord1 = choose [0:0] s6295-  s6297 :: SBool = s15 /= s6296-  s6298 :: SWord8 = s6285 >>> 1-  s6299 :: SWord8 = s20 | s6298-  s6300 :: SWord8 = s22 & s6298-  s6301 :: SWord8 = if s6087 then s6299 else s6300-  s6302 :: SWord8 = if s18 then s6301 else s6284-  s6303 :: SWord8 = s6302 >>> 1-  s6304 :: SWord8 = s20 | s6303-  s6305 :: SWord8 = s22 & s6303-  s6306 :: SWord8 = if s6297 then s6304 else s6305-  s6307 :: SWord8 = if s18 then s6306 else s6301-  s6308 :: SWord1 = choose [0:0] s6307-  s6309 :: SBool = s15 /= s6308-  s6310 :: SBool = s_2 == s6309-  s6311 :: SWord8 = s6295 >>> 1-  s6312 :: SWord8 = s20 | s6311-  s6313 :: SWord8 = s22 & s6311-  s6314 :: SWord8 = if s6287 then s6312 else s6313-  s6315 :: SWord1 = choose [0:0] s6314-  s6316 :: SBool = s15 /= s6315-  s6317 :: SWord1 = choose [0:0] s6302-  s6318 :: SBool = s15 /= s6317-  s6319 :: SWord8 = s6307 >>> 1-  s6320 :: SWord8 = s20 | s6319-  s6321 :: SWord8 = s22 & s6319-  s6322 :: SWord8 = if s6318 then s6320 else s6321-  s6323 :: SWord8 = if s18 then s6322 else s6306-  s6324 :: SWord8 = s6323 >>> 1-  s6325 :: SWord8 = s20 | s6324-  s6326 :: SWord8 = s22 & s6324-  s6327 :: SWord8 = if s6316 then s6325 else s6326-  s6328 :: SWord8 = if s18 then s6327 else s6322-  s6329 :: SWord1 = choose [0:0] s6328-  s6330 :: SBool = s15 /= s6329-  s6331 :: SBool = s_2 == s6330-  s6332 :: SWord8 = s6314 >>> 1-  s6333 :: SWord8 = s20 | s6332-  s6334 :: SWord8 = s22 & s6332-  s6335 :: SWord8 = if s6309 then s6333 else s6334-  s6336 :: SWord8 = s6335 >>> 1-  s6337 :: SWord8 = s20 | s6336-  s6338 :: SWord8 = s22 & s6336-  s6339 :: SWord8 = if s6330 then s6337 else s6338-  s6340 :: SWord1 = choose [0:0] s6323-  s6341 :: SBool = s15 /= s6340-  s6342 :: SWord8 = s6328 >>> 1-  s6343 :: SWord8 = s20 | s6342-  s6344 :: SWord8 = s22 & s6342-  s6345 :: SWord8 = if s6341 then s6343 else s6344-  s6346 :: SWord8 = if s25 then s6284 else s6137-  s6347 :: SWord8 = if s166 then s6301 else s6346-  s6348 :: SWord8 = if s25 then s6306 else s6347-  s6349 :: SWord8 = if s166 then s6322 else s6348-  s6350 :: SWord8 = if s25 then s6327 else s6349-  s6351 :: SWord8 = if s166 then s6345 else s6350-  s6352 :: SWord8 = s6335 + s6351-  s6353 :: SBool = s6352 < s6351-  s6354 :: SBool = s6352 < s6335-  s6355 :: SBool = s6353 | s6354-  s6356 :: SWord8 = s6352 >>> 1-  s6357 :: SWord8 = s20 | s6356-  s6358 :: SWord8 = s22 & s6356-  s6359 :: SWord8 = if s6355 then s6357 else s6358-  s6360 :: SWord8 = if s6331 then s6339 else s6359-  s6361 :: SWord8 = s6314 + s6349-  s6362 :: SWord1 = choose [0:0] s6361-  s6363 :: SBool = s15 /= s6362-  s6364 :: SWord8 = if s6363 then s6325 else s6326-  s6365 :: SWord8 = if s18 then s6364 else s6322-  s6366 :: SWord1 = choose [0:0] s6365-  s6367 :: SBool = s15 /= s6366-  s6368 :: SBool = s_2 == s6367-  s6369 :: SBool = s6361 < s6349-  s6370 :: SBool = s6361 < s6314-  s6371 :: SBool = s6369 | s6370-  s6372 :: SWord8 = s6361 >>> 1-  s6373 :: SWord8 = s20 | s6372-  s6374 :: SWord8 = s22 & s6372-  s6375 :: SWord8 = if s6371 then s6373 else s6374-  s6376 :: SWord8 = s6375 >>> 1-  s6377 :: SWord8 = s20 | s6376-  s6378 :: SWord8 = s22 & s6376-  s6379 :: SWord8 = if s6367 then s6377 else s6378-  s6380 :: SWord8 = s6365 >>> 1-  s6381 :: SWord8 = s20 | s6380-  s6382 :: SWord8 = s22 & s6380-  s6383 :: SWord8 = if s6341 then s6381 else s6382-  s6384 :: SWord8 = if s25 then s6364 else s6349-  s6385 :: SWord8 = if s166 then s6383 else s6384-  s6386 :: SWord8 = s6375 + s6385-  s6387 :: SBool = s6386 < s6385-  s6388 :: SBool = s6386 < s6375-  s6389 :: SBool = s6387 | s6388-  s6390 :: SWord8 = s6386 >>> 1-  s6391 :: SWord8 = s20 | s6390-  s6392 :: SWord8 = s22 & s6390-  s6393 :: SWord8 = if s6389 then s6391 else s6392-  s6394 :: SWord8 = if s6368 then s6379 else s6393-  s6395 :: SWord8 = if s6310 then s6360 else s6394-  s6396 :: SWord8 = s6295 + s6347-  s6397 :: SWord1 = choose [0:0] s6396-  s6398 :: SBool = s15 /= s6397-  s6399 :: SWord8 = if s6398 then s6304 else s6305-  s6400 :: SWord8 = if s18 then s6399 else s6301-  s6401 :: SWord1 = choose [0:0] s6400-  s6402 :: SBool = s15 /= s6401-  s6403 :: SBool = s_2 == s6402-  s6404 :: SBool = s6396 < s6347-  s6405 :: SBool = s6396 < s6295-  s6406 :: SBool = s6404 | s6405-  s6407 :: SWord8 = s6396 >>> 1-  s6408 :: SWord8 = s20 | s6407-  s6409 :: SWord8 = s22 & s6407-  s6410 :: SWord8 = if s6406 then s6408 else s6409-  s6411 :: SWord1 = choose [0:0] s6410-  s6412 :: SBool = s15 /= s6411-  s6413 :: SWord8 = s6400 >>> 1-  s6414 :: SWord8 = s20 | s6413-  s6415 :: SWord8 = s22 & s6413-  s6416 :: SWord8 = if s6318 then s6414 else s6415-  s6417 :: SWord8 = if s18 then s6416 else s6399-  s6418 :: SWord8 = s6417 >>> 1-  s6419 :: SWord8 = s20 | s6418-  s6420 :: SWord8 = s22 & s6418-  s6421 :: SWord8 = if s6412 then s6419 else s6420-  s6422 :: SWord8 = if s18 then s6421 else s6416-  s6423 :: SWord1 = choose [0:0] s6422-  s6424 :: SBool = s15 /= s6423-  s6425 :: SBool = s_2 == s6424-  s6426 :: SWord8 = s6410 >>> 1-  s6427 :: SWord8 = s20 | s6426-  s6428 :: SWord8 = s22 & s6426-  s6429 :: SWord8 = if s6402 then s6427 else s6428-  s6430 :: SWord8 = s6429 >>> 1-  s6431 :: SWord8 = s20 | s6430-  s6432 :: SWord8 = s22 & s6430-  s6433 :: SWord8 = if s6424 then s6431 else s6432-  s6434 :: SWord1 = choose [0:0] s6417-  s6435 :: SBool = s15 /= s6434-  s6436 :: SWord8 = s6422 >>> 1-  s6437 :: SWord8 = s20 | s6436-  s6438 :: SWord8 = s22 & s6436-  s6439 :: SWord8 = if s6435 then s6437 else s6438-  s6440 :: SWord8 = if s25 then s6399 else s6347-  s6441 :: SWord8 = if s166 then s6416 else s6440-  s6442 :: SWord8 = if s25 then s6421 else s6441-  s6443 :: SWord8 = if s166 then s6439 else s6442-  s6444 :: SWord8 = s6429 + s6443-  s6445 :: SBool = s6444 < s6443-  s6446 :: SBool = s6444 < s6429-  s6447 :: SBool = s6445 | s6446-  s6448 :: SWord8 = s6444 >>> 1-  s6449 :: SWord8 = s20 | s6448-  s6450 :: SWord8 = s22 & s6448-  s6451 :: SWord8 = if s6447 then s6449 else s6450-  s6452 :: SWord8 = if s6425 then s6433 else s6451-  s6453 :: SWord8 = s6410 + s6441-  s6454 :: SWord1 = choose [0:0] s6453-  s6455 :: SBool = s15 /= s6454-  s6456 :: SWord8 = if s6455 then s6419 else s6420-  s6457 :: SWord8 = if s18 then s6456 else s6416-  s6458 :: SWord1 = choose [0:0] s6457-  s6459 :: SBool = s15 /= s6458-  s6460 :: SBool = s_2 == s6459-  s6461 :: SBool = s6453 < s6441-  s6462 :: SBool = s6453 < s6410-  s6463 :: SBool = s6461 | s6462-  s6464 :: SWord8 = s6453 >>> 1-  s6465 :: SWord8 = s20 | s6464-  s6466 :: SWord8 = s22 & s6464-  s6467 :: SWord8 = if s6463 then s6465 else s6466-  s6468 :: SWord8 = s6467 >>> 1-  s6469 :: SWord8 = s20 | s6468-  s6470 :: SWord8 = s22 & s6468-  s6471 :: SWord8 = if s6459 then s6469 else s6470-  s6472 :: SWord8 = s6457 >>> 1-  s6473 :: SWord8 = s20 | s6472-  s6474 :: SWord8 = s22 & s6472-  s6475 :: SWord8 = if s6435 then s6473 else s6474-  s6476 :: SWord8 = if s25 then s6456 else s6441-  s6477 :: SWord8 = if s166 then s6475 else s6476-  s6478 :: SWord8 = s6467 + s6477-  s6479 :: SBool = s6478 < s6477-  s6480 :: SBool = s6478 < s6467-  s6481 :: SBool = s6479 | s6480-  s6482 :: SWord8 = s6478 >>> 1-  s6483 :: SWord8 = s20 | s6482-  s6484 :: SWord8 = s22 & s6482-  s6485 :: SWord8 = if s6481 then s6483 else s6484-  s6486 :: SWord8 = if s6460 then s6471 else s6485-  s6487 :: SWord8 = if s6403 then s6452 else s6486-  s6488 :: SWord8 = if s6288 then s6395 else s6487-  s6489 :: SWord8 = if s6057 then s6280 else s6488-  s6490 :: SWord8 = if s5593 then s6049 else s6489-  s6491 :: SWord8 = s5578 + s5693-  s6492 :: SWord1 = choose [0:0] s6491-  s6493 :: SBool = s15 /= s6492-  s6494 :: SWord8 = if s6493 then s5587 else s5588-  s6495 :: SWord8 = if s18 then s6494 else s5584-  s6496 :: SWord1 = choose [0:0] s6495-  s6497 :: SBool = s15 /= s6496-  s6498 :: SBool = s_2 == s6497-  s6499 :: SBool = s6491 < s5693-  s6500 :: SBool = s6491 < s5578-  s6501 :: SBool = s6499 | s6500-  s6502 :: SWord8 = s6491 >>> 1-  s6503 :: SWord8 = s20 | s6502-  s6504 :: SWord8 = s22 & s6502-  s6505 :: SWord8 = if s6501 then s6503 else s6504-  s6506 :: SWord1 = choose [0:0] s6505-  s6507 :: SBool = s15 /= s6506-  s6508 :: SWord8 = s6495 >>> 1-  s6509 :: SWord8 = s20 | s6508-  s6510 :: SWord8 = s22 & s6508-  s6511 :: SWord8 = if s5601 then s6509 else s6510-  s6512 :: SWord8 = if s18 then s6511 else s6494-  s6513 :: SWord8 = s6512 >>> 1-  s6514 :: SWord8 = s20 | s6513-  s6515 :: SWord8 = s22 & s6513-  s6516 :: SWord8 = if s6507 then s6514 else s6515-  s6517 :: SWord8 = if s18 then s6516 else s6511-  s6518 :: SWord1 = choose [0:0] s6517-  s6519 :: SBool = s15 /= s6518-  s6520 :: SBool = s_2 == s6519-  s6521 :: SWord8 = s6505 >>> 1-  s6522 :: SWord8 = s20 | s6521-  s6523 :: SWord8 = s22 & s6521-  s6524 :: SWord8 = if s6497 then s6522 else s6523-  s6525 :: SWord1 = choose [0:0] s6524-  s6526 :: SBool = s15 /= s6525-  s6527 :: SWord1 = choose [0:0] s6512-  s6528 :: SBool = s15 /= s6527-  s6529 :: SWord8 = s6517 >>> 1-  s6530 :: SWord8 = s20 | s6529-  s6531 :: SWord8 = s22 & s6529-  s6532 :: SWord8 = if s6528 then s6530 else s6531-  s6533 :: SWord8 = if s18 then s6532 else s6516-  s6534 :: SWord8 = s6533 >>> 1-  s6535 :: SWord8 = s20 | s6534-  s6536 :: SWord8 = s22 & s6534-  s6537 :: SWord8 = if s6526 then s6535 else s6536-  s6538 :: SWord8 = if s18 then s6537 else s6532-  s6539 :: SWord1 = choose [0:0] s6538-  s6540 :: SBool = s15 /= s6539-  s6541 :: SBool = s_2 == s6540-  s6542 :: SWord8 = s6524 >>> 1-  s6543 :: SWord8 = s20 | s6542-  s6544 :: SWord8 = s22 & s6542-  s6545 :: SWord8 = if s6519 then s6543 else s6544-  s6546 :: SWord1 = choose [0:0] s6545-  s6547 :: SBool = s15 /= s6546-  s6548 :: SWord1 = choose [0:0] s6533-  s6549 :: SBool = s15 /= s6548-  s6550 :: SWord8 = s6538 >>> 1-  s6551 :: SWord8 = s20 | s6550-  s6552 :: SWord8 = s22 & s6550-  s6553 :: SWord8 = if s6549 then s6551 else s6552-  s6554 :: SWord8 = if s18 then s6553 else s6537-  s6555 :: SWord8 = s6554 >>> 1-  s6556 :: SWord8 = s20 | s6555-  s6557 :: SWord8 = s22 & s6555-  s6558 :: SWord8 = if s6547 then s6556 else s6557-  s6559 :: SWord8 = if s18 then s6558 else s6553-  s6560 :: SWord1 = choose [0:0] s6559-  s6561 :: SBool = s15 /= s6560-  s6562 :: SBool = s_2 == s6561-  s6563 :: SWord8 = s6545 >>> 1-  s6564 :: SWord8 = s20 | s6563-  s6565 :: SWord8 = s22 & s6563-  s6566 :: SWord8 = if s6540 then s6564 else s6565-  s6567 :: SWord1 = choose [0:0] s6566-  s6568 :: SBool = s15 /= s6567-  s6569 :: SWord1 = choose [0:0] s6554-  s6570 :: SBool = s15 /= s6569-  s6571 :: SWord8 = s6559 >>> 1-  s6572 :: SWord8 = s20 | s6571-  s6573 :: SWord8 = s22 & s6571-  s6574 :: SWord8 = if s6570 then s6572 else s6573-  s6575 :: SWord8 = if s18 then s6574 else s6558-  s6576 :: SWord8 = s6575 >>> 1-  s6577 :: SWord8 = s20 | s6576-  s6578 :: SWord8 = s22 & s6576-  s6579 :: SWord8 = if s6568 then s6577 else s6578-  s6580 :: SWord8 = if s18 then s6579 else s6574-  s6581 :: SWord1 = choose [0:0] s6580-  s6582 :: SBool = s15 /= s6581-  s6583 :: SBool = s_2 == s6582-  s6584 :: SWord8 = s6566 >>> 1-  s6585 :: SWord8 = s20 | s6584-  s6586 :: SWord8 = s22 & s6584-  s6587 :: SWord8 = if s6561 then s6585 else s6586-  s6588 :: SWord8 = s6587 >>> 1-  s6589 :: SWord8 = s20 | s6588-  s6590 :: SWord8 = s22 & s6588-  s6591 :: SWord8 = if s6582 then s6589 else s6590-  s6592 :: SWord1 = choose [0:0] s6575-  s6593 :: SBool = s15 /= s6592-  s6594 :: SWord8 = s6580 >>> 1-  s6595 :: SWord8 = s20 | s6594-  s6596 :: SWord8 = s22 & s6594-  s6597 :: SWord8 = if s6593 then s6595 else s6596-  s6598 :: SWord8 = if s25 then s6494 else s5693-  s6599 :: SWord8 = if s166 then s6511 else s6598-  s6600 :: SWord8 = if s25 then s6516 else s6599-  s6601 :: SWord8 = if s166 then s6532 else s6600-  s6602 :: SWord8 = if s25 then s6537 else s6601-  s6603 :: SWord8 = if s166 then s6553 else s6602-  s6604 :: SWord8 = if s25 then s6558 else s6603-  s6605 :: SWord8 = if s166 then s6574 else s6604-  s6606 :: SWord8 = if s25 then s6579 else s6605-  s6607 :: SWord8 = if s166 then s6597 else s6606-  s6608 :: SWord8 = s6587 + s6607-  s6609 :: SBool = s6608 < s6607-  s6610 :: SBool = s6608 < s6587-  s6611 :: SBool = s6609 | s6610-  s6612 :: SWord8 = s6608 >>> 1-  s6613 :: SWord8 = s20 | s6612-  s6614 :: SWord8 = s22 & s6612-  s6615 :: SWord8 = if s6611 then s6613 else s6614-  s6616 :: SWord8 = if s6583 then s6591 else s6615-  s6617 :: SWord8 = s6566 + s6605-  s6618 :: SWord1 = choose [0:0] s6617-  s6619 :: SBool = s15 /= s6618-  s6620 :: SWord8 = if s6619 then s6577 else s6578-  s6621 :: SWord8 = if s18 then s6620 else s6574-  s6622 :: SWord1 = choose [0:0] s6621-  s6623 :: SBool = s15 /= s6622-  s6624 :: SBool = s_2 == s6623-  s6625 :: SBool = s6617 < s6605-  s6626 :: SBool = s6617 < s6566-  s6627 :: SBool = s6625 | s6626-  s6628 :: SWord8 = s6617 >>> 1-  s6629 :: SWord8 = s20 | s6628-  s6630 :: SWord8 = s22 & s6628-  s6631 :: SWord8 = if s6627 then s6629 else s6630-  s6632 :: SWord8 = s6631 >>> 1-  s6633 :: SWord8 = s20 | s6632-  s6634 :: SWord8 = s22 & s6632-  s6635 :: SWord8 = if s6623 then s6633 else s6634-  s6636 :: SWord8 = s6621 >>> 1-  s6637 :: SWord8 = s20 | s6636-  s6638 :: SWord8 = s22 & s6636-  s6639 :: SWord8 = if s6593 then s6637 else s6638-  s6640 :: SWord8 = if s25 then s6620 else s6605-  s6641 :: SWord8 = if s166 then s6639 else s6640-  s6642 :: SWord8 = s6631 + s6641-  s6643 :: SBool = s6642 < s6641-  s6644 :: SBool = s6642 < s6631-  s6645 :: SBool = s6643 | s6644-  s6646 :: SWord8 = s6642 >>> 1-  s6647 :: SWord8 = s20 | s6646-  s6648 :: SWord8 = s22 & s6646-  s6649 :: SWord8 = if s6645 then s6647 else s6648-  s6650 :: SWord8 = if s6624 then s6635 else s6649-  s6651 :: SWord8 = if s6562 then s6616 else s6650-  s6652 :: SWord8 = s6545 + s6603-  s6653 :: SWord1 = choose [0:0] s6652-  s6654 :: SBool = s15 /= s6653-  s6655 :: SWord8 = if s6654 then s6556 else s6557-  s6656 :: SWord8 = if s18 then s6655 else s6553-  s6657 :: SWord1 = choose [0:0] s6656-  s6658 :: SBool = s15 /= s6657-  s6659 :: SBool = s_2 == s6658-  s6660 :: SBool = s6652 < s6603-  s6661 :: SBool = s6652 < s6545-  s6662 :: SBool = s6660 | s6661-  s6663 :: SWord8 = s6652 >>> 1-  s6664 :: SWord8 = s20 | s6663-  s6665 :: SWord8 = s22 & s6663-  s6666 :: SWord8 = if s6662 then s6664 else s6665-  s6667 :: SWord1 = choose [0:0] s6666-  s6668 :: SBool = s15 /= s6667-  s6669 :: SWord8 = s6656 >>> 1-  s6670 :: SWord8 = s20 | s6669-  s6671 :: SWord8 = s22 & s6669-  s6672 :: SWord8 = if s6570 then s6670 else s6671-  s6673 :: SWord8 = if s18 then s6672 else s6655-  s6674 :: SWord8 = s6673 >>> 1-  s6675 :: SWord8 = s20 | s6674-  s6676 :: SWord8 = s22 & s6674-  s6677 :: SWord8 = if s6668 then s6675 else s6676-  s6678 :: SWord8 = if s18 then s6677 else s6672-  s6679 :: SWord1 = choose [0:0] s6678-  s6680 :: SBool = s15 /= s6679-  s6681 :: SBool = s_2 == s6680-  s6682 :: SWord8 = s6666 >>> 1-  s6683 :: SWord8 = s20 | s6682-  s6684 :: SWord8 = s22 & s6682-  s6685 :: SWord8 = if s6658 then s6683 else s6684-  s6686 :: SWord8 = s6685 >>> 1-  s6687 :: SWord8 = s20 | s6686-  s6688 :: SWord8 = s22 & s6686-  s6689 :: SWord8 = if s6680 then s6687 else s6688-  s6690 :: SWord1 = choose [0:0] s6673-  s6691 :: SBool = s15 /= s6690-  s6692 :: SWord8 = s6678 >>> 1-  s6693 :: SWord8 = s20 | s6692-  s6694 :: SWord8 = s22 & s6692-  s6695 :: SWord8 = if s6691 then s6693 else s6694-  s6696 :: SWord8 = if s25 then s6655 else s6603-  s6697 :: SWord8 = if s166 then s6672 else s6696-  s6698 :: SWord8 = if s25 then s6677 else s6697-  s6699 :: SWord8 = if s166 then s6695 else s6698-  s6700 :: SWord8 = s6685 + s6699-  s6701 :: SBool = s6700 < s6699-  s6702 :: SBool = s6700 < s6685-  s6703 :: SBool = s6701 | s6702-  s6704 :: SWord8 = s6700 >>> 1-  s6705 :: SWord8 = s20 | s6704-  s6706 :: SWord8 = s22 & s6704-  s6707 :: SWord8 = if s6703 then s6705 else s6706-  s6708 :: SWord8 = if s6681 then s6689 else s6707-  s6709 :: SWord8 = s6666 + s6697-  s6710 :: SWord1 = choose [0:0] s6709-  s6711 :: SBool = s15 /= s6710-  s6712 :: SWord8 = if s6711 then s6675 else s6676-  s6713 :: SWord8 = if s18 then s6712 else s6672-  s6714 :: SWord1 = choose [0:0] s6713-  s6715 :: SBool = s15 /= s6714-  s6716 :: SBool = s_2 == s6715-  s6717 :: SBool = s6709 < s6697-  s6718 :: SBool = s6709 < s6666-  s6719 :: SBool = s6717 | s6718-  s6720 :: SWord8 = s6709 >>> 1-  s6721 :: SWord8 = s20 | s6720-  s6722 :: SWord8 = s22 & s6720-  s6723 :: SWord8 = if s6719 then s6721 else s6722-  s6724 :: SWord8 = s6723 >>> 1-  s6725 :: SWord8 = s20 | s6724-  s6726 :: SWord8 = s22 & s6724-  s6727 :: SWord8 = if s6715 then s6725 else s6726-  s6728 :: SWord8 = s6713 >>> 1-  s6729 :: SWord8 = s20 | s6728-  s6730 :: SWord8 = s22 & s6728-  s6731 :: SWord8 = if s6691 then s6729 else s6730-  s6732 :: SWord8 = if s25 then s6712 else s6697-  s6733 :: SWord8 = if s166 then s6731 else s6732-  s6734 :: SWord8 = s6723 + s6733-  s6735 :: SBool = s6734 < s6733-  s6736 :: SBool = s6734 < s6723-  s6737 :: SBool = s6735 | s6736-  s6738 :: SWord8 = s6734 >>> 1-  s6739 :: SWord8 = s20 | s6738-  s6740 :: SWord8 = s22 & s6738-  s6741 :: SWord8 = if s6737 then s6739 else s6740-  s6742 :: SWord8 = if s6716 then s6727 else s6741-  s6743 :: SWord8 = if s6659 then s6708 else s6742-  s6744 :: SWord8 = if s6541 then s6651 else s6743-  s6745 :: SWord8 = s6524 + s6601-  s6746 :: SWord1 = choose [0:0] s6745-  s6747 :: SBool = s15 /= s6746-  s6748 :: SWord8 = if s6747 then s6535 else s6536-  s6749 :: SWord8 = if s18 then s6748 else s6532-  s6750 :: SWord1 = choose [0:0] s6749-  s6751 :: SBool = s15 /= s6750-  s6752 :: SBool = s_2 == s6751-  s6753 :: SBool = s6745 < s6601-  s6754 :: SBool = s6745 < s6524-  s6755 :: SBool = s6753 | s6754-  s6756 :: SWord8 = s6745 >>> 1-  s6757 :: SWord8 = s20 | s6756-  s6758 :: SWord8 = s22 & s6756-  s6759 :: SWord8 = if s6755 then s6757 else s6758-  s6760 :: SWord1 = choose [0:0] s6759-  s6761 :: SBool = s15 /= s6760-  s6762 :: SWord8 = s6749 >>> 1-  s6763 :: SWord8 = s20 | s6762-  s6764 :: SWord8 = s22 & s6762-  s6765 :: SWord8 = if s6549 then s6763 else s6764-  s6766 :: SWord8 = if s18 then s6765 else s6748-  s6767 :: SWord8 = s6766 >>> 1-  s6768 :: SWord8 = s20 | s6767-  s6769 :: SWord8 = s22 & s6767-  s6770 :: SWord8 = if s6761 then s6768 else s6769-  s6771 :: SWord8 = if s18 then s6770 else s6765-  s6772 :: SWord1 = choose [0:0] s6771-  s6773 :: SBool = s15 /= s6772-  s6774 :: SBool = s_2 == s6773-  s6775 :: SWord8 = s6759 >>> 1-  s6776 :: SWord8 = s20 | s6775-  s6777 :: SWord8 = s22 & s6775-  s6778 :: SWord8 = if s6751 then s6776 else s6777-  s6779 :: SWord1 = choose [0:0] s6778-  s6780 :: SBool = s15 /= s6779-  s6781 :: SWord1 = choose [0:0] s6766-  s6782 :: SBool = s15 /= s6781-  s6783 :: SWord8 = s6771 >>> 1-  s6784 :: SWord8 = s20 | s6783-  s6785 :: SWord8 = s22 & s6783-  s6786 :: SWord8 = if s6782 then s6784 else s6785-  s6787 :: SWord8 = if s18 then s6786 else s6770-  s6788 :: SWord8 = s6787 >>> 1-  s6789 :: SWord8 = s20 | s6788-  s6790 :: SWord8 = s22 & s6788-  s6791 :: SWord8 = if s6780 then s6789 else s6790-  s6792 :: SWord8 = if s18 then s6791 else s6786-  s6793 :: SWord1 = choose [0:0] s6792-  s6794 :: SBool = s15 /= s6793-  s6795 :: SBool = s_2 == s6794-  s6796 :: SWord8 = s6778 >>> 1-  s6797 :: SWord8 = s20 | s6796-  s6798 :: SWord8 = s22 & s6796-  s6799 :: SWord8 = if s6773 then s6797 else s6798-  s6800 :: SWord8 = s6799 >>> 1-  s6801 :: SWord8 = s20 | s6800-  s6802 :: SWord8 = s22 & s6800-  s6803 :: SWord8 = if s6794 then s6801 else s6802-  s6804 :: SWord1 = choose [0:0] s6787-  s6805 :: SBool = s15 /= s6804-  s6806 :: SWord8 = s6792 >>> 1-  s6807 :: SWord8 = s20 | s6806-  s6808 :: SWord8 = s22 & s6806-  s6809 :: SWord8 = if s6805 then s6807 else s6808-  s6810 :: SWord8 = if s25 then s6748 else s6601-  s6811 :: SWord8 = if s166 then s6765 else s6810-  s6812 :: SWord8 = if s25 then s6770 else s6811-  s6813 :: SWord8 = if s166 then s6786 else s6812-  s6814 :: SWord8 = if s25 then s6791 else s6813-  s6815 :: SWord8 = if s166 then s6809 else s6814-  s6816 :: SWord8 = s6799 + s6815-  s6817 :: SBool = s6816 < s6815-  s6818 :: SBool = s6816 < s6799-  s6819 :: SBool = s6817 | s6818-  s6820 :: SWord8 = s6816 >>> 1-  s6821 :: SWord8 = s20 | s6820-  s6822 :: SWord8 = s22 & s6820-  s6823 :: SWord8 = if s6819 then s6821 else s6822-  s6824 :: SWord8 = if s6795 then s6803 else s6823-  s6825 :: SWord8 = s6778 + s6813-  s6826 :: SWord1 = choose [0:0] s6825-  s6827 :: SBool = s15 /= s6826-  s6828 :: SWord8 = if s6827 then s6789 else s6790-  s6829 :: SWord8 = if s18 then s6828 else s6786-  s6830 :: SWord1 = choose [0:0] s6829-  s6831 :: SBool = s15 /= s6830-  s6832 :: SBool = s_2 == s6831-  s6833 :: SBool = s6825 < s6813-  s6834 :: SBool = s6825 < s6778-  s6835 :: SBool = s6833 | s6834-  s6836 :: SWord8 = s6825 >>> 1-  s6837 :: SWord8 = s20 | s6836-  s6838 :: SWord8 = s22 & s6836-  s6839 :: SWord8 = if s6835 then s6837 else s6838-  s6840 :: SWord8 = s6839 >>> 1-  s6841 :: SWord8 = s20 | s6840-  s6842 :: SWord8 = s22 & s6840-  s6843 :: SWord8 = if s6831 then s6841 else s6842-  s6844 :: SWord8 = s6829 >>> 1-  s6845 :: SWord8 = s20 | s6844-  s6846 :: SWord8 = s22 & s6844-  s6847 :: SWord8 = if s6805 then s6845 else s6846-  s6848 :: SWord8 = if s25 then s6828 else s6813-  s6849 :: SWord8 = if s166 then s6847 else s6848-  s6850 :: SWord8 = s6839 + s6849-  s6851 :: SBool = s6850 < s6849-  s6852 :: SBool = s6850 < s6839-  s6853 :: SBool = s6851 | s6852-  s6854 :: SWord8 = s6850 >>> 1-  s6855 :: SWord8 = s20 | s6854-  s6856 :: SWord8 = s22 & s6854-  s6857 :: SWord8 = if s6853 then s6855 else s6856-  s6858 :: SWord8 = if s6832 then s6843 else s6857-  s6859 :: SWord8 = if s6774 then s6824 else s6858-  s6860 :: SWord8 = s6759 + s6811-  s6861 :: SWord1 = choose [0:0] s6860-  s6862 :: SBool = s15 /= s6861-  s6863 :: SWord8 = if s6862 then s6768 else s6769-  s6864 :: SWord8 = if s18 then s6863 else s6765-  s6865 :: SWord1 = choose [0:0] s6864-  s6866 :: SBool = s15 /= s6865-  s6867 :: SBool = s_2 == s6866-  s6868 :: SBool = s6860 < s6811-  s6869 :: SBool = s6860 < s6759-  s6870 :: SBool = s6868 | s6869-  s6871 :: SWord8 = s6860 >>> 1-  s6872 :: SWord8 = s20 | s6871-  s6873 :: SWord8 = s22 & s6871-  s6874 :: SWord8 = if s6870 then s6872 else s6873-  s6875 :: SWord1 = choose [0:0] s6874-  s6876 :: SBool = s15 /= s6875-  s6877 :: SWord8 = s6864 >>> 1-  s6878 :: SWord8 = s20 | s6877-  s6879 :: SWord8 = s22 & s6877-  s6880 :: SWord8 = if s6782 then s6878 else s6879-  s6881 :: SWord8 = if s18 then s6880 else s6863-  s6882 :: SWord8 = s6881 >>> 1-  s6883 :: SWord8 = s20 | s6882-  s6884 :: SWord8 = s22 & s6882-  s6885 :: SWord8 = if s6876 then s6883 else s6884-  s6886 :: SWord8 = if s18 then s6885 else s6880-  s6887 :: SWord1 = choose [0:0] s6886-  s6888 :: SBool = s15 /= s6887-  s6889 :: SBool = s_2 == s6888-  s6890 :: SWord8 = s6874 >>> 1-  s6891 :: SWord8 = s20 | s6890-  s6892 :: SWord8 = s22 & s6890-  s6893 :: SWord8 = if s6866 then s6891 else s6892-  s6894 :: SWord8 = s6893 >>> 1-  s6895 :: SWord8 = s20 | s6894-  s6896 :: SWord8 = s22 & s6894-  s6897 :: SWord8 = if s6888 then s6895 else s6896-  s6898 :: SWord1 = choose [0:0] s6881-  s6899 :: SBool = s15 /= s6898-  s6900 :: SWord8 = s6886 >>> 1-  s6901 :: SWord8 = s20 | s6900-  s6902 :: SWord8 = s22 & s6900-  s6903 :: SWord8 = if s6899 then s6901 else s6902-  s6904 :: SWord8 = if s25 then s6863 else s6811-  s6905 :: SWord8 = if s166 then s6880 else s6904-  s6906 :: SWord8 = if s25 then s6885 else s6905-  s6907 :: SWord8 = if s166 then s6903 else s6906-  s6908 :: SWord8 = s6893 + s6907-  s6909 :: SBool = s6908 < s6907-  s6910 :: SBool = s6908 < s6893-  s6911 :: SBool = s6909 | s6910-  s6912 :: SWord8 = s6908 >>> 1-  s6913 :: SWord8 = s20 | s6912-  s6914 :: SWord8 = s22 & s6912-  s6915 :: SWord8 = if s6911 then s6913 else s6914-  s6916 :: SWord8 = if s6889 then s6897 else s6915-  s6917 :: SWord8 = s6874 + s6905-  s6918 :: SWord1 = choose [0:0] s6917-  s6919 :: SBool = s15 /= s6918-  s6920 :: SWord8 = if s6919 then s6883 else s6884-  s6921 :: SWord8 = if s18 then s6920 else s6880-  s6922 :: SWord1 = choose [0:0] s6921-  s6923 :: SBool = s15 /= s6922-  s6924 :: SBool = s_2 == s6923-  s6925 :: SBool = s6917 < s6905-  s6926 :: SBool = s6917 < s6874-  s6927 :: SBool = s6925 | s6926-  s6928 :: SWord8 = s6917 >>> 1-  s6929 :: SWord8 = s20 | s6928-  s6930 :: SWord8 = s22 & s6928-  s6931 :: SWord8 = if s6927 then s6929 else s6930-  s6932 :: SWord8 = s6931 >>> 1-  s6933 :: SWord8 = s20 | s6932-  s6934 :: SWord8 = s22 & s6932-  s6935 :: SWord8 = if s6923 then s6933 else s6934-  s6936 :: SWord8 = s6921 >>> 1-  s6937 :: SWord8 = s20 | s6936-  s6938 :: SWord8 = s22 & s6936-  s6939 :: SWord8 = if s6899 then s6937 else s6938-  s6940 :: SWord8 = if s25 then s6920 else s6905-  s6941 :: SWord8 = if s166 then s6939 else s6940-  s6942 :: SWord8 = s6931 + s6941-  s6943 :: SBool = s6942 < s6941-  s6944 :: SBool = s6942 < s6931-  s6945 :: SBool = s6943 | s6944-  s6946 :: SWord8 = s6942 >>> 1-  s6947 :: SWord8 = s20 | s6946-  s6948 :: SWord8 = s22 & s6946-  s6949 :: SWord8 = if s6945 then s6947 else s6948-  s6950 :: SWord8 = if s6924 then s6935 else s6949-  s6951 :: SWord8 = if s6867 then s6916 else s6950-  s6952 :: SWord8 = if s6752 then s6859 else s6951-  s6953 :: SWord8 = if s6520 then s6744 else s6952-  s6954 :: SWord8 = s6505 + s6599-  s6955 :: SWord1 = choose [0:0] s6954-  s6956 :: SBool = s15 /= s6955-  s6957 :: SWord8 = if s6956 then s6514 else s6515-  s6958 :: SWord8 = if s18 then s6957 else s6511-  s6959 :: SWord1 = choose [0:0] s6958-  s6960 :: SBool = s15 /= s6959-  s6961 :: SBool = s_2 == s6960-  s6962 :: SBool = s6954 < s6599-  s6963 :: SBool = s6954 < s6505-  s6964 :: SBool = s6962 | s6963-  s6965 :: SWord8 = s6954 >>> 1-  s6966 :: SWord8 = s20 | s6965-  s6967 :: SWord8 = s22 & s6965-  s6968 :: SWord8 = if s6964 then s6966 else s6967-  s6969 :: SWord1 = choose [0:0] s6968-  s6970 :: SBool = s15 /= s6969-  s6971 :: SWord8 = s6958 >>> 1-  s6972 :: SWord8 = s20 | s6971-  s6973 :: SWord8 = s22 & s6971-  s6974 :: SWord8 = if s6528 then s6972 else s6973-  s6975 :: SWord8 = if s18 then s6974 else s6957-  s6976 :: SWord8 = s6975 >>> 1-  s6977 :: SWord8 = s20 | s6976-  s6978 :: SWord8 = s22 & s6976-  s6979 :: SWord8 = if s6970 then s6977 else s6978-  s6980 :: SWord8 = if s18 then s6979 else s6974-  s6981 :: SWord1 = choose [0:0] s6980-  s6982 :: SBool = s15 /= s6981-  s6983 :: SBool = s_2 == s6982-  s6984 :: SWord8 = s6968 >>> 1-  s6985 :: SWord8 = s20 | s6984-  s6986 :: SWord8 = s22 & s6984-  s6987 :: SWord8 = if s6960 then s6985 else s6986-  s6988 :: SWord1 = choose [0:0] s6987-  s6989 :: SBool = s15 /= s6988-  s6990 :: SWord1 = choose [0:0] s6975-  s6991 :: SBool = s15 /= s6990-  s6992 :: SWord8 = s6980 >>> 1-  s6993 :: SWord8 = s20 | s6992-  s6994 :: SWord8 = s22 & s6992-  s6995 :: SWord8 = if s6991 then s6993 else s6994-  s6996 :: SWord8 = if s18 then s6995 else s6979-  s6997 :: SWord8 = s6996 >>> 1-  s6998 :: SWord8 = s20 | s6997-  s6999 :: SWord8 = s22 & s6997-  s7000 :: SWord8 = if s6989 then s6998 else s6999-  s7001 :: SWord8 = if s18 then s7000 else s6995-  s7002 :: SWord1 = choose [0:0] s7001-  s7003 :: SBool = s15 /= s7002-  s7004 :: SBool = s_2 == s7003-  s7005 :: SWord8 = s6987 >>> 1-  s7006 :: SWord8 = s20 | s7005-  s7007 :: SWord8 = s22 & s7005-  s7008 :: SWord8 = if s6982 then s7006 else s7007-  s7009 :: SWord1 = choose [0:0] s7008-  s7010 :: SBool = s15 /= s7009-  s7011 :: SWord1 = choose [0:0] s6996-  s7012 :: SBool = s15 /= s7011-  s7013 :: SWord8 = s7001 >>> 1-  s7014 :: SWord8 = s20 | s7013-  s7015 :: SWord8 = s22 & s7013-  s7016 :: SWord8 = if s7012 then s7014 else s7015-  s7017 :: SWord8 = if s18 then s7016 else s7000-  s7018 :: SWord8 = s7017 >>> 1-  s7019 :: SWord8 = s20 | s7018-  s7020 :: SWord8 = s22 & s7018-  s7021 :: SWord8 = if s7010 then s7019 else s7020-  s7022 :: SWord8 = if s18 then s7021 else s7016-  s7023 :: SWord1 = choose [0:0] s7022-  s7024 :: SBool = s15 /= s7023-  s7025 :: SBool = s_2 == s7024-  s7026 :: SWord8 = s7008 >>> 1-  s7027 :: SWord8 = s20 | s7026-  s7028 :: SWord8 = s22 & s7026-  s7029 :: SWord8 = if s7003 then s7027 else s7028-  s7030 :: SWord8 = s7029 >>> 1-  s7031 :: SWord8 = s20 | s7030-  s7032 :: SWord8 = s22 & s7030-  s7033 :: SWord8 = if s7024 then s7031 else s7032-  s7034 :: SWord1 = choose [0:0] s7017-  s7035 :: SBool = s15 /= s7034-  s7036 :: SWord8 = s7022 >>> 1-  s7037 :: SWord8 = s20 | s7036-  s7038 :: SWord8 = s22 & s7036-  s7039 :: SWord8 = if s7035 then s7037 else s7038-  s7040 :: SWord8 = if s25 then s6957 else s6599-  s7041 :: SWord8 = if s166 then s6974 else s7040-  s7042 :: SWord8 = if s25 then s6979 else s7041-  s7043 :: SWord8 = if s166 then s6995 else s7042-  s7044 :: SWord8 = if s25 then s7000 else s7043-  s7045 :: SWord8 = if s166 then s7016 else s7044-  s7046 :: SWord8 = if s25 then s7021 else s7045-  s7047 :: SWord8 = if s166 then s7039 else s7046-  s7048 :: SWord8 = s7029 + s7047-  s7049 :: SBool = s7048 < s7047-  s7050 :: SBool = s7048 < s7029-  s7051 :: SBool = s7049 | s7050-  s7052 :: SWord8 = s7048 >>> 1-  s7053 :: SWord8 = s20 | s7052-  s7054 :: SWord8 = s22 & s7052-  s7055 :: SWord8 = if s7051 then s7053 else s7054-  s7056 :: SWord8 = if s7025 then s7033 else s7055-  s7057 :: SWord8 = s7008 + s7045-  s7058 :: SWord1 = choose [0:0] s7057-  s7059 :: SBool = s15 /= s7058-  s7060 :: SWord8 = if s7059 then s7019 else s7020-  s7061 :: SWord8 = if s18 then s7060 else s7016-  s7062 :: SWord1 = choose [0:0] s7061-  s7063 :: SBool = s15 /= s7062-  s7064 :: SBool = s_2 == s7063-  s7065 :: SBool = s7057 < s7045-  s7066 :: SBool = s7057 < s7008-  s7067 :: SBool = s7065 | s7066-  s7068 :: SWord8 = s7057 >>> 1-  s7069 :: SWord8 = s20 | s7068-  s7070 :: SWord8 = s22 & s7068-  s7071 :: SWord8 = if s7067 then s7069 else s7070-  s7072 :: SWord8 = s7071 >>> 1-  s7073 :: SWord8 = s20 | s7072-  s7074 :: SWord8 = s22 & s7072-  s7075 :: SWord8 = if s7063 then s7073 else s7074-  s7076 :: SWord8 = s7061 >>> 1-  s7077 :: SWord8 = s20 | s7076-  s7078 :: SWord8 = s22 & s7076-  s7079 :: SWord8 = if s7035 then s7077 else s7078-  s7080 :: SWord8 = if s25 then s7060 else s7045-  s7081 :: SWord8 = if s166 then s7079 else s7080-  s7082 :: SWord8 = s7071 + s7081-  s7083 :: SBool = s7082 < s7081-  s7084 :: SBool = s7082 < s7071-  s7085 :: SBool = s7083 | s7084-  s7086 :: SWord8 = s7082 >>> 1-  s7087 :: SWord8 = s20 | s7086-  s7088 :: SWord8 = s22 & s7086-  s7089 :: SWord8 = if s7085 then s7087 else s7088-  s7090 :: SWord8 = if s7064 then s7075 else s7089-  s7091 :: SWord8 = if s7004 then s7056 else s7090-  s7092 :: SWord8 = s6987 + s7043-  s7093 :: SWord1 = choose [0:0] s7092-  s7094 :: SBool = s15 /= s7093-  s7095 :: SWord8 = if s7094 then s6998 else s6999-  s7096 :: SWord8 = if s18 then s7095 else s6995-  s7097 :: SWord1 = choose [0:0] s7096-  s7098 :: SBool = s15 /= s7097-  s7099 :: SBool = s_2 == s7098-  s7100 :: SBool = s7092 < s7043-  s7101 :: SBool = s7092 < s6987-  s7102 :: SBool = s7100 | s7101-  s7103 :: SWord8 = s7092 >>> 1-  s7104 :: SWord8 = s20 | s7103-  s7105 :: SWord8 = s22 & s7103-  s7106 :: SWord8 = if s7102 then s7104 else s7105-  s7107 :: SWord1 = choose [0:0] s7106-  s7108 :: SBool = s15 /= s7107-  s7109 :: SWord8 = s7096 >>> 1-  s7110 :: SWord8 = s20 | s7109-  s7111 :: SWord8 = s22 & s7109-  s7112 :: SWord8 = if s7012 then s7110 else s7111-  s7113 :: SWord8 = if s18 then s7112 else s7095-  s7114 :: SWord8 = s7113 >>> 1-  s7115 :: SWord8 = s20 | s7114-  s7116 :: SWord8 = s22 & s7114-  s7117 :: SWord8 = if s7108 then s7115 else s7116-  s7118 :: SWord8 = if s18 then s7117 else s7112-  s7119 :: SWord1 = choose [0:0] s7118-  s7120 :: SBool = s15 /= s7119-  s7121 :: SBool = s_2 == s7120-  s7122 :: SWord8 = s7106 >>> 1-  s7123 :: SWord8 = s20 | s7122-  s7124 :: SWord8 = s22 & s7122-  s7125 :: SWord8 = if s7098 then s7123 else s7124-  s7126 :: SWord8 = s7125 >>> 1-  s7127 :: SWord8 = s20 | s7126-  s7128 :: SWord8 = s22 & s7126-  s7129 :: SWord8 = if s7120 then s7127 else s7128-  s7130 :: SWord1 = choose [0:0] s7113-  s7131 :: SBool = s15 /= s7130-  s7132 :: SWord8 = s7118 >>> 1-  s7133 :: SWord8 = s20 | s7132-  s7134 :: SWord8 = s22 & s7132-  s7135 :: SWord8 = if s7131 then s7133 else s7134-  s7136 :: SWord8 = if s25 then s7095 else s7043-  s7137 :: SWord8 = if s166 then s7112 else s7136-  s7138 :: SWord8 = if s25 then s7117 else s7137-  s7139 :: SWord8 = if s166 then s7135 else s7138-  s7140 :: SWord8 = s7125 + s7139-  s7141 :: SBool = s7140 < s7139-  s7142 :: SBool = s7140 < s7125-  s7143 :: SBool = s7141 | s7142-  s7144 :: SWord8 = s7140 >>> 1-  s7145 :: SWord8 = s20 | s7144-  s7146 :: SWord8 = s22 & s7144-  s7147 :: SWord8 = if s7143 then s7145 else s7146-  s7148 :: SWord8 = if s7121 then s7129 else s7147-  s7149 :: SWord8 = s7106 + s7137-  s7150 :: SWord1 = choose [0:0] s7149-  s7151 :: SBool = s15 /= s7150-  s7152 :: SWord8 = if s7151 then s7115 else s7116-  s7153 :: SWord8 = if s18 then s7152 else s7112-  s7154 :: SWord1 = choose [0:0] s7153-  s7155 :: SBool = s15 /= s7154-  s7156 :: SBool = s_2 == s7155-  s7157 :: SBool = s7149 < s7137-  s7158 :: SBool = s7149 < s7106-  s7159 :: SBool = s7157 | s7158-  s7160 :: SWord8 = s7149 >>> 1-  s7161 :: SWord8 = s20 | s7160-  s7162 :: SWord8 = s22 & s7160-  s7163 :: SWord8 = if s7159 then s7161 else s7162-  s7164 :: SWord8 = s7163 >>> 1-  s7165 :: SWord8 = s20 | s7164-  s7166 :: SWord8 = s22 & s7164-  s7167 :: SWord8 = if s7155 then s7165 else s7166-  s7168 :: SWord8 = s7153 >>> 1-  s7169 :: SWord8 = s20 | s7168-  s7170 :: SWord8 = s22 & s7168-  s7171 :: SWord8 = if s7131 then s7169 else s7170-  s7172 :: SWord8 = if s25 then s7152 else s7137-  s7173 :: SWord8 = if s166 then s7171 else s7172-  s7174 :: SWord8 = s7163 + s7173-  s7175 :: SBool = s7174 < s7173-  s7176 :: SBool = s7174 < s7163-  s7177 :: SBool = s7175 | s7176-  s7178 :: SWord8 = s7174 >>> 1-  s7179 :: SWord8 = s20 | s7178-  s7180 :: SWord8 = s22 & s7178-  s7181 :: SWord8 = if s7177 then s7179 else s7180-  s7182 :: SWord8 = if s7156 then s7167 else s7181-  s7183 :: SWord8 = if s7099 then s7148 else s7182-  s7184 :: SWord8 = if s6983 then s7091 else s7183-  s7185 :: SWord8 = s6968 + s7041-  s7186 :: SWord1 = choose [0:0] s7185-  s7187 :: SBool = s15 /= s7186-  s7188 :: SWord8 = if s7187 then s6977 else s6978-  s7189 :: SWord8 = if s18 then s7188 else s6974-  s7190 :: SWord1 = choose [0:0] s7189-  s7191 :: SBool = s15 /= s7190-  s7192 :: SBool = s_2 == s7191-  s7193 :: SBool = s7185 < s7041-  s7194 :: SBool = s7185 < s6968-  s7195 :: SBool = s7193 | s7194-  s7196 :: SWord8 = s7185 >>> 1-  s7197 :: SWord8 = s20 | s7196-  s7198 :: SWord8 = s22 & s7196-  s7199 :: SWord8 = if s7195 then s7197 else s7198-  s7200 :: SWord1 = choose [0:0] s7199-  s7201 :: SBool = s15 /= s7200-  s7202 :: SWord8 = s7189 >>> 1-  s7203 :: SWord8 = s20 | s7202-  s7204 :: SWord8 = s22 & s7202-  s7205 :: SWord8 = if s6991 then s7203 else s7204-  s7206 :: SWord8 = if s18 then s7205 else s7188-  s7207 :: SWord8 = s7206 >>> 1-  s7208 :: SWord8 = s20 | s7207-  s7209 :: SWord8 = s22 & s7207-  s7210 :: SWord8 = if s7201 then s7208 else s7209-  s7211 :: SWord8 = if s18 then s7210 else s7205-  s7212 :: SWord1 = choose [0:0] s7211-  s7213 :: SBool = s15 /= s7212-  s7214 :: SBool = s_2 == s7213-  s7215 :: SWord8 = s7199 >>> 1-  s7216 :: SWord8 = s20 | s7215-  s7217 :: SWord8 = s22 & s7215-  s7218 :: SWord8 = if s7191 then s7216 else s7217-  s7219 :: SWord1 = choose [0:0] s7218-  s7220 :: SBool = s15 /= s7219-  s7221 :: SWord1 = choose [0:0] s7206-  s7222 :: SBool = s15 /= s7221-  s7223 :: SWord8 = s7211 >>> 1-  s7224 :: SWord8 = s20 | s7223-  s7225 :: SWord8 = s22 & s7223-  s7226 :: SWord8 = if s7222 then s7224 else s7225-  s7227 :: SWord8 = if s18 then s7226 else s7210-  s7228 :: SWord8 = s7227 >>> 1-  s7229 :: SWord8 = s20 | s7228-  s7230 :: SWord8 = s22 & s7228-  s7231 :: SWord8 = if s7220 then s7229 else s7230-  s7232 :: SWord8 = if s18 then s7231 else s7226-  s7233 :: SWord1 = choose [0:0] s7232-  s7234 :: SBool = s15 /= s7233-  s7235 :: SBool = s_2 == s7234-  s7236 :: SWord8 = s7218 >>> 1-  s7237 :: SWord8 = s20 | s7236-  s7238 :: SWord8 = s22 & s7236-  s7239 :: SWord8 = if s7213 then s7237 else s7238-  s7240 :: SWord8 = s7239 >>> 1-  s7241 :: SWord8 = s20 | s7240-  s7242 :: SWord8 = s22 & s7240-  s7243 :: SWord8 = if s7234 then s7241 else s7242-  s7244 :: SWord1 = choose [0:0] s7227-  s7245 :: SBool = s15 /= s7244-  s7246 :: SWord8 = s7232 >>> 1-  s7247 :: SWord8 = s20 | s7246-  s7248 :: SWord8 = s22 & s7246-  s7249 :: SWord8 = if s7245 then s7247 else s7248-  s7250 :: SWord8 = if s25 then s7188 else s7041-  s7251 :: SWord8 = if s166 then s7205 else s7250-  s7252 :: SWord8 = if s25 then s7210 else s7251-  s7253 :: SWord8 = if s166 then s7226 else s7252-  s7254 :: SWord8 = if s25 then s7231 else s7253-  s7255 :: SWord8 = if s166 then s7249 else s7254-  s7256 :: SWord8 = s7239 + s7255-  s7257 :: SBool = s7256 < s7255-  s7258 :: SBool = s7256 < s7239-  s7259 :: SBool = s7257 | s7258-  s7260 :: SWord8 = s7256 >>> 1-  s7261 :: SWord8 = s20 | s7260-  s7262 :: SWord8 = s22 & s7260-  s7263 :: SWord8 = if s7259 then s7261 else s7262-  s7264 :: SWord8 = if s7235 then s7243 else s7263-  s7265 :: SWord8 = s7218 + s7253-  s7266 :: SWord1 = choose [0:0] s7265-  s7267 :: SBool = s15 /= s7266-  s7268 :: SWord8 = if s7267 then s7229 else s7230-  s7269 :: SWord8 = if s18 then s7268 else s7226-  s7270 :: SWord1 = choose [0:0] s7269-  s7271 :: SBool = s15 /= s7270-  s7272 :: SBool = s_2 == s7271-  s7273 :: SBool = s7265 < s7253-  s7274 :: SBool = s7265 < s7218-  s7275 :: SBool = s7273 | s7274-  s7276 :: SWord8 = s7265 >>> 1-  s7277 :: SWord8 = s20 | s7276-  s7278 :: SWord8 = s22 & s7276-  s7279 :: SWord8 = if s7275 then s7277 else s7278-  s7280 :: SWord8 = s7279 >>> 1-  s7281 :: SWord8 = s20 | s7280-  s7282 :: SWord8 = s22 & s7280-  s7283 :: SWord8 = if s7271 then s7281 else s7282-  s7284 :: SWord8 = s7269 >>> 1-  s7285 :: SWord8 = s20 | s7284-  s7286 :: SWord8 = s22 & s7284-  s7287 :: SWord8 = if s7245 then s7285 else s7286-  s7288 :: SWord8 = if s25 then s7268 else s7253-  s7289 :: SWord8 = if s166 then s7287 else s7288-  s7290 :: SWord8 = s7279 + s7289-  s7291 :: SBool = s7290 < s7289-  s7292 :: SBool = s7290 < s7279-  s7293 :: SBool = s7291 | s7292-  s7294 :: SWord8 = s7290 >>> 1-  s7295 :: SWord8 = s20 | s7294-  s7296 :: SWord8 = s22 & s7294-  s7297 :: SWord8 = if s7293 then s7295 else s7296-  s7298 :: SWord8 = if s7272 then s7283 else s7297-  s7299 :: SWord8 = if s7214 then s7264 else s7298-  s7300 :: SWord8 = s7199 + s7251-  s7301 :: SWord1 = choose [0:0] s7300-  s7302 :: SBool = s15 /= s7301-  s7303 :: SWord8 = if s7302 then s7208 else s7209-  s7304 :: SWord8 = if s18 then s7303 else s7205-  s7305 :: SWord1 = choose [0:0] s7304-  s7306 :: SBool = s15 /= s7305-  s7307 :: SBool = s_2 == s7306-  s7308 :: SBool = s7300 < s7251-  s7309 :: SBool = s7300 < s7199-  s7310 :: SBool = s7308 | s7309-  s7311 :: SWord8 = s7300 >>> 1-  s7312 :: SWord8 = s20 | s7311-  s7313 :: SWord8 = s22 & s7311-  s7314 :: SWord8 = if s7310 then s7312 else s7313-  s7315 :: SWord1 = choose [0:0] s7314-  s7316 :: SBool = s15 /= s7315-  s7317 :: SWord8 = s7304 >>> 1-  s7318 :: SWord8 = s20 | s7317-  s7319 :: SWord8 = s22 & s7317-  s7320 :: SWord8 = if s7222 then s7318 else s7319-  s7321 :: SWord8 = if s18 then s7320 else s7303-  s7322 :: SWord8 = s7321 >>> 1-  s7323 :: SWord8 = s20 | s7322-  s7324 :: SWord8 = s22 & s7322-  s7325 :: SWord8 = if s7316 then s7323 else s7324-  s7326 :: SWord8 = if s18 then s7325 else s7320-  s7327 :: SWord1 = choose [0:0] s7326-  s7328 :: SBool = s15 /= s7327-  s7329 :: SBool = s_2 == s7328-  s7330 :: SWord8 = s7314 >>> 1-  s7331 :: SWord8 = s20 | s7330-  s7332 :: SWord8 = s22 & s7330-  s7333 :: SWord8 = if s7306 then s7331 else s7332-  s7334 :: SWord8 = s7333 >>> 1-  s7335 :: SWord8 = s20 | s7334-  s7336 :: SWord8 = s22 & s7334-  s7337 :: SWord8 = if s7328 then s7335 else s7336-  s7338 :: SWord1 = choose [0:0] s7321-  s7339 :: SBool = s15 /= s7338-  s7340 :: SWord8 = s7326 >>> 1-  s7341 :: SWord8 = s20 | s7340-  s7342 :: SWord8 = s22 & s7340-  s7343 :: SWord8 = if s7339 then s7341 else s7342-  s7344 :: SWord8 = if s25 then s7303 else s7251-  s7345 :: SWord8 = if s166 then s7320 else s7344-  s7346 :: SWord8 = if s25 then s7325 else s7345-  s7347 :: SWord8 = if s166 then s7343 else s7346-  s7348 :: SWord8 = s7333 + s7347-  s7349 :: SBool = s7348 < s7347-  s7350 :: SBool = s7348 < s7333-  s7351 :: SBool = s7349 | s7350-  s7352 :: SWord8 = s7348 >>> 1-  s7353 :: SWord8 = s20 | s7352-  s7354 :: SWord8 = s22 & s7352-  s7355 :: SWord8 = if s7351 then s7353 else s7354-  s7356 :: SWord8 = if s7329 then s7337 else s7355-  s7357 :: SWord8 = s7314 + s7345-  s7358 :: SWord1 = choose [0:0] s7357-  s7359 :: SBool = s15 /= s7358-  s7360 :: SWord8 = if s7359 then s7323 else s7324-  s7361 :: SWord8 = if s18 then s7360 else s7320-  s7362 :: SWord1 = choose [0:0] s7361-  s7363 :: SBool = s15 /= s7362-  s7364 :: SBool = s_2 == s7363-  s7365 :: SBool = s7357 < s7345-  s7366 :: SBool = s7357 < s7314-  s7367 :: SBool = s7365 | s7366-  s7368 :: SWord8 = s7357 >>> 1-  s7369 :: SWord8 = s20 | s7368-  s7370 :: SWord8 = s22 & s7368-  s7371 :: SWord8 = if s7367 then s7369 else s7370-  s7372 :: SWord8 = s7371 >>> 1-  s7373 :: SWord8 = s20 | s7372-  s7374 :: SWord8 = s22 & s7372-  s7375 :: SWord8 = if s7363 then s7373 else s7374-  s7376 :: SWord8 = s7361 >>> 1-  s7377 :: SWord8 = s20 | s7376-  s7378 :: SWord8 = s22 & s7376-  s7379 :: SWord8 = if s7339 then s7377 else s7378-  s7380 :: SWord8 = if s25 then s7360 else s7345-  s7381 :: SWord8 = if s166 then s7379 else s7380-  s7382 :: SWord8 = s7371 + s7381-  s7383 :: SBool = s7382 < s7381-  s7384 :: SBool = s7382 < s7371-  s7385 :: SBool = s7383 | s7384-  s7386 :: SWord8 = s7382 >>> 1-  s7387 :: SWord8 = s20 | s7386-  s7388 :: SWord8 = s22 & s7386-  s7389 :: SWord8 = if s7385 then s7387 else s7388-  s7390 :: SWord8 = if s7364 then s7375 else s7389-  s7391 :: SWord8 = if s7307 then s7356 else s7390-  s7392 :: SWord8 = if s7192 then s7299 else s7391-  s7393 :: SWord8 = if s6961 then s7184 else s7392-  s7394 :: SWord8 = if s6498 then s6953 else s7393-  s7395 :: SWord8 = if s5571 then s6490 else s7394-  s7396 :: SWord8 = if s3721 then s5563 else s7395-  s7397 :: SWord8 = if s17 then s3713 else s7396-  s7398 :: SWord16 = s13 # s7397-  s7399 :: SWord16 = s12 * s7398-  s7400 :: SWord1 = choose [0:0] s161-  s7401 :: SBool = s15 /= s7400-  s7402 :: SWord8 = if s18 then s172 else s153-  s7403 :: SWord8 = s7402 >>> 1-  s7404 :: SWord8 = s20 | s7403-  s7405 :: SWord8 = s22 & s7403-  s7406 :: SWord8 = if s7401 then s7404 else s7405-  s7407 :: SWord1 = choose [0:0] s189-  s7408 :: SBool = s15 /= s7407-  s7409 :: SWord8 = if s7408 then s7404 else s7405-  s7410 :: SWord8 = if s157 then s7406 else s7409-  s7411 :: SWord1 = choose [0:0] s212-  s7412 :: SBool = s15 /= s7411-  s7413 :: SWord8 = if s18 then s220 else s201-  s7414 :: SWord8 = s7413 >>> 1-  s7415 :: SWord8 = s20 | s7414-  s7416 :: SWord8 = s22 & s7414-  s7417 :: SWord8 = if s7412 then s7415 else s7416-  s7418 :: SWord1 = choose [0:0] s223-  s7419 :: SBool = s15 /= s7418-  s7420 :: SWord8 = if s7419 then s7415 else s7416-  s7421 :: SWord8 = if s205 then s7417 else s7420-  s7422 :: SWord8 = if s136 then s7410 else s7421-  s7423 :: SWord1 = choose [0:0] s266-  s7424 :: SBool = s15 /= s7423-  s7425 :: SWord8 = if s18 then s276 else s258-  s7426 :: SWord8 = s7425 >>> 1-  s7427 :: SWord8 = s20 | s7426-  s7428 :: SWord8 = s22 & s7426-  s7429 :: SWord8 = if s7424 then s7427 else s7428-  s7430 :: SWord1 = choose [0:0] s281-  s7431 :: SBool = s15 /= s7430-  s7432 :: SWord8 = if s7431 then s7427 else s7428-  s7433 :: SWord8 = if s262 then s7429 else s7432-  s7434 :: SWord1 = choose [0:0] s304-  s7435 :: SBool = s15 /= s7434-  s7436 :: SWord8 = if s18 then s312 else s293-  s7437 :: SWord8 = s7436 >>> 1-  s7438 :: SWord8 = s20 | s7437-  s7439 :: SWord8 = s22 & s7437-  s7440 :: SWord8 = if s7435 then s7438 else s7439-  s7441 :: SWord1 = choose [0:0] s315-  s7442 :: SBool = s15 /= s7441-  s7443 :: SWord8 = if s7442 then s7438 else s7439-  s7444 :: SWord8 = if s297 then s7440 else s7443-  s7445 :: SWord8 = if s240 then s7433 else s7444-  s7446 :: SWord8 = if s115 then s7422 else s7445-  s7447 :: SWord1 = choose [0:0] s380-  s7448 :: SBool = s15 /= s7447-  s7449 :: SWord8 = if s18 then s390 else s372-  s7450 :: SWord8 = s7449 >>> 1-  s7451 :: SWord8 = s20 | s7450-  s7452 :: SWord8 = s22 & s7450-  s7453 :: SWord8 = if s7448 then s7451 else s7452-  s7454 :: SWord1 = choose [0:0] s397-  s7455 :: SBool = s15 /= s7454-  s7456 :: SWord8 = if s7455 then s7451 else s7452-  s7457 :: SWord8 = if s376 then s7453 else s7456-  s7458 :: SWord1 = choose [0:0] s420-  s7459 :: SBool = s15 /= s7458-  s7460 :: SWord8 = if s18 then s428 else s409-  s7461 :: SWord8 = s7460 >>> 1-  s7462 :: SWord8 = s20 | s7461-  s7463 :: SWord8 = s22 & s7461-  s7464 :: SWord8 = if s7459 then s7462 else s7463-  s7465 :: SWord1 = choose [0:0] s431-  s7466 :: SBool = s15 /= s7465-  s7467 :: SWord8 = if s7466 then s7462 else s7463-  s7468 :: SWord8 = if s413 then s7464 else s7467-  s7469 :: SWord8 = if s355 then s7457 else s7468-  s7470 :: SWord1 = choose [0:0] s474-  s7471 :: SBool = s15 /= s7470-  s7472 :: SWord8 = if s18 then s484 else s466-  s7473 :: SWord8 = s7472 >>> 1-  s7474 :: SWord8 = s20 | s7473-  s7475 :: SWord8 = s22 & s7473-  s7476 :: SWord8 = if s7471 then s7474 else s7475-  s7477 :: SWord1 = choose [0:0] s489-  s7478 :: SBool = s15 /= s7477-  s7479 :: SWord8 = if s7478 then s7474 else s7475-  s7480 :: SWord8 = if s470 then s7476 else s7479-  s7481 :: SWord1 = choose [0:0] s512-  s7482 :: SBool = s15 /= s7481-  s7483 :: SWord8 = if s18 then s520 else s501-  s7484 :: SWord8 = s7483 >>> 1-  s7485 :: SWord8 = s20 | s7484-  s7486 :: SWord8 = s22 & s7484-  s7487 :: SWord8 = if s7482 then s7485 else s7486-  s7488 :: SWord1 = choose [0:0] s523-  s7489 :: SBool = s15 /= s7488-  s7490 :: SWord8 = if s7489 then s7485 else s7486-  s7491 :: SWord8 = if s505 then s7487 else s7490-  s7492 :: SWord8 = if s448 then s7480 else s7491-  s7493 :: SWord8 = if s333 then s7469 else s7492-  s7494 :: SWord8 = if s94 then s7446 else s7493-  s7495 :: SWord1 = choose [0:0] s610-  s7496 :: SBool = s15 /= s7495-  s7497 :: SWord8 = if s18 then s620 else s602-  s7498 :: SWord8 = s7497 >>> 1-  s7499 :: SWord8 = s20 | s7498-  s7500 :: SWord8 = s22 & s7498-  s7501 :: SWord8 = if s7496 then s7499 else s7500-  s7502 :: SWord1 = choose [0:0] s629-  s7503 :: SBool = s15 /= s7502-  s7504 :: SWord8 = if s7503 then s7499 else s7500-  s7505 :: SWord8 = if s606 then s7501 else s7504-  s7506 :: SWord1 = choose [0:0] s652-  s7507 :: SBool = s15 /= s7506-  s7508 :: SWord8 = if s18 then s660 else s641-  s7509 :: SWord8 = s7508 >>> 1-  s7510 :: SWord8 = s20 | s7509-  s7511 :: SWord8 = s22 & s7509-  s7512 :: SWord8 = if s7507 then s7510 else s7511-  s7513 :: SWord1 = choose [0:0] s663-  s7514 :: SBool = s15 /= s7513-  s7515 :: SWord8 = if s7514 then s7510 else s7511-  s7516 :: SWord8 = if s645 then s7512 else s7515-  s7517 :: SWord8 = if s585 then s7505 else s7516-  s7518 :: SWord1 = choose [0:0] s706-  s7519 :: SBool = s15 /= s7518-  s7520 :: SWord8 = if s18 then s716 else s698-  s7521 :: SWord8 = s7520 >>> 1-  s7522 :: SWord8 = s20 | s7521-  s7523 :: SWord8 = s22 & s7521-  s7524 :: SWord8 = if s7519 then s7522 else s7523-  s7525 :: SWord1 = choose [0:0] s721-  s7526 :: SBool = s15 /= s7525-  s7527 :: SWord8 = if s7526 then s7522 else s7523-  s7528 :: SWord8 = if s702 then s7524 else s7527-  s7529 :: SWord1 = choose [0:0] s744-  s7530 :: SBool = s15 /= s7529-  s7531 :: SWord8 = if s18 then s752 else s733-  s7532 :: SWord8 = s7531 >>> 1-  s7533 :: SWord8 = s20 | s7532-  s7534 :: SWord8 = s22 & s7532-  s7535 :: SWord8 = if s7530 then s7533 else s7534-  s7536 :: SWord1 = choose [0:0] s755-  s7537 :: SBool = s15 /= s7536-  s7538 :: SWord8 = if s7537 then s7533 else s7534-  s7539 :: SWord8 = if s737 then s7535 else s7538-  s7540 :: SWord8 = if s680 then s7528 else s7539-  s7541 :: SWord8 = if s564 then s7517 else s7540-  s7542 :: SWord1 = choose [0:0] s820-  s7543 :: SBool = s15 /= s7542-  s7544 :: SWord8 = if s18 then s830 else s812-  s7545 :: SWord8 = s7544 >>> 1-  s7546 :: SWord8 = s20 | s7545-  s7547 :: SWord8 = s22 & s7545-  s7548 :: SWord8 = if s7543 then s7546 else s7547-  s7549 :: SWord1 = choose [0:0] s837-  s7550 :: SBool = s15 /= s7549-  s7551 :: SWord8 = if s7550 then s7546 else s7547-  s7552 :: SWord8 = if s816 then s7548 else s7551-  s7553 :: SWord1 = choose [0:0] s860-  s7554 :: SBool = s15 /= s7553-  s7555 :: SWord8 = if s18 then s868 else s849-  s7556 :: SWord8 = s7555 >>> 1-  s7557 :: SWord8 = s20 | s7556-  s7558 :: SWord8 = s22 & s7556-  s7559 :: SWord8 = if s7554 then s7557 else s7558-  s7560 :: SWord1 = choose [0:0] s871-  s7561 :: SBool = s15 /= s7560-  s7562 :: SWord8 = if s7561 then s7557 else s7558-  s7563 :: SWord8 = if s853 then s7559 else s7562-  s7564 :: SWord8 = if s795 then s7552 else s7563-  s7565 :: SWord1 = choose [0:0] s914-  s7566 :: SBool = s15 /= s7565-  s7567 :: SWord8 = if s18 then s924 else s906-  s7568 :: SWord8 = s7567 >>> 1-  s7569 :: SWord8 = s20 | s7568-  s7570 :: SWord8 = s22 & s7568-  s7571 :: SWord8 = if s7566 then s7569 else s7570-  s7572 :: SWord1 = choose [0:0] s929-  s7573 :: SBool = s15 /= s7572-  s7574 :: SWord8 = if s7573 then s7569 else s7570-  s7575 :: SWord8 = if s910 then s7571 else s7574-  s7576 :: SWord1 = choose [0:0] s952-  s7577 :: SBool = s15 /= s7576-  s7578 :: SWord8 = if s18 then s960 else s941-  s7579 :: SWord8 = s7578 >>> 1-  s7580 :: SWord8 = s20 | s7579-  s7581 :: SWord8 = s22 & s7579-  s7582 :: SWord8 = if s7577 then s7580 else s7581-  s7583 :: SWord1 = choose [0:0] s963-  s7584 :: SBool = s15 /= s7583-  s7585 :: SWord8 = if s7584 then s7580 else s7581-  s7586 :: SWord8 = if s945 then s7582 else s7585-  s7587 :: SWord8 = if s888 then s7575 else s7586-  s7588 :: SWord8 = if s773 then s7564 else s7587-  s7589 :: SWord8 = if s542 then s7541 else s7588-  s7590 :: SWord8 = if s73 then s7494 else s7589-  s7591 :: SWord1 = choose [0:0] s1072-  s7592 :: SBool = s15 /= s7591-  s7593 :: SWord8 = if s18 then s1082 else s1064-  s7594 :: SWord8 = s7593 >>> 1-  s7595 :: SWord8 = s20 | s7594-  s7596 :: SWord8 = s22 & s7594-  s7597 :: SWord8 = if s7592 then s7595 else s7596-  s7598 :: SWord1 = choose [0:0] s1093-  s7599 :: SBool = s15 /= s7598-  s7600 :: SWord8 = if s7599 then s7595 else s7596-  s7601 :: SWord8 = if s1068 then s7597 else s7600-  s7602 :: SWord1 = choose [0:0] s1116-  s7603 :: SBool = s15 /= s7602-  s7604 :: SWord8 = if s18 then s1124 else s1105-  s7605 :: SWord8 = s7604 >>> 1-  s7606 :: SWord8 = s20 | s7605-  s7607 :: SWord8 = s22 & s7605-  s7608 :: SWord8 = if s7603 then s7606 else s7607-  s7609 :: SWord1 = choose [0:0] s1127-  s7610 :: SBool = s15 /= s7609-  s7611 :: SWord8 = if s7610 then s7606 else s7607-  s7612 :: SWord8 = if s1109 then s7608 else s7611-  s7613 :: SWord8 = if s1047 then s7601 else s7612-  s7614 :: SWord1 = choose [0:0] s1170-  s7615 :: SBool = s15 /= s7614-  s7616 :: SWord8 = if s18 then s1180 else s1162-  s7617 :: SWord8 = s7616 >>> 1-  s7618 :: SWord8 = s20 | s7617-  s7619 :: SWord8 = s22 & s7617-  s7620 :: SWord8 = if s7615 then s7618 else s7619-  s7621 :: SWord1 = choose [0:0] s1185-  s7622 :: SBool = s15 /= s7621-  s7623 :: SWord8 = if s7622 then s7618 else s7619-  s7624 :: SWord8 = if s1166 then s7620 else s7623-  s7625 :: SWord1 = choose [0:0] s1208-  s7626 :: SBool = s15 /= s7625-  s7627 :: SWord8 = if s18 then s1216 else s1197-  s7628 :: SWord8 = s7627 >>> 1-  s7629 :: SWord8 = s20 | s7628-  s7630 :: SWord8 = s22 & s7628-  s7631 :: SWord8 = if s7626 then s7629 else s7630-  s7632 :: SWord1 = choose [0:0] s1219-  s7633 :: SBool = s15 /= s7632-  s7634 :: SWord8 = if s7633 then s7629 else s7630-  s7635 :: SWord8 = if s1201 then s7631 else s7634-  s7636 :: SWord8 = if s1144 then s7624 else s7635-  s7637 :: SWord8 = if s1026 then s7613 else s7636-  s7638 :: SWord1 = choose [0:0] s1284-  s7639 :: SBool = s15 /= s7638-  s7640 :: SWord8 = if s18 then s1294 else s1276-  s7641 :: SWord8 = s7640 >>> 1-  s7642 :: SWord8 = s20 | s7641-  s7643 :: SWord8 = s22 & s7641-  s7644 :: SWord8 = if s7639 then s7642 else s7643-  s7645 :: SWord1 = choose [0:0] s1301-  s7646 :: SBool = s15 /= s7645-  s7647 :: SWord8 = if s7646 then s7642 else s7643-  s7648 :: SWord8 = if s1280 then s7644 else s7647-  s7649 :: SWord1 = choose [0:0] s1324-  s7650 :: SBool = s15 /= s7649-  s7651 :: SWord8 = if s18 then s1332 else s1313-  s7652 :: SWord8 = s7651 >>> 1-  s7653 :: SWord8 = s20 | s7652-  s7654 :: SWord8 = s22 & s7652-  s7655 :: SWord8 = if s7650 then s7653 else s7654-  s7656 :: SWord1 = choose [0:0] s1335-  s7657 :: SBool = s15 /= s7656-  s7658 :: SWord8 = if s7657 then s7653 else s7654-  s7659 :: SWord8 = if s1317 then s7655 else s7658-  s7660 :: SWord8 = if s1259 then s7648 else s7659-  s7661 :: SWord1 = choose [0:0] s1378-  s7662 :: SBool = s15 /= s7661-  s7663 :: SWord8 = if s18 then s1388 else s1370-  s7664 :: SWord8 = s7663 >>> 1-  s7665 :: SWord8 = s20 | s7664-  s7666 :: SWord8 = s22 & s7664-  s7667 :: SWord8 = if s7662 then s7665 else s7666-  s7668 :: SWord1 = choose [0:0] s1393-  s7669 :: SBool = s15 /= s7668-  s7670 :: SWord8 = if s7669 then s7665 else s7666-  s7671 :: SWord8 = if s1374 then s7667 else s7670-  s7672 :: SWord1 = choose [0:0] s1416-  s7673 :: SBool = s15 /= s7672-  s7674 :: SWord8 = if s18 then s1424 else s1405-  s7675 :: SWord8 = s7674 >>> 1-  s7676 :: SWord8 = s20 | s7675-  s7677 :: SWord8 = s22 & s7675-  s7678 :: SWord8 = if s7673 then s7676 else s7677-  s7679 :: SWord1 = choose [0:0] s1427-  s7680 :: SBool = s15 /= s7679-  s7681 :: SWord8 = if s7680 then s7676 else s7677-  s7682 :: SWord8 = if s1409 then s7678 else s7681-  s7683 :: SWord8 = if s1352 then s7671 else s7682-  s7684 :: SWord8 = if s1237 then s7660 else s7683-  s7685 :: SWord8 = if s1005 then s7637 else s7684-  s7686 :: SWord1 = choose [0:0] s1514-  s7687 :: SBool = s15 /= s7686-  s7688 :: SWord8 = if s18 then s1524 else s1506-  s7689 :: SWord8 = s7688 >>> 1-  s7690 :: SWord8 = s20 | s7689-  s7691 :: SWord8 = s22 & s7689-  s7692 :: SWord8 = if s7687 then s7690 else s7691-  s7693 :: SWord1 = choose [0:0] s1533-  s7694 :: SBool = s15 /= s7693-  s7695 :: SWord8 = if s7694 then s7690 else s7691-  s7696 :: SWord8 = if s1510 then s7692 else s7695-  s7697 :: SWord1 = choose [0:0] s1556-  s7698 :: SBool = s15 /= s7697-  s7699 :: SWord8 = if s18 then s1564 else s1545-  s7700 :: SWord8 = s7699 >>> 1-  s7701 :: SWord8 = s20 | s7700-  s7702 :: SWord8 = s22 & s7700-  s7703 :: SWord8 = if s7698 then s7701 else s7702-  s7704 :: SWord1 = choose [0:0] s1567-  s7705 :: SBool = s15 /= s7704-  s7706 :: SWord8 = if s7705 then s7701 else s7702-  s7707 :: SWord8 = if s1549 then s7703 else s7706-  s7708 :: SWord8 = if s1489 then s7696 else s7707-  s7709 :: SWord1 = choose [0:0] s1610-  s7710 :: SBool = s15 /= s7709-  s7711 :: SWord8 = if s18 then s1620 else s1602-  s7712 :: SWord8 = s7711 >>> 1-  s7713 :: SWord8 = s20 | s7712-  s7714 :: SWord8 = s22 & s7712-  s7715 :: SWord8 = if s7710 then s7713 else s7714-  s7716 :: SWord1 = choose [0:0] s1625-  s7717 :: SBool = s15 /= s7716-  s7718 :: SWord8 = if s7717 then s7713 else s7714-  s7719 :: SWord8 = if s1606 then s7715 else s7718-  s7720 :: SWord1 = choose [0:0] s1648-  s7721 :: SBool = s15 /= s7720-  s7722 :: SWord8 = if s18 then s1656 else s1637-  s7723 :: SWord8 = s7722 >>> 1-  s7724 :: SWord8 = s20 | s7723-  s7725 :: SWord8 = s22 & s7723-  s7726 :: SWord8 = if s7721 then s7724 else s7725-  s7727 :: SWord1 = choose [0:0] s1659-  s7728 :: SBool = s15 /= s7727-  s7729 :: SWord8 = if s7728 then s7724 else s7725-  s7730 :: SWord8 = if s1641 then s7726 else s7729-  s7731 :: SWord8 = if s1584 then s7719 else s7730-  s7732 :: SWord8 = if s1468 then s7708 else s7731-  s7733 :: SWord1 = choose [0:0] s1724-  s7734 :: SBool = s15 /= s7733-  s7735 :: SWord8 = if s18 then s1734 else s1716-  s7736 :: SWord8 = s7735 >>> 1-  s7737 :: SWord8 = s20 | s7736-  s7738 :: SWord8 = s22 & s7736-  s7739 :: SWord8 = if s7734 then s7737 else s7738-  s7740 :: SWord1 = choose [0:0] s1741-  s7741 :: SBool = s15 /= s7740-  s7742 :: SWord8 = if s7741 then s7737 else s7738-  s7743 :: SWord8 = if s1720 then s7739 else s7742-  s7744 :: SWord1 = choose [0:0] s1764-  s7745 :: SBool = s15 /= s7744-  s7746 :: SWord8 = if s18 then s1772 else s1753-  s7747 :: SWord8 = s7746 >>> 1-  s7748 :: SWord8 = s20 | s7747-  s7749 :: SWord8 = s22 & s7747-  s7750 :: SWord8 = if s7745 then s7748 else s7749-  s7751 :: SWord1 = choose [0:0] s1775-  s7752 :: SBool = s15 /= s7751-  s7753 :: SWord8 = if s7752 then s7748 else s7749-  s7754 :: SWord8 = if s1757 then s7750 else s7753-  s7755 :: SWord8 = if s1699 then s7743 else s7754-  s7756 :: SWord1 = choose [0:0] s1818-  s7757 :: SBool = s15 /= s7756-  s7758 :: SWord8 = if s18 then s1828 else s1810-  s7759 :: SWord8 = s7758 >>> 1-  s7760 :: SWord8 = s20 | s7759-  s7761 :: SWord8 = s22 & s7759-  s7762 :: SWord8 = if s7757 then s7760 else s7761-  s7763 :: SWord1 = choose [0:0] s1833-  s7764 :: SBool = s15 /= s7763-  s7765 :: SWord8 = if s7764 then s7760 else s7761-  s7766 :: SWord8 = if s1814 then s7762 else s7765-  s7767 :: SWord1 = choose [0:0] s1856-  s7768 :: SBool = s15 /= s7767-  s7769 :: SWord8 = if s18 then s1864 else s1845-  s7770 :: SWord8 = s7769 >>> 1-  s7771 :: SWord8 = s20 | s7770-  s7772 :: SWord8 = s22 & s7770-  s7773 :: SWord8 = if s7768 then s7771 else s7772-  s7774 :: SWord1 = choose [0:0] s1867-  s7775 :: SBool = s15 /= s7774-  s7776 :: SWord8 = if s7775 then s7771 else s7772-  s7777 :: SWord8 = if s1849 then s7773 else s7776-  s7778 :: SWord8 = if s1792 then s7766 else s7777-  s7779 :: SWord8 = if s1677 then s7755 else s7778-  s7780 :: SWord8 = if s1446 then s7732 else s7779-  s7781 :: SWord8 = if s983 then s7685 else s7780-  s7782 :: SWord8 = if s52 then s7590 else s7781-  s7783 :: SWord1 = choose [0:0] s1998-  s7784 :: SBool = s15 /= s7783-  s7785 :: SWord8 = if s18 then s2008 else s1990-  s7786 :: SWord8 = s7785 >>> 1-  s7787 :: SWord8 = s20 | s7786-  s7788 :: SWord8 = s22 & s7786-  s7789 :: SWord8 = if s7784 then s7787 else s7788-  s7790 :: SWord1 = choose [0:0] s2021-  s7791 :: SBool = s15 /= s7790-  s7792 :: SWord8 = if s7791 then s7787 else s7788-  s7793 :: SWord8 = if s1994 then s7789 else s7792-  s7794 :: SWord1 = choose [0:0] s2044-  s7795 :: SBool = s15 /= s7794-  s7796 :: SWord8 = if s18 then s2052 else s2033-  s7797 :: SWord8 = s7796 >>> 1-  s7798 :: SWord8 = s20 | s7797-  s7799 :: SWord8 = s22 & s7797-  s7800 :: SWord8 = if s7795 then s7798 else s7799-  s7801 :: SWord1 = choose [0:0] s2055-  s7802 :: SBool = s15 /= s7801-  s7803 :: SWord8 = if s7802 then s7798 else s7799-  s7804 :: SWord8 = if s2037 then s7800 else s7803-  s7805 :: SWord8 = if s1973 then s7793 else s7804-  s7806 :: SWord1 = choose [0:0] s2098-  s7807 :: SBool = s15 /= s7806-  s7808 :: SWord8 = if s18 then s2108 else s2090-  s7809 :: SWord8 = s7808 >>> 1-  s7810 :: SWord8 = s20 | s7809-  s7811 :: SWord8 = s22 & s7809-  s7812 :: SWord8 = if s7807 then s7810 else s7811-  s7813 :: SWord1 = choose [0:0] s2113-  s7814 :: SBool = s15 /= s7813-  s7815 :: SWord8 = if s7814 then s7810 else s7811-  s7816 :: SWord8 = if s2094 then s7812 else s7815-  s7817 :: SWord1 = choose [0:0] s2136-  s7818 :: SBool = s15 /= s7817-  s7819 :: SWord8 = if s18 then s2144 else s2125-  s7820 :: SWord8 = s7819 >>> 1-  s7821 :: SWord8 = s20 | s7820-  s7822 :: SWord8 = s22 & s7820-  s7823 :: SWord8 = if s7818 then s7821 else s7822-  s7824 :: SWord1 = choose [0:0] s2147-  s7825 :: SBool = s15 /= s7824-  s7826 :: SWord8 = if s7825 then s7821 else s7822-  s7827 :: SWord8 = if s2129 then s7823 else s7826-  s7828 :: SWord8 = if s2072 then s7816 else s7827-  s7829 :: SWord8 = if s1952 then s7805 else s7828-  s7830 :: SWord1 = choose [0:0] s2212-  s7831 :: SBool = s15 /= s7830-  s7832 :: SWord8 = if s18 then s2222 else s2204-  s7833 :: SWord8 = s7832 >>> 1-  s7834 :: SWord8 = s20 | s7833-  s7835 :: SWord8 = s22 & s7833-  s7836 :: SWord8 = if s7831 then s7834 else s7835-  s7837 :: SWord1 = choose [0:0] s2229-  s7838 :: SBool = s15 /= s7837-  s7839 :: SWord8 = if s7838 then s7834 else s7835-  s7840 :: SWord8 = if s2208 then s7836 else s7839-  s7841 :: SWord1 = choose [0:0] s2252-  s7842 :: SBool = s15 /= s7841-  s7843 :: SWord8 = if s18 then s2260 else s2241-  s7844 :: SWord8 = s7843 >>> 1-  s7845 :: SWord8 = s20 | s7844-  s7846 :: SWord8 = s22 & s7844-  s7847 :: SWord8 = if s7842 then s7845 else s7846-  s7848 :: SWord1 = choose [0:0] s2263-  s7849 :: SBool = s15 /= s7848-  s7850 :: SWord8 = if s7849 then s7845 else s7846-  s7851 :: SWord8 = if s2245 then s7847 else s7850-  s7852 :: SWord8 = if s2187 then s7840 else s7851-  s7853 :: SWord1 = choose [0:0] s2306-  s7854 :: SBool = s15 /= s7853-  s7855 :: SWord8 = if s18 then s2316 else s2298-  s7856 :: SWord8 = s7855 >>> 1-  s7857 :: SWord8 = s20 | s7856-  s7858 :: SWord8 = s22 & s7856-  s7859 :: SWord8 = if s7854 then s7857 else s7858-  s7860 :: SWord1 = choose [0:0] s2321-  s7861 :: SBool = s15 /= s7860-  s7862 :: SWord8 = if s7861 then s7857 else s7858-  s7863 :: SWord8 = if s2302 then s7859 else s7862-  s7864 :: SWord1 = choose [0:0] s2344-  s7865 :: SBool = s15 /= s7864-  s7866 :: SWord8 = if s18 then s2352 else s2333-  s7867 :: SWord8 = s7866 >>> 1-  s7868 :: SWord8 = s20 | s7867-  s7869 :: SWord8 = s22 & s7867-  s7870 :: SWord8 = if s7865 then s7868 else s7869-  s7871 :: SWord1 = choose [0:0] s2355-  s7872 :: SBool = s15 /= s7871-  s7873 :: SWord8 = if s7872 then s7868 else s7869-  s7874 :: SWord8 = if s2337 then s7870 else s7873-  s7875 :: SWord8 = if s2280 then s7863 else s7874-  s7876 :: SWord8 = if s2165 then s7852 else s7875-  s7877 :: SWord8 = if s1931 then s7829 else s7876-  s7878 :: SWord1 = choose [0:0] s2442-  s7879 :: SBool = s15 /= s7878-  s7880 :: SWord8 = if s18 then s2452 else s2434-  s7881 :: SWord8 = s7880 >>> 1-  s7882 :: SWord8 = s20 | s7881-  s7883 :: SWord8 = s22 & s7881-  s7884 :: SWord8 = if s7879 then s7882 else s7883-  s7885 :: SWord1 = choose [0:0] s2461-  s7886 :: SBool = s15 /= s7885-  s7887 :: SWord8 = if s7886 then s7882 else s7883-  s7888 :: SWord8 = if s2438 then s7884 else s7887-  s7889 :: SWord1 = choose [0:0] s2484-  s7890 :: SBool = s15 /= s7889-  s7891 :: SWord8 = if s18 then s2492 else s2473-  s7892 :: SWord8 = s7891 >>> 1-  s7893 :: SWord8 = s20 | s7892-  s7894 :: SWord8 = s22 & s7892-  s7895 :: SWord8 = if s7890 then s7893 else s7894-  s7896 :: SWord1 = choose [0:0] s2495-  s7897 :: SBool = s15 /= s7896-  s7898 :: SWord8 = if s7897 then s7893 else s7894-  s7899 :: SWord8 = if s2477 then s7895 else s7898-  s7900 :: SWord8 = if s2417 then s7888 else s7899-  s7901 :: SWord1 = choose [0:0] s2538-  s7902 :: SBool = s15 /= s7901-  s7903 :: SWord8 = if s18 then s2548 else s2530-  s7904 :: SWord8 = s7903 >>> 1-  s7905 :: SWord8 = s20 | s7904-  s7906 :: SWord8 = s22 & s7904-  s7907 :: SWord8 = if s7902 then s7905 else s7906-  s7908 :: SWord1 = choose [0:0] s2553-  s7909 :: SBool = s15 /= s7908-  s7910 :: SWord8 = if s7909 then s7905 else s7906-  s7911 :: SWord8 = if s2534 then s7907 else s7910-  s7912 :: SWord1 = choose [0:0] s2576-  s7913 :: SBool = s15 /= s7912-  s7914 :: SWord8 = if s18 then s2584 else s2565-  s7915 :: SWord8 = s7914 >>> 1-  s7916 :: SWord8 = s20 | s7915-  s7917 :: SWord8 = s22 & s7915-  s7918 :: SWord8 = if s7913 then s7916 else s7917-  s7919 :: SWord1 = choose [0:0] s2587-  s7920 :: SBool = s15 /= s7919-  s7921 :: SWord8 = if s7920 then s7916 else s7917-  s7922 :: SWord8 = if s2569 then s7918 else s7921-  s7923 :: SWord8 = if s2512 then s7911 else s7922-  s7924 :: SWord8 = if s2396 then s7900 else s7923-  s7925 :: SWord1 = choose [0:0] s2652-  s7926 :: SBool = s15 /= s7925-  s7927 :: SWord8 = if s18 then s2662 else s2644-  s7928 :: SWord8 = s7927 >>> 1-  s7929 :: SWord8 = s20 | s7928-  s7930 :: SWord8 = s22 & s7928-  s7931 :: SWord8 = if s7926 then s7929 else s7930-  s7932 :: SWord1 = choose [0:0] s2669-  s7933 :: SBool = s15 /= s7932-  s7934 :: SWord8 = if s7933 then s7929 else s7930-  s7935 :: SWord8 = if s2648 then s7931 else s7934-  s7936 :: SWord1 = choose [0:0] s2692-  s7937 :: SBool = s15 /= s7936-  s7938 :: SWord8 = if s18 then s2700 else s2681-  s7939 :: SWord8 = s7938 >>> 1-  s7940 :: SWord8 = s20 | s7939-  s7941 :: SWord8 = s22 & s7939-  s7942 :: SWord8 = if s7937 then s7940 else s7941-  s7943 :: SWord1 = choose [0:0] s2703-  s7944 :: SBool = s15 /= s7943-  s7945 :: SWord8 = if s7944 then s7940 else s7941-  s7946 :: SWord8 = if s2685 then s7942 else s7945-  s7947 :: SWord8 = if s2627 then s7935 else s7946-  s7948 :: SWord1 = choose [0:0] s2746-  s7949 :: SBool = s15 /= s7948-  s7950 :: SWord8 = if s18 then s2756 else s2738-  s7951 :: SWord8 = s7950 >>> 1-  s7952 :: SWord8 = s20 | s7951-  s7953 :: SWord8 = s22 & s7951-  s7954 :: SWord8 = if s7949 then s7952 else s7953-  s7955 :: SWord1 = choose [0:0] s2761-  s7956 :: SBool = s15 /= s7955-  s7957 :: SWord8 = if s7956 then s7952 else s7953-  s7958 :: SWord8 = if s2742 then s7954 else s7957-  s7959 :: SWord1 = choose [0:0] s2784-  s7960 :: SBool = s15 /= s7959-  s7961 :: SWord8 = if s18 then s2792 else s2773-  s7962 :: SWord8 = s7961 >>> 1-  s7963 :: SWord8 = s20 | s7962-  s7964 :: SWord8 = s22 & s7962-  s7965 :: SWord8 = if s7960 then s7963 else s7964-  s7966 :: SWord1 = choose [0:0] s2795-  s7967 :: SBool = s15 /= s7966-  s7968 :: SWord8 = if s7967 then s7963 else s7964-  s7969 :: SWord8 = if s2777 then s7965 else s7968-  s7970 :: SWord8 = if s2720 then s7958 else s7969-  s7971 :: SWord8 = if s2605 then s7947 else s7970-  s7972 :: SWord8 = if s2374 then s7924 else s7971-  s7973 :: SWord8 = if s1910 then s7877 else s7972-  s7974 :: SWord1 = choose [0:0] s2904-  s7975 :: SBool = s15 /= s7974-  s7976 :: SWord8 = if s18 then s2914 else s2896-  s7977 :: SWord8 = s7976 >>> 1-  s7978 :: SWord8 = s20 | s7977-  s7979 :: SWord8 = s22 & s7977-  s7980 :: SWord8 = if s7975 then s7978 else s7979-  s7981 :: SWord1 = choose [0:0] s2925-  s7982 :: SBool = s15 /= s7981-  s7983 :: SWord8 = if s7982 then s7978 else s7979-  s7984 :: SWord8 = if s2900 then s7980 else s7983-  s7985 :: SWord1 = choose [0:0] s2948-  s7986 :: SBool = s15 /= s7985-  s7987 :: SWord8 = if s18 then s2956 else s2937-  s7988 :: SWord8 = s7987 >>> 1-  s7989 :: SWord8 = s20 | s7988-  s7990 :: SWord8 = s22 & s7988-  s7991 :: SWord8 = if s7986 then s7989 else s7990-  s7992 :: SWord1 = choose [0:0] s2959-  s7993 :: SBool = s15 /= s7992-  s7994 :: SWord8 = if s7993 then s7989 else s7990-  s7995 :: SWord8 = if s2941 then s7991 else s7994-  s7996 :: SWord8 = if s2879 then s7984 else s7995-  s7997 :: SWord1 = choose [0:0] s3002-  s7998 :: SBool = s15 /= s7997-  s7999 :: SWord8 = if s18 then s3012 else s2994-  s8000 :: SWord8 = s7999 >>> 1-  s8001 :: SWord8 = s20 | s8000-  s8002 :: SWord8 = s22 & s8000-  s8003 :: SWord8 = if s7998 then s8001 else s8002-  s8004 :: SWord1 = choose [0:0] s3017-  s8005 :: SBool = s15 /= s8004-  s8006 :: SWord8 = if s8005 then s8001 else s8002-  s8007 :: SWord8 = if s2998 then s8003 else s8006-  s8008 :: SWord1 = choose [0:0] s3040-  s8009 :: SBool = s15 /= s8008-  s8010 :: SWord8 = if s18 then s3048 else s3029-  s8011 :: SWord8 = s8010 >>> 1-  s8012 :: SWord8 = s20 | s8011-  s8013 :: SWord8 = s22 & s8011-  s8014 :: SWord8 = if s8009 then s8012 else s8013-  s8015 :: SWord1 = choose [0:0] s3051-  s8016 :: SBool = s15 /= s8015-  s8017 :: SWord8 = if s8016 then s8012 else s8013-  s8018 :: SWord8 = if s3033 then s8014 else s8017-  s8019 :: SWord8 = if s2976 then s8007 else s8018-  s8020 :: SWord8 = if s2858 then s7996 else s8019-  s8021 :: SWord1 = choose [0:0] s3116-  s8022 :: SBool = s15 /= s8021-  s8023 :: SWord8 = if s18 then s3126 else s3108-  s8024 :: SWord8 = s8023 >>> 1-  s8025 :: SWord8 = s20 | s8024-  s8026 :: SWord8 = s22 & s8024-  s8027 :: SWord8 = if s8022 then s8025 else s8026-  s8028 :: SWord1 = choose [0:0] s3133-  s8029 :: SBool = s15 /= s8028-  s8030 :: SWord8 = if s8029 then s8025 else s8026-  s8031 :: SWord8 = if s3112 then s8027 else s8030-  s8032 :: SWord1 = choose [0:0] s3156-  s8033 :: SBool = s15 /= s8032-  s8034 :: SWord8 = if s18 then s3164 else s3145-  s8035 :: SWord8 = s8034 >>> 1-  s8036 :: SWord8 = s20 | s8035-  s8037 :: SWord8 = s22 & s8035-  s8038 :: SWord8 = if s8033 then s8036 else s8037-  s8039 :: SWord1 = choose [0:0] s3167-  s8040 :: SBool = s15 /= s8039-  s8041 :: SWord8 = if s8040 then s8036 else s8037-  s8042 :: SWord8 = if s3149 then s8038 else s8041-  s8043 :: SWord8 = if s3091 then s8031 else s8042-  s8044 :: SWord1 = choose [0:0] s3210-  s8045 :: SBool = s15 /= s8044-  s8046 :: SWord8 = if s18 then s3220 else s3202-  s8047 :: SWord8 = s8046 >>> 1-  s8048 :: SWord8 = s20 | s8047-  s8049 :: SWord8 = s22 & s8047-  s8050 :: SWord8 = if s8045 then s8048 else s8049-  s8051 :: SWord1 = choose [0:0] s3225-  s8052 :: SBool = s15 /= s8051-  s8053 :: SWord8 = if s8052 then s8048 else s8049-  s8054 :: SWord8 = if s3206 then s8050 else s8053-  s8055 :: SWord1 = choose [0:0] s3248-  s8056 :: SBool = s15 /= s8055-  s8057 :: SWord8 = if s18 then s3256 else s3237-  s8058 :: SWord8 = s8057 >>> 1-  s8059 :: SWord8 = s20 | s8058-  s8060 :: SWord8 = s22 & s8058-  s8061 :: SWord8 = if s8056 then s8059 else s8060-  s8062 :: SWord1 = choose [0:0] s3259-  s8063 :: SBool = s15 /= s8062-  s8064 :: SWord8 = if s8063 then s8059 else s8060-  s8065 :: SWord8 = if s3241 then s8061 else s8064-  s8066 :: SWord8 = if s3184 then s8054 else s8065-  s8067 :: SWord8 = if s3069 then s8043 else s8066-  s8068 :: SWord8 = if s2837 then s8020 else s8067-  s8069 :: SWord1 = choose [0:0] s3346-  s8070 :: SBool = s15 /= s8069-  s8071 :: SWord8 = if s18 then s3356 else s3338-  s8072 :: SWord8 = s8071 >>> 1-  s8073 :: SWord8 = s20 | s8072-  s8074 :: SWord8 = s22 & s8072-  s8075 :: SWord8 = if s8070 then s8073 else s8074-  s8076 :: SWord1 = choose [0:0] s3365-  s8077 :: SBool = s15 /= s8076-  s8078 :: SWord8 = if s8077 then s8073 else s8074-  s8079 :: SWord8 = if s3342 then s8075 else s8078-  s8080 :: SWord1 = choose [0:0] s3388-  s8081 :: SBool = s15 /= s8080-  s8082 :: SWord8 = if s18 then s3396 else s3377-  s8083 :: SWord8 = s8082 >>> 1-  s8084 :: SWord8 = s20 | s8083-  s8085 :: SWord8 = s22 & s8083-  s8086 :: SWord8 = if s8081 then s8084 else s8085-  s8087 :: SWord1 = choose [0:0] s3399-  s8088 :: SBool = s15 /= s8087-  s8089 :: SWord8 = if s8088 then s8084 else s8085-  s8090 :: SWord8 = if s3381 then s8086 else s8089-  s8091 :: SWord8 = if s3321 then s8079 else s8090-  s8092 :: SWord1 = choose [0:0] s3442-  s8093 :: SBool = s15 /= s8092-  s8094 :: SWord8 = if s18 then s3452 else s3434-  s8095 :: SWord8 = s8094 >>> 1-  s8096 :: SWord8 = s20 | s8095-  s8097 :: SWord8 = s22 & s8095-  s8098 :: SWord8 = if s8093 then s8096 else s8097-  s8099 :: SWord1 = choose [0:0] s3457-  s8100 :: SBool = s15 /= s8099-  s8101 :: SWord8 = if s8100 then s8096 else s8097-  s8102 :: SWord8 = if s3438 then s8098 else s8101-  s8103 :: SWord1 = choose [0:0] s3480-  s8104 :: SBool = s15 /= s8103-  s8105 :: SWord8 = if s18 then s3488 else s3469-  s8106 :: SWord8 = s8105 >>> 1-  s8107 :: SWord8 = s20 | s8106-  s8108 :: SWord8 = s22 & s8106-  s8109 :: SWord8 = if s8104 then s8107 else s8108-  s8110 :: SWord1 = choose [0:0] s3491-  s8111 :: SBool = s15 /= s8110-  s8112 :: SWord8 = if s8111 then s8107 else s8108-  s8113 :: SWord8 = if s3473 then s8109 else s8112-  s8114 :: SWord8 = if s3416 then s8102 else s8113-  s8115 :: SWord8 = if s3300 then s8091 else s8114-  s8116 :: SWord1 = choose [0:0] s3556-  s8117 :: SBool = s15 /= s8116-  s8118 :: SWord8 = if s18 then s3566 else s3548-  s8119 :: SWord8 = s8118 >>> 1-  s8120 :: SWord8 = s20 | s8119-  s8121 :: SWord8 = s22 & s8119-  s8122 :: SWord8 = if s8117 then s8120 else s8121-  s8123 :: SWord1 = choose [0:0] s3573-  s8124 :: SBool = s15 /= s8123-  s8125 :: SWord8 = if s8124 then s8120 else s8121-  s8126 :: SWord8 = if s3552 then s8122 else s8125-  s8127 :: SWord1 = choose [0:0] s3596-  s8128 :: SBool = s15 /= s8127-  s8129 :: SWord8 = if s18 then s3604 else s3585-  s8130 :: SWord8 = s8129 >>> 1-  s8131 :: SWord8 = s20 | s8130-  s8132 :: SWord8 = s22 & s8130-  s8133 :: SWord8 = if s8128 then s8131 else s8132-  s8134 :: SWord1 = choose [0:0] s3607-  s8135 :: SBool = s15 /= s8134-  s8136 :: SWord8 = if s8135 then s8131 else s8132-  s8137 :: SWord8 = if s3589 then s8133 else s8136-  s8138 :: SWord8 = if s3531 then s8126 else s8137-  s8139 :: SWord1 = choose [0:0] s3650-  s8140 :: SBool = s15 /= s8139-  s8141 :: SWord8 = if s18 then s3660 else s3642-  s8142 :: SWord8 = s8141 >>> 1-  s8143 :: SWord8 = s20 | s8142-  s8144 :: SWord8 = s22 & s8142-  s8145 :: SWord8 = if s8140 then s8143 else s8144-  s8146 :: SWord1 = choose [0:0] s3665-  s8147 :: SBool = s15 /= s8146-  s8148 :: SWord8 = if s8147 then s8143 else s8144-  s8149 :: SWord8 = if s3646 then s8145 else s8148-  s8150 :: SWord1 = choose [0:0] s3688-  s8151 :: SBool = s15 /= s8150-  s8152 :: SWord8 = if s18 then s3696 else s3677-  s8153 :: SWord8 = s8152 >>> 1-  s8154 :: SWord8 = s20 | s8153-  s8155 :: SWord8 = s22 & s8153-  s8156 :: SWord8 = if s8151 then s8154 else s8155-  s8157 :: SWord1 = choose [0:0] s3699-  s8158 :: SBool = s15 /= s8157-  s8159 :: SWord8 = if s8158 then s8154 else s8155-  s8160 :: SWord8 = if s3681 then s8156 else s8159-  s8161 :: SWord8 = if s3624 then s8149 else s8160-  s8162 :: SWord8 = if s3509 then s8138 else s8161-  s8163 :: SWord8 = if s3278 then s8115 else s8162-  s8164 :: SWord8 = if s2815 then s8068 else s8163-  s8165 :: SWord8 = if s1888 then s7973 else s8164-  s8166 :: SWord8 = if s34 then s7782 else s8165-  s8167 :: SWord1 = choose [0:0] s3847-  s8168 :: SBool = s15 /= s8167-  s8169 :: SWord8 = if s18 then s3857 else s3839-  s8170 :: SWord8 = s8169 >>> 1-  s8171 :: SWord8 = s20 | s8170-  s8172 :: SWord8 = s22 & s8170-  s8173 :: SWord8 = if s8168 then s8171 else s8172-  s8174 :: SWord1 = choose [0:0] s3872-  s8175 :: SBool = s15 /= s8174-  s8176 :: SWord8 = if s8175 then s8171 else s8172-  s8177 :: SWord8 = if s3843 then s8173 else s8176-  s8178 :: SWord1 = choose [0:0] s3895-  s8179 :: SBool = s15 /= s8178-  s8180 :: SWord8 = if s18 then s3903 else s3884-  s8181 :: SWord8 = s8180 >>> 1-  s8182 :: SWord8 = s20 | s8181-  s8183 :: SWord8 = s22 & s8181-  s8184 :: SWord8 = if s8179 then s8182 else s8183-  s8185 :: SWord1 = choose [0:0] s3906-  s8186 :: SBool = s15 /= s8185-  s8187 :: SWord8 = if s8186 then s8182 else s8183-  s8188 :: SWord8 = if s3888 then s8184 else s8187-  s8189 :: SWord8 = if s3822 then s8177 else s8188-  s8190 :: SWord1 = choose [0:0] s3949-  s8191 :: SBool = s15 /= s8190-  s8192 :: SWord8 = if s18 then s3959 else s3941-  s8193 :: SWord8 = s8192 >>> 1-  s8194 :: SWord8 = s20 | s8193-  s8195 :: SWord8 = s22 & s8193-  s8196 :: SWord8 = if s8191 then s8194 else s8195-  s8197 :: SWord1 = choose [0:0] s3964-  s8198 :: SBool = s15 /= s8197-  s8199 :: SWord8 = if s8198 then s8194 else s8195-  s8200 :: SWord8 = if s3945 then s8196 else s8199-  s8201 :: SWord1 = choose [0:0] s3987-  s8202 :: SBool = s15 /= s8201-  s8203 :: SWord8 = if s18 then s3995 else s3976-  s8204 :: SWord8 = s8203 >>> 1-  s8205 :: SWord8 = s20 | s8204-  s8206 :: SWord8 = s22 & s8204-  s8207 :: SWord8 = if s8202 then s8205 else s8206-  s8208 :: SWord1 = choose [0:0] s3998-  s8209 :: SBool = s15 /= s8208-  s8210 :: SWord8 = if s8209 then s8205 else s8206-  s8211 :: SWord8 = if s3980 then s8207 else s8210-  s8212 :: SWord8 = if s3923 then s8200 else s8211-  s8213 :: SWord8 = if s3801 then s8189 else s8212-  s8214 :: SWord1 = choose [0:0] s4063-  s8215 :: SBool = s15 /= s8214-  s8216 :: SWord8 = if s18 then s4073 else s4055-  s8217 :: SWord8 = s8216 >>> 1-  s8218 :: SWord8 = s20 | s8217-  s8219 :: SWord8 = s22 & s8217-  s8220 :: SWord8 = if s8215 then s8218 else s8219-  s8221 :: SWord1 = choose [0:0] s4080-  s8222 :: SBool = s15 /= s8221-  s8223 :: SWord8 = if s8222 then s8218 else s8219-  s8224 :: SWord8 = if s4059 then s8220 else s8223-  s8225 :: SWord1 = choose [0:0] s4103-  s8226 :: SBool = s15 /= s8225-  s8227 :: SWord8 = if s18 then s4111 else s4092-  s8228 :: SWord8 = s8227 >>> 1-  s8229 :: SWord8 = s20 | s8228-  s8230 :: SWord8 = s22 & s8228-  s8231 :: SWord8 = if s8226 then s8229 else s8230-  s8232 :: SWord1 = choose [0:0] s4114-  s8233 :: SBool = s15 /= s8232-  s8234 :: SWord8 = if s8233 then s8229 else s8230-  s8235 :: SWord8 = if s4096 then s8231 else s8234-  s8236 :: SWord8 = if s4038 then s8224 else s8235-  s8237 :: SWord1 = choose [0:0] s4157-  s8238 :: SBool = s15 /= s8237-  s8239 :: SWord8 = if s18 then s4167 else s4149-  s8240 :: SWord8 = s8239 >>> 1-  s8241 :: SWord8 = s20 | s8240-  s8242 :: SWord8 = s22 & s8240-  s8243 :: SWord8 = if s8238 then s8241 else s8242-  s8244 :: SWord1 = choose [0:0] s4172-  s8245 :: SBool = s15 /= s8244-  s8246 :: SWord8 = if s8245 then s8241 else s8242-  s8247 :: SWord8 = if s4153 then s8243 else s8246-  s8248 :: SWord1 = choose [0:0] s4195-  s8249 :: SBool = s15 /= s8248-  s8250 :: SWord8 = if s18 then s4203 else s4184-  s8251 :: SWord8 = s8250 >>> 1-  s8252 :: SWord8 = s20 | s8251-  s8253 :: SWord8 = s22 & s8251-  s8254 :: SWord8 = if s8249 then s8252 else s8253-  s8255 :: SWord1 = choose [0:0] s4206-  s8256 :: SBool = s15 /= s8255-  s8257 :: SWord8 = if s8256 then s8252 else s8253-  s8258 :: SWord8 = if s4188 then s8254 else s8257-  s8259 :: SWord8 = if s4131 then s8247 else s8258-  s8260 :: SWord8 = if s4016 then s8236 else s8259-  s8261 :: SWord8 = if s3780 then s8213 else s8260-  s8262 :: SWord1 = choose [0:0] s4293-  s8263 :: SBool = s15 /= s8262-  s8264 :: SWord8 = if s18 then s4303 else s4285-  s8265 :: SWord8 = s8264 >>> 1-  s8266 :: SWord8 = s20 | s8265-  s8267 :: SWord8 = s22 & s8265-  s8268 :: SWord8 = if s8263 then s8266 else s8267-  s8269 :: SWord1 = choose [0:0] s4312-  s8270 :: SBool = s15 /= s8269-  s8271 :: SWord8 = if s8270 then s8266 else s8267-  s8272 :: SWord8 = if s4289 then s8268 else s8271-  s8273 :: SWord1 = choose [0:0] s4335-  s8274 :: SBool = s15 /= s8273-  s8275 :: SWord8 = if s18 then s4343 else s4324-  s8276 :: SWord8 = s8275 >>> 1-  s8277 :: SWord8 = s20 | s8276-  s8278 :: SWord8 = s22 & s8276-  s8279 :: SWord8 = if s8274 then s8277 else s8278-  s8280 :: SWord1 = choose [0:0] s4346-  s8281 :: SBool = s15 /= s8280-  s8282 :: SWord8 = if s8281 then s8277 else s8278-  s8283 :: SWord8 = if s4328 then s8279 else s8282-  s8284 :: SWord8 = if s4268 then s8272 else s8283-  s8285 :: SWord1 = choose [0:0] s4389-  s8286 :: SBool = s15 /= s8285-  s8287 :: SWord8 = if s18 then s4399 else s4381-  s8288 :: SWord8 = s8287 >>> 1-  s8289 :: SWord8 = s20 | s8288-  s8290 :: SWord8 = s22 & s8288-  s8291 :: SWord8 = if s8286 then s8289 else s8290-  s8292 :: SWord1 = choose [0:0] s4404-  s8293 :: SBool = s15 /= s8292-  s8294 :: SWord8 = if s8293 then s8289 else s8290-  s8295 :: SWord8 = if s4385 then s8291 else s8294-  s8296 :: SWord1 = choose [0:0] s4427-  s8297 :: SBool = s15 /= s8296-  s8298 :: SWord8 = if s18 then s4435 else s4416-  s8299 :: SWord8 = s8298 >>> 1-  s8300 :: SWord8 = s20 | s8299-  s8301 :: SWord8 = s22 & s8299-  s8302 :: SWord8 = if s8297 then s8300 else s8301-  s8303 :: SWord1 = choose [0:0] s4438-  s8304 :: SBool = s15 /= s8303-  s8305 :: SWord8 = if s8304 then s8300 else s8301-  s8306 :: SWord8 = if s4420 then s8302 else s8305-  s8307 :: SWord8 = if s4363 then s8295 else s8306-  s8308 :: SWord8 = if s4247 then s8284 else s8307-  s8309 :: SWord1 = choose [0:0] s4503-  s8310 :: SBool = s15 /= s8309-  s8311 :: SWord8 = if s18 then s4513 else s4495-  s8312 :: SWord8 = s8311 >>> 1-  s8313 :: SWord8 = s20 | s8312-  s8314 :: SWord8 = s22 & s8312-  s8315 :: SWord8 = if s8310 then s8313 else s8314-  s8316 :: SWord1 = choose [0:0] s4520-  s8317 :: SBool = s15 /= s8316-  s8318 :: SWord8 = if s8317 then s8313 else s8314-  s8319 :: SWord8 = if s4499 then s8315 else s8318-  s8320 :: SWord1 = choose [0:0] s4543-  s8321 :: SBool = s15 /= s8320-  s8322 :: SWord8 = if s18 then s4551 else s4532-  s8323 :: SWord8 = s8322 >>> 1-  s8324 :: SWord8 = s20 | s8323-  s8325 :: SWord8 = s22 & s8323-  s8326 :: SWord8 = if s8321 then s8324 else s8325-  s8327 :: SWord1 = choose [0:0] s4554-  s8328 :: SBool = s15 /= s8327-  s8329 :: SWord8 = if s8328 then s8324 else s8325-  s8330 :: SWord8 = if s4536 then s8326 else s8329-  s8331 :: SWord8 = if s4478 then s8319 else s8330-  s8332 :: SWord1 = choose [0:0] s4597-  s8333 :: SBool = s15 /= s8332-  s8334 :: SWord8 = if s18 then s4607 else s4589-  s8335 :: SWord8 = s8334 >>> 1-  s8336 :: SWord8 = s20 | s8335-  s8337 :: SWord8 = s22 & s8335-  s8338 :: SWord8 = if s8333 then s8336 else s8337-  s8339 :: SWord1 = choose [0:0] s4612-  s8340 :: SBool = s15 /= s8339-  s8341 :: SWord8 = if s8340 then s8336 else s8337-  s8342 :: SWord8 = if s4593 then s8338 else s8341-  s8343 :: SWord1 = choose [0:0] s4635-  s8344 :: SBool = s15 /= s8343-  s8345 :: SWord8 = if s18 then s4643 else s4624-  s8346 :: SWord8 = s8345 >>> 1-  s8347 :: SWord8 = s20 | s8346-  s8348 :: SWord8 = s22 & s8346-  s8349 :: SWord8 = if s8344 then s8347 else s8348-  s8350 :: SWord1 = choose [0:0] s4646-  s8351 :: SBool = s15 /= s8350-  s8352 :: SWord8 = if s8351 then s8347 else s8348-  s8353 :: SWord8 = if s4628 then s8349 else s8352-  s8354 :: SWord8 = if s4571 then s8342 else s8353-  s8355 :: SWord8 = if s4456 then s8331 else s8354-  s8356 :: SWord8 = if s4225 then s8308 else s8355-  s8357 :: SWord8 = if s3759 then s8261 else s8356-  s8358 :: SWord1 = choose [0:0] s4755-  s8359 :: SBool = s15 /= s8358-  s8360 :: SWord8 = if s18 then s4765 else s4747-  s8361 :: SWord8 = s8360 >>> 1-  s8362 :: SWord8 = s20 | s8361-  s8363 :: SWord8 = s22 & s8361-  s8364 :: SWord8 = if s8359 then s8362 else s8363-  s8365 :: SWord1 = choose [0:0] s4776-  s8366 :: SBool = s15 /= s8365-  s8367 :: SWord8 = if s8366 then s8362 else s8363-  s8368 :: SWord8 = if s4751 then s8364 else s8367-  s8369 :: SWord1 = choose [0:0] s4799-  s8370 :: SBool = s15 /= s8369-  s8371 :: SWord8 = if s18 then s4807 else s4788-  s8372 :: SWord8 = s8371 >>> 1-  s8373 :: SWord8 = s20 | s8372-  s8374 :: SWord8 = s22 & s8372-  s8375 :: SWord8 = if s8370 then s8373 else s8374-  s8376 :: SWord1 = choose [0:0] s4810-  s8377 :: SBool = s15 /= s8376-  s8378 :: SWord8 = if s8377 then s8373 else s8374-  s8379 :: SWord8 = if s4792 then s8375 else s8378-  s8380 :: SWord8 = if s4730 then s8368 else s8379-  s8381 :: SWord1 = choose [0:0] s4853-  s8382 :: SBool = s15 /= s8381-  s8383 :: SWord8 = if s18 then s4863 else s4845-  s8384 :: SWord8 = s8383 >>> 1-  s8385 :: SWord8 = s20 | s8384-  s8386 :: SWord8 = s22 & s8384-  s8387 :: SWord8 = if s8382 then s8385 else s8386-  s8388 :: SWord1 = choose [0:0] s4868-  s8389 :: SBool = s15 /= s8388-  s8390 :: SWord8 = if s8389 then s8385 else s8386-  s8391 :: SWord8 = if s4849 then s8387 else s8390-  s8392 :: SWord1 = choose [0:0] s4891-  s8393 :: SBool = s15 /= s8392-  s8394 :: SWord8 = if s18 then s4899 else s4880-  s8395 :: SWord8 = s8394 >>> 1-  s8396 :: SWord8 = s20 | s8395-  s8397 :: SWord8 = s22 & s8395-  s8398 :: SWord8 = if s8393 then s8396 else s8397-  s8399 :: SWord1 = choose [0:0] s4902-  s8400 :: SBool = s15 /= s8399-  s8401 :: SWord8 = if s8400 then s8396 else s8397-  s8402 :: SWord8 = if s4884 then s8398 else s8401-  s8403 :: SWord8 = if s4827 then s8391 else s8402-  s8404 :: SWord8 = if s4709 then s8380 else s8403-  s8405 :: SWord1 = choose [0:0] s4967-  s8406 :: SBool = s15 /= s8405-  s8407 :: SWord8 = if s18 then s4977 else s4959-  s8408 :: SWord8 = s8407 >>> 1-  s8409 :: SWord8 = s20 | s8408-  s8410 :: SWord8 = s22 & s8408-  s8411 :: SWord8 = if s8406 then s8409 else s8410-  s8412 :: SWord1 = choose [0:0] s4984-  s8413 :: SBool = s15 /= s8412-  s8414 :: SWord8 = if s8413 then s8409 else s8410-  s8415 :: SWord8 = if s4963 then s8411 else s8414-  s8416 :: SWord1 = choose [0:0] s5007-  s8417 :: SBool = s15 /= s8416-  s8418 :: SWord8 = if s18 then s5015 else s4996-  s8419 :: SWord8 = s8418 >>> 1-  s8420 :: SWord8 = s20 | s8419-  s8421 :: SWord8 = s22 & s8419-  s8422 :: SWord8 = if s8417 then s8420 else s8421-  s8423 :: SWord1 = choose [0:0] s5018-  s8424 :: SBool = s15 /= s8423-  s8425 :: SWord8 = if s8424 then s8420 else s8421-  s8426 :: SWord8 = if s5000 then s8422 else s8425-  s8427 :: SWord8 = if s4942 then s8415 else s8426-  s8428 :: SWord1 = choose [0:0] s5061-  s8429 :: SBool = s15 /= s8428-  s8430 :: SWord8 = if s18 then s5071 else s5053-  s8431 :: SWord8 = s8430 >>> 1-  s8432 :: SWord8 = s20 | s8431-  s8433 :: SWord8 = s22 & s8431-  s8434 :: SWord8 = if s8429 then s8432 else s8433-  s8435 :: SWord1 = choose [0:0] s5076-  s8436 :: SBool = s15 /= s8435-  s8437 :: SWord8 = if s8436 then s8432 else s8433-  s8438 :: SWord8 = if s5057 then s8434 else s8437-  s8439 :: SWord1 = choose [0:0] s5099-  s8440 :: SBool = s15 /= s8439-  s8441 :: SWord8 = if s18 then s5107 else s5088-  s8442 :: SWord8 = s8441 >>> 1-  s8443 :: SWord8 = s20 | s8442-  s8444 :: SWord8 = s22 & s8442-  s8445 :: SWord8 = if s8440 then s8443 else s8444-  s8446 :: SWord1 = choose [0:0] s5110-  s8447 :: SBool = s15 /= s8446-  s8448 :: SWord8 = if s8447 then s8443 else s8444-  s8449 :: SWord8 = if s5092 then s8445 else s8448-  s8450 :: SWord8 = if s5035 then s8438 else s8449-  s8451 :: SWord8 = if s4920 then s8427 else s8450-  s8452 :: SWord8 = if s4688 then s8404 else s8451-  s8453 :: SWord1 = choose [0:0] s5197-  s8454 :: SBool = s15 /= s8453-  s8455 :: SWord8 = if s18 then s5207 else s5189-  s8456 :: SWord8 = s8455 >>> 1-  s8457 :: SWord8 = s20 | s8456-  s8458 :: SWord8 = s22 & s8456-  s8459 :: SWord8 = if s8454 then s8457 else s8458-  s8460 :: SWord1 = choose [0:0] s5216-  s8461 :: SBool = s15 /= s8460-  s8462 :: SWord8 = if s8461 then s8457 else s8458-  s8463 :: SWord8 = if s5193 then s8459 else s8462-  s8464 :: SWord1 = choose [0:0] s5239-  s8465 :: SBool = s15 /= s8464-  s8466 :: SWord8 = if s18 then s5247 else s5228-  s8467 :: SWord8 = s8466 >>> 1-  s8468 :: SWord8 = s20 | s8467-  s8469 :: SWord8 = s22 & s8467-  s8470 :: SWord8 = if s8465 then s8468 else s8469-  s8471 :: SWord1 = choose [0:0] s5250-  s8472 :: SBool = s15 /= s8471-  s8473 :: SWord8 = if s8472 then s8468 else s8469-  s8474 :: SWord8 = if s5232 then s8470 else s8473-  s8475 :: SWord8 = if s5172 then s8463 else s8474-  s8476 :: SWord1 = choose [0:0] s5293-  s8477 :: SBool = s15 /= s8476-  s8478 :: SWord8 = if s18 then s5303 else s5285-  s8479 :: SWord8 = s8478 >>> 1-  s8480 :: SWord8 = s20 | s8479-  s8481 :: SWord8 = s22 & s8479-  s8482 :: SWord8 = if s8477 then s8480 else s8481-  s8483 :: SWord1 = choose [0:0] s5308-  s8484 :: SBool = s15 /= s8483-  s8485 :: SWord8 = if s8484 then s8480 else s8481-  s8486 :: SWord8 = if s5289 then s8482 else s8485-  s8487 :: SWord1 = choose [0:0] s5331-  s8488 :: SBool = s15 /= s8487-  s8489 :: SWord8 = if s18 then s5339 else s5320-  s8490 :: SWord8 = s8489 >>> 1-  s8491 :: SWord8 = s20 | s8490-  s8492 :: SWord8 = s22 & s8490-  s8493 :: SWord8 = if s8488 then s8491 else s8492-  s8494 :: SWord1 = choose [0:0] s5342-  s8495 :: SBool = s15 /= s8494-  s8496 :: SWord8 = if s8495 then s8491 else s8492-  s8497 :: SWord8 = if s5324 then s8493 else s8496-  s8498 :: SWord8 = if s5267 then s8486 else s8497-  s8499 :: SWord8 = if s5151 then s8475 else s8498-  s8500 :: SWord1 = choose [0:0] s5407-  s8501 :: SBool = s15 /= s8500-  s8502 :: SWord8 = if s18 then s5417 else s5399-  s8503 :: SWord8 = s8502 >>> 1-  s8504 :: SWord8 = s20 | s8503-  s8505 :: SWord8 = s22 & s8503-  s8506 :: SWord8 = if s8501 then s8504 else s8505-  s8507 :: SWord1 = choose [0:0] s5424-  s8508 :: SBool = s15 /= s8507-  s8509 :: SWord8 = if s8508 then s8504 else s8505-  s8510 :: SWord8 = if s5403 then s8506 else s8509-  s8511 :: SWord1 = choose [0:0] s5447-  s8512 :: SBool = s15 /= s8511-  s8513 :: SWord8 = if s18 then s5455 else s5436-  s8514 :: SWord8 = s8513 >>> 1-  s8515 :: SWord8 = s20 | s8514-  s8516 :: SWord8 = s22 & s8514-  s8517 :: SWord8 = if s8512 then s8515 else s8516-  s8518 :: SWord1 = choose [0:0] s5458-  s8519 :: SBool = s15 /= s8518-  s8520 :: SWord8 = if s8519 then s8515 else s8516-  s8521 :: SWord8 = if s5440 then s8517 else s8520-  s8522 :: SWord8 = if s5382 then s8510 else s8521-  s8523 :: SWord1 = choose [0:0] s5501-  s8524 :: SBool = s15 /= s8523-  s8525 :: SWord8 = if s18 then s5511 else s5493-  s8526 :: SWord8 = s8525 >>> 1-  s8527 :: SWord8 = s20 | s8526-  s8528 :: SWord8 = s22 & s8526-  s8529 :: SWord8 = if s8524 then s8527 else s8528-  s8530 :: SWord1 = choose [0:0] s5516-  s8531 :: SBool = s15 /= s8530-  s8532 :: SWord8 = if s8531 then s8527 else s8528-  s8533 :: SWord8 = if s5497 then s8529 else s8532-  s8534 :: SWord1 = choose [0:0] s5539-  s8535 :: SBool = s15 /= s8534-  s8536 :: SWord8 = if s18 then s5547 else s5528-  s8537 :: SWord8 = s8536 >>> 1-  s8538 :: SWord8 = s20 | s8537-  s8539 :: SWord8 = s22 & s8537-  s8540 :: SWord8 = if s8535 then s8538 else s8539-  s8541 :: SWord1 = choose [0:0] s5550-  s8542 :: SBool = s15 /= s8541-  s8543 :: SWord8 = if s8542 then s8538 else s8539-  s8544 :: SWord8 = if s5532 then s8540 else s8543-  s8545 :: SWord8 = if s5475 then s8533 else s8544-  s8546 :: SWord8 = if s5360 then s8522 else s8545-  s8547 :: SWord8 = if s5129 then s8499 else s8546-  s8548 :: SWord8 = if s4666 then s8452 else s8547-  s8549 :: SWord8 = if s3738 then s8357 else s8548-  s8550 :: SWord1 = choose [0:0] s5681-  s8551 :: SBool = s15 /= s8550-  s8552 :: SWord8 = if s18 then s5691 else s5673-  s8553 :: SWord8 = s8552 >>> 1-  s8554 :: SWord8 = s20 | s8553-  s8555 :: SWord8 = s22 & s8553-  s8556 :: SWord8 = if s8551 then s8554 else s8555-  s8557 :: SWord1 = choose [0:0] s5704-  s8558 :: SBool = s15 /= s8557-  s8559 :: SWord8 = if s8558 then s8554 else s8555-  s8560 :: SWord8 = if s5677 then s8556 else s8559-  s8561 :: SWord1 = choose [0:0] s5727-  s8562 :: SBool = s15 /= s8561-  s8563 :: SWord8 = if s18 then s5735 else s5716-  s8564 :: SWord8 = s8563 >>> 1-  s8565 :: SWord8 = s20 | s8564-  s8566 :: SWord8 = s22 & s8564-  s8567 :: SWord8 = if s8562 then s8565 else s8566-  s8568 :: SWord1 = choose [0:0] s5738-  s8569 :: SBool = s15 /= s8568-  s8570 :: SWord8 = if s8569 then s8565 else s8566-  s8571 :: SWord8 = if s5720 then s8567 else s8570-  s8572 :: SWord8 = if s5656 then s8560 else s8571-  s8573 :: SWord1 = choose [0:0] s5781-  s8574 :: SBool = s15 /= s8573-  s8575 :: SWord8 = if s18 then s5791 else s5773-  s8576 :: SWord8 = s8575 >>> 1-  s8577 :: SWord8 = s20 | s8576-  s8578 :: SWord8 = s22 & s8576-  s8579 :: SWord8 = if s8574 then s8577 else s8578-  s8580 :: SWord1 = choose [0:0] s5796-  s8581 :: SBool = s15 /= s8580-  s8582 :: SWord8 = if s8581 then s8577 else s8578-  s8583 :: SWord8 = if s5777 then s8579 else s8582-  s8584 :: SWord1 = choose [0:0] s5819-  s8585 :: SBool = s15 /= s8584-  s8586 :: SWord8 = if s18 then s5827 else s5808-  s8587 :: SWord8 = s8586 >>> 1-  s8588 :: SWord8 = s20 | s8587-  s8589 :: SWord8 = s22 & s8587-  s8590 :: SWord8 = if s8585 then s8588 else s8589-  s8591 :: SWord1 = choose [0:0] s5830-  s8592 :: SBool = s15 /= s8591-  s8593 :: SWord8 = if s8592 then s8588 else s8589-  s8594 :: SWord8 = if s5812 then s8590 else s8593-  s8595 :: SWord8 = if s5755 then s8583 else s8594-  s8596 :: SWord8 = if s5635 then s8572 else s8595-  s8597 :: SWord1 = choose [0:0] s5895-  s8598 :: SBool = s15 /= s8597-  s8599 :: SWord8 = if s18 then s5905 else s5887-  s8600 :: SWord8 = s8599 >>> 1-  s8601 :: SWord8 = s20 | s8600-  s8602 :: SWord8 = s22 & s8600-  s8603 :: SWord8 = if s8598 then s8601 else s8602-  s8604 :: SWord1 = choose [0:0] s5912-  s8605 :: SBool = s15 /= s8604-  s8606 :: SWord8 = if s8605 then s8601 else s8602-  s8607 :: SWord8 = if s5891 then s8603 else s8606-  s8608 :: SWord1 = choose [0:0] s5935-  s8609 :: SBool = s15 /= s8608-  s8610 :: SWord8 = if s18 then s5943 else s5924-  s8611 :: SWord8 = s8610 >>> 1-  s8612 :: SWord8 = s20 | s8611-  s8613 :: SWord8 = s22 & s8611-  s8614 :: SWord8 = if s8609 then s8612 else s8613-  s8615 :: SWord1 = choose [0:0] s5946-  s8616 :: SBool = s15 /= s8615-  s8617 :: SWord8 = if s8616 then s8612 else s8613-  s8618 :: SWord8 = if s5928 then s8614 else s8617-  s8619 :: SWord8 = if s5870 then s8607 else s8618-  s8620 :: SWord1 = choose [0:0] s5989-  s8621 :: SBool = s15 /= s8620-  s8622 :: SWord8 = if s18 then s5999 else s5981-  s8623 :: SWord8 = s8622 >>> 1-  s8624 :: SWord8 = s20 | s8623-  s8625 :: SWord8 = s22 & s8623-  s8626 :: SWord8 = if s8621 then s8624 else s8625-  s8627 :: SWord1 = choose [0:0] s6004-  s8628 :: SBool = s15 /= s8627-  s8629 :: SWord8 = if s8628 then s8624 else s8625-  s8630 :: SWord8 = if s5985 then s8626 else s8629-  s8631 :: SWord1 = choose [0:0] s6027-  s8632 :: SBool = s15 /= s8631-  s8633 :: SWord8 = if s18 then s6035 else s6016-  s8634 :: SWord8 = s8633 >>> 1-  s8635 :: SWord8 = s20 | s8634-  s8636 :: SWord8 = s22 & s8634-  s8637 :: SWord8 = if s8632 then s8635 else s8636-  s8638 :: SWord1 = choose [0:0] s6038-  s8639 :: SBool = s15 /= s8638-  s8640 :: SWord8 = if s8639 then s8635 else s8636-  s8641 :: SWord8 = if s6020 then s8637 else s8640-  s8642 :: SWord8 = if s5963 then s8630 else s8641-  s8643 :: SWord8 = if s5848 then s8619 else s8642-  s8644 :: SWord8 = if s5614 then s8596 else s8643-  s8645 :: SWord1 = choose [0:0] s6125-  s8646 :: SBool = s15 /= s8645-  s8647 :: SWord8 = if s18 then s6135 else s6117-  s8648 :: SWord8 = s8647 >>> 1-  s8649 :: SWord8 = s20 | s8648-  s8650 :: SWord8 = s22 & s8648-  s8651 :: SWord8 = if s8646 then s8649 else s8650-  s8652 :: SWord1 = choose [0:0] s6144-  s8653 :: SBool = s15 /= s8652-  s8654 :: SWord8 = if s8653 then s8649 else s8650-  s8655 :: SWord8 = if s6121 then s8651 else s8654-  s8656 :: SWord1 = choose [0:0] s6167-  s8657 :: SBool = s15 /= s8656-  s8658 :: SWord8 = if s18 then s6175 else s6156-  s8659 :: SWord8 = s8658 >>> 1-  s8660 :: SWord8 = s20 | s8659-  s8661 :: SWord8 = s22 & s8659-  s8662 :: SWord8 = if s8657 then s8660 else s8661-  s8663 :: SWord1 = choose [0:0] s6178-  s8664 :: SBool = s15 /= s8663-  s8665 :: SWord8 = if s8664 then s8660 else s8661-  s8666 :: SWord8 = if s6160 then s8662 else s8665-  s8667 :: SWord8 = if s6100 then s8655 else s8666-  s8668 :: SWord1 = choose [0:0] s6221-  s8669 :: SBool = s15 /= s8668-  s8670 :: SWord8 = if s18 then s6231 else s6213-  s8671 :: SWord8 = s8670 >>> 1-  s8672 :: SWord8 = s20 | s8671-  s8673 :: SWord8 = s22 & s8671-  s8674 :: SWord8 = if s8669 then s8672 else s8673-  s8675 :: SWord1 = choose [0:0] s6236-  s8676 :: SBool = s15 /= s8675-  s8677 :: SWord8 = if s8676 then s8672 else s8673-  s8678 :: SWord8 = if s6217 then s8674 else s8677-  s8679 :: SWord1 = choose [0:0] s6259-  s8680 :: SBool = s15 /= s8679-  s8681 :: SWord8 = if s18 then s6267 else s6248-  s8682 :: SWord8 = s8681 >>> 1-  s8683 :: SWord8 = s20 | s8682-  s8684 :: SWord8 = s22 & s8682-  s8685 :: SWord8 = if s8680 then s8683 else s8684-  s8686 :: SWord1 = choose [0:0] s6270-  s8687 :: SBool = s15 /= s8686-  s8688 :: SWord8 = if s8687 then s8683 else s8684-  s8689 :: SWord8 = if s6252 then s8685 else s8688-  s8690 :: SWord8 = if s6195 then s8678 else s8689-  s8691 :: SWord8 = if s6079 then s8667 else s8690-  s8692 :: SWord1 = choose [0:0] s6335-  s8693 :: SBool = s15 /= s8692-  s8694 :: SWord8 = if s18 then s6345 else s6327-  s8695 :: SWord8 = s8694 >>> 1-  s8696 :: SWord8 = s20 | s8695-  s8697 :: SWord8 = s22 & s8695-  s8698 :: SWord8 = if s8693 then s8696 else s8697-  s8699 :: SWord1 = choose [0:0] s6352-  s8700 :: SBool = s15 /= s8699-  s8701 :: SWord8 = if s8700 then s8696 else s8697-  s8702 :: SWord8 = if s6331 then s8698 else s8701-  s8703 :: SWord1 = choose [0:0] s6375-  s8704 :: SBool = s15 /= s8703-  s8705 :: SWord8 = if s18 then s6383 else s6364-  s8706 :: SWord8 = s8705 >>> 1-  s8707 :: SWord8 = s20 | s8706-  s8708 :: SWord8 = s22 & s8706-  s8709 :: SWord8 = if s8704 then s8707 else s8708-  s8710 :: SWord1 = choose [0:0] s6386-  s8711 :: SBool = s15 /= s8710-  s8712 :: SWord8 = if s8711 then s8707 else s8708-  s8713 :: SWord8 = if s6368 then s8709 else s8712-  s8714 :: SWord8 = if s6310 then s8702 else s8713-  s8715 :: SWord1 = choose [0:0] s6429-  s8716 :: SBool = s15 /= s8715-  s8717 :: SWord8 = if s18 then s6439 else s6421-  s8718 :: SWord8 = s8717 >>> 1-  s8719 :: SWord8 = s20 | s8718-  s8720 :: SWord8 = s22 & s8718-  s8721 :: SWord8 = if s8716 then s8719 else s8720-  s8722 :: SWord1 = choose [0:0] s6444-  s8723 :: SBool = s15 /= s8722-  s8724 :: SWord8 = if s8723 then s8719 else s8720-  s8725 :: SWord8 = if s6425 then s8721 else s8724-  s8726 :: SWord1 = choose [0:0] s6467-  s8727 :: SBool = s15 /= s8726-  s8728 :: SWord8 = if s18 then s6475 else s6456-  s8729 :: SWord8 = s8728 >>> 1-  s8730 :: SWord8 = s20 | s8729-  s8731 :: SWord8 = s22 & s8729-  s8732 :: SWord8 = if s8727 then s8730 else s8731-  s8733 :: SWord1 = choose [0:0] s6478-  s8734 :: SBool = s15 /= s8733-  s8735 :: SWord8 = if s8734 then s8730 else s8731-  s8736 :: SWord8 = if s6460 then s8732 else s8735-  s8737 :: SWord8 = if s6403 then s8725 else s8736-  s8738 :: SWord8 = if s6288 then s8714 else s8737-  s8739 :: SWord8 = if s6057 then s8691 else s8738-  s8740 :: SWord8 = if s5593 then s8644 else s8739-  s8741 :: SWord1 = choose [0:0] s6587-  s8742 :: SBool = s15 /= s8741-  s8743 :: SWord8 = if s18 then s6597 else s6579-  s8744 :: SWord8 = s8743 >>> 1-  s8745 :: SWord8 = s20 | s8744-  s8746 :: SWord8 = s22 & s8744-  s8747 :: SWord8 = if s8742 then s8745 else s8746-  s8748 :: SWord1 = choose [0:0] s6608-  s8749 :: SBool = s15 /= s8748-  s8750 :: SWord8 = if s8749 then s8745 else s8746-  s8751 :: SWord8 = if s6583 then s8747 else s8750-  s8752 :: SWord1 = choose [0:0] s6631-  s8753 :: SBool = s15 /= s8752-  s8754 :: SWord8 = if s18 then s6639 else s6620-  s8755 :: SWord8 = s8754 >>> 1-  s8756 :: SWord8 = s20 | s8755-  s8757 :: SWord8 = s22 & s8755-  s8758 :: SWord8 = if s8753 then s8756 else s8757-  s8759 :: SWord1 = choose [0:0] s6642-  s8760 :: SBool = s15 /= s8759-  s8761 :: SWord8 = if s8760 then s8756 else s8757-  s8762 :: SWord8 = if s6624 then s8758 else s8761-  s8763 :: SWord8 = if s6562 then s8751 else s8762-  s8764 :: SWord1 = choose [0:0] s6685-  s8765 :: SBool = s15 /= s8764-  s8766 :: SWord8 = if s18 then s6695 else s6677-  s8767 :: SWord8 = s8766 >>> 1-  s8768 :: SWord8 = s20 | s8767-  s8769 :: SWord8 = s22 & s8767-  s8770 :: SWord8 = if s8765 then s8768 else s8769-  s8771 :: SWord1 = choose [0:0] s6700-  s8772 :: SBool = s15 /= s8771-  s8773 :: SWord8 = if s8772 then s8768 else s8769-  s8774 :: SWord8 = if s6681 then s8770 else s8773-  s8775 :: SWord1 = choose [0:0] s6723-  s8776 :: SBool = s15 /= s8775-  s8777 :: SWord8 = if s18 then s6731 else s6712-  s8778 :: SWord8 = s8777 >>> 1-  s8779 :: SWord8 = s20 | s8778-  s8780 :: SWord8 = s22 & s8778-  s8781 :: SWord8 = if s8776 then s8779 else s8780-  s8782 :: SWord1 = choose [0:0] s6734-  s8783 :: SBool = s15 /= s8782-  s8784 :: SWord8 = if s8783 then s8779 else s8780-  s8785 :: SWord8 = if s6716 then s8781 else s8784-  s8786 :: SWord8 = if s6659 then s8774 else s8785-  s8787 :: SWord8 = if s6541 then s8763 else s8786-  s8788 :: SWord1 = choose [0:0] s6799-  s8789 :: SBool = s15 /= s8788-  s8790 :: SWord8 = if s18 then s6809 else s6791-  s8791 :: SWord8 = s8790 >>> 1-  s8792 :: SWord8 = s20 | s8791-  s8793 :: SWord8 = s22 & s8791-  s8794 :: SWord8 = if s8789 then s8792 else s8793-  s8795 :: SWord1 = choose [0:0] s6816-  s8796 :: SBool = s15 /= s8795-  s8797 :: SWord8 = if s8796 then s8792 else s8793-  s8798 :: SWord8 = if s6795 then s8794 else s8797-  s8799 :: SWord1 = choose [0:0] s6839-  s8800 :: SBool = s15 /= s8799-  s8801 :: SWord8 = if s18 then s6847 else s6828-  s8802 :: SWord8 = s8801 >>> 1-  s8803 :: SWord8 = s20 | s8802-  s8804 :: SWord8 = s22 & s8802-  s8805 :: SWord8 = if s8800 then s8803 else s8804-  s8806 :: SWord1 = choose [0:0] s6850-  s8807 :: SBool = s15 /= s8806-  s8808 :: SWord8 = if s8807 then s8803 else s8804-  s8809 :: SWord8 = if s6832 then s8805 else s8808-  s8810 :: SWord8 = if s6774 then s8798 else s8809-  s8811 :: SWord1 = choose [0:0] s6893-  s8812 :: SBool = s15 /= s8811-  s8813 :: SWord8 = if s18 then s6903 else s6885-  s8814 :: SWord8 = s8813 >>> 1-  s8815 :: SWord8 = s20 | s8814-  s8816 :: SWord8 = s22 & s8814-  s8817 :: SWord8 = if s8812 then s8815 else s8816-  s8818 :: SWord1 = choose [0:0] s6908-  s8819 :: SBool = s15 /= s8818-  s8820 :: SWord8 = if s8819 then s8815 else s8816-  s8821 :: SWord8 = if s6889 then s8817 else s8820-  s8822 :: SWord1 = choose [0:0] s6931-  s8823 :: SBool = s15 /= s8822-  s8824 :: SWord8 = if s18 then s6939 else s6920-  s8825 :: SWord8 = s8824 >>> 1-  s8826 :: SWord8 = s20 | s8825-  s8827 :: SWord8 = s22 & s8825-  s8828 :: SWord8 = if s8823 then s8826 else s8827-  s8829 :: SWord1 = choose [0:0] s6942-  s8830 :: SBool = s15 /= s8829-  s8831 :: SWord8 = if s8830 then s8826 else s8827-  s8832 :: SWord8 = if s6924 then s8828 else s8831-  s8833 :: SWord8 = if s6867 then s8821 else s8832-  s8834 :: SWord8 = if s6752 then s8810 else s8833-  s8835 :: SWord8 = if s6520 then s8787 else s8834-  s8836 :: SWord1 = choose [0:0] s7029-  s8837 :: SBool = s15 /= s8836-  s8838 :: SWord8 = if s18 then s7039 else s7021-  s8839 :: SWord8 = s8838 >>> 1-  s8840 :: SWord8 = s20 | s8839-  s8841 :: SWord8 = s22 & s8839-  s8842 :: SWord8 = if s8837 then s8840 else s8841-  s8843 :: SWord1 = choose [0:0] s7048-  s8844 :: SBool = s15 /= s8843-  s8845 :: SWord8 = if s8844 then s8840 else s8841-  s8846 :: SWord8 = if s7025 then s8842 else s8845-  s8847 :: SWord1 = choose [0:0] s7071-  s8848 :: SBool = s15 /= s8847-  s8849 :: SWord8 = if s18 then s7079 else s7060-  s8850 :: SWord8 = s8849 >>> 1-  s8851 :: SWord8 = s20 | s8850-  s8852 :: SWord8 = s22 & s8850-  s8853 :: SWord8 = if s8848 then s8851 else s8852-  s8854 :: SWord1 = choose [0:0] s7082-  s8855 :: SBool = s15 /= s8854-  s8856 :: SWord8 = if s8855 then s8851 else s8852-  s8857 :: SWord8 = if s7064 then s8853 else s8856-  s8858 :: SWord8 = if s7004 then s8846 else s8857-  s8859 :: SWord1 = choose [0:0] s7125-  s8860 :: SBool = s15 /= s8859-  s8861 :: SWord8 = if s18 then s7135 else s7117-  s8862 :: SWord8 = s8861 >>> 1-  s8863 :: SWord8 = s20 | s8862-  s8864 :: SWord8 = s22 & s8862-  s8865 :: SWord8 = if s8860 then s8863 else s8864-  s8866 :: SWord1 = choose [0:0] s7140-  s8867 :: SBool = s15 /= s8866-  s8868 :: SWord8 = if s8867 then s8863 else s8864-  s8869 :: SWord8 = if s7121 then s8865 else s8868-  s8870 :: SWord1 = choose [0:0] s7163-  s8871 :: SBool = s15 /= s8870-  s8872 :: SWord8 = if s18 then s7171 else s7152-  s8873 :: SWord8 = s8872 >>> 1-  s8874 :: SWord8 = s20 | s8873-  s8875 :: SWord8 = s22 & s8873-  s8876 :: SWord8 = if s8871 then s8874 else s8875-  s8877 :: SWord1 = choose [0:0] s7174-  s8878 :: SBool = s15 /= s8877-  s8879 :: SWord8 = if s8878 then s8874 else s8875-  s8880 :: SWord8 = if s7156 then s8876 else s8879-  s8881 :: SWord8 = if s7099 then s8869 else s8880-  s8882 :: SWord8 = if s6983 then s8858 else s8881-  s8883 :: SWord1 = choose [0:0] s7239-  s8884 :: SBool = s15 /= s8883-  s8885 :: SWord8 = if s18 then s7249 else s7231-  s8886 :: SWord8 = s8885 >>> 1-  s8887 :: SWord8 = s20 | s8886-  s8888 :: SWord8 = s22 & s8886-  s8889 :: SWord8 = if s8884 then s8887 else s8888-  s8890 :: SWord1 = choose [0:0] s7256-  s8891 :: SBool = s15 /= s8890-  s8892 :: SWord8 = if s8891 then s8887 else s8888-  s8893 :: SWord8 = if s7235 then s8889 else s8892-  s8894 :: SWord1 = choose [0:0] s7279-  s8895 :: SBool = s15 /= s8894-  s8896 :: SWord8 = if s18 then s7287 else s7268-  s8897 :: SWord8 = s8896 >>> 1-  s8898 :: SWord8 = s20 | s8897-  s8899 :: SWord8 = s22 & s8897-  s8900 :: SWord8 = if s8895 then s8898 else s8899-  s8901 :: SWord1 = choose [0:0] s7290-  s8902 :: SBool = s15 /= s8901-  s8903 :: SWord8 = if s8902 then s8898 else s8899-  s8904 :: SWord8 = if s7272 then s8900 else s8903-  s8905 :: SWord8 = if s7214 then s8893 else s8904-  s8906 :: SWord1 = choose [0:0] s7333-  s8907 :: SBool = s15 /= s8906-  s8908 :: SWord8 = if s18 then s7343 else s7325-  s8909 :: SWord8 = s8908 >>> 1-  s8910 :: SWord8 = s20 | s8909-  s8911 :: SWord8 = s22 & s8909-  s8912 :: SWord8 = if s8907 then s8910 else s8911-  s8913 :: SWord1 = choose [0:0] s7348-  s8914 :: SBool = s15 /= s8913-  s8915 :: SWord8 = if s8914 then s8910 else s8911-  s8916 :: SWord8 = if s7329 then s8912 else s8915-  s8917 :: SWord1 = choose [0:0] s7371-  s8918 :: SBool = s15 /= s8917-  s8919 :: SWord8 = if s18 then s7379 else s7360-  s8920 :: SWord8 = s8919 >>> 1-  s8921 :: SWord8 = s20 | s8920-  s8922 :: SWord8 = s22 & s8920-  s8923 :: SWord8 = if s8918 then s8921 else s8922-  s8924 :: SWord1 = choose [0:0] s7382-  s8925 :: SBool = s15 /= s8924-  s8926 :: SWord8 = if s8925 then s8921 else s8922-  s8927 :: SWord8 = if s7364 then s8923 else s8926-  s8928 :: SWord8 = if s7307 then s8916 else s8927-  s8929 :: SWord8 = if s7192 then s8905 else s8928-  s8930 :: SWord8 = if s6961 then s8882 else s8929-  s8931 :: SWord8 = if s6498 then s8835 else s8930-  s8932 :: SWord8 = if s5571 then s8740 else s8931-  s8933 :: SWord8 = if s3721 then s8549 else s8932-  s8934 :: SWord8 = if s17 then s8166 else s8933-  s8935 :: SWord16 = s13 # s8934-  s8936 :: SWord16 = s7399 + s8935-  s8937 :: SWord16 = s13 # s1-  s8938 :: SWord16 = s13 # s3-  s8939 :: SWord16 = s8937 * s8938-  s8940 :: SBool = s8936 == s8939-  s8941 :: SBool = s11 | s8940-CONSTRAINTS-ASSERTIONS-OUTPUTS-  s8941
− SBVUnitTest/GoldFiles/legato_c.gold 
@@ -1,6425 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for legatoMult. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: legatoMult_driver--legatoMult.o: legatoMult.c legatoMult.h-	${CC} ${CCFLAGS} -c $< -o $@--legatoMult_driver.o: legatoMult_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--legatoMult_driver: legatoMult.o legatoMult_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f legatoMult_driver-== END: "Makefile" ==================-== BEGIN: "legatoMult.h" ================-/* Header file for legatoMult. Automatically generated by SBV. Do not edit! */--#ifndef __legatoMult__HEADER_INCLUDED__-#define __legatoMult__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-void legatoMult(const SWord8 x, const SWord8 y, SWord8 *hi,-                SWord8 *lo);--#endif /* __legatoMult__HEADER_INCLUDED__ */-== END: "legatoMult.h" ==================-== BEGIN: "legatoMult_driver.c" ================-/* Example driver program for legatoMult. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "legatoMult.h"--int main(void)-{-  SWord8 hi;-  SWord8 lo;--  legatoMult(87, 92, &hi, &lo);--  printf("legatoMult(87, 92, &hi, &lo) ->\n");-  printf("  hi = %"PRIu8"\n", hi);-  printf("  lo = %"PRIu8"\n", lo);--  return 0;-}-== END: "legatoMult_driver.c" ==================-== BEGIN: "legatoMult.c" ================-/* File: "legatoMult.c". Automatically generated by SBV. Do not edit! */--#include "legatoMult.h"--void legatoMult(const SWord8 x, const SWord8 y, SWord8 *hi,-                SWord8 *lo)-{-  const SWord8 s0 = x;-  const SWord8 s1 = y;-  const SBool  s2 = (SBool) ((s0 >> 0) & 1);-  const SBool  s4 = s2 != false;-  const SBool  s5 = false == s4;-  const SWord8 s6 = (s0 >> 1) | (s0 << 7);-  const SWord8 s8 = s6 & 127;-  const SBool  s9 = (SBool) ((s8 >> 0) & 1);-  const SBool  s10 = false != s9;-  const SBool  s11 = false == s10;-  const SWord8 s12 = (s8 >> 1) | (s8 << 7);-  const SWord8 s13 = 127 & s12;-  const SBool  s14 = (SBool) ((s13 >> 0) & 1);-  const SBool  s15 = false != s14;-  const SBool  s16 = false == s15;-  const SWord8 s17 = (s13 >> 1) | (s13 << 7);-  const SWord8 s18 = 127 & s17;-  const SBool  s19 = (SBool) ((s18 >> 0) & 1);-  const SBool  s20 = false != s19;-  const SBool  s21 = false == s20;-  const SWord8 s24 = s4 ? 128 : 0;-  const SBool  s25 = (SBool) ((s24 >> 0) & 1);-  const SBool  s26 = false != s25;-  const SWord8 s27 = s26 ? 128 : 0;-  const SBool  s28 = (SBool) ((s27 >> 0) & 1);-  const SBool  s29 = false != s28;-  const SWord8 s30 = (s18 >> 1) | (s18 << 7);-  const SWord8 s31 = 128 | s30;-  const SWord8 s32 = 127 & s30;-  const SWord8 s33 = s29 ? s31 : s32;-  const SBool  s34 = (SBool) ((s33 >> 0) & 1);-  const SBool  s35 = false != s34;-  const SBool  s36 = false == s35;-  const SWord8 s37 = (s24 >> 1) | (s24 << 7);-  const SWord8 s38 = 128 | s37;-  const SWord8 s39 = 127 & s37;-  const SWord8 s40 = s10 ? s38 : s39;-  const SBool  s41 = (SBool) ((s40 >> 0) & 1);-  const SBool  s42 = false != s41;-  const SWord8 s43 = (s27 >> 1) | (s27 << 7);-  const SWord8 s44 = 128 | s43;-  const SWord8 s45 = 127 & s43;-  const SWord8 s46 = s42 ? s44 : s45;-  const SBool  s47 = (SBool) ((s46 >> 0) & 1);-  const SBool  s48 = false != s47;-  const SWord8 s49 = (s33 >> 1) | (s33 << 7);-  const SWord8 s50 = 128 | s49;-  const SWord8 s51 = 127 & s49;-  const SWord8 s52 = s48 ? s50 : s51;-  const SBool  s53 = (SBool) ((s52 >> 0) & 1);-  const SBool  s54 = false != s53;-  const SBool  s55 = false == s54;-  const SWord8 s56 = (s40 >> 1) | (s40 << 7);-  const SWord8 s57 = 128 | s56;-  const SWord8 s58 = 127 & s56;-  const SWord8 s59 = s15 ? s57 : s58;-  const SBool  s60 = (SBool) ((s59 >> 0) & 1);-  const SBool  s61 = false != s60;-  const SWord8 s62 = (s46 >> 1) | (s46 << 7);-  const SWord8 s63 = 128 | s62;-  const SWord8 s64 = 127 & s62;-  const SWord8 s65 = s61 ? s63 : s64;-  const SBool  s66 = (SBool) ((s65 >> 0) & 1);-  const SBool  s67 = false != s66;-  const SWord8 s68 = (s52 >> 1) | (s52 << 7);-  const SWord8 s69 = 128 | s68;-  const SWord8 s70 = 127 & s68;-  const SWord8 s71 = s67 ? s69 : s70;-  const SBool  s72 = (SBool) ((s71 >> 0) & 1);-  const SBool  s73 = false != s72;-  const SBool  s74 = false == s73;-  const SWord8 s75 = (s59 >> 1) | (s59 << 7);-  const SWord8 s76 = 128 | s75;-  const SWord8 s77 = 127 & s75;-  const SWord8 s78 = s20 ? s76 : s77;-  const SBool  s79 = (SBool) ((s78 >> 0) & 1);-  const SBool  s80 = false != s79;-  const SWord8 s81 = (s65 >> 1) | (s65 << 7);-  const SWord8 s82 = 128 | s81;-  const SWord8 s83 = 127 & s81;-  const SWord8 s84 = s80 ? s82 : s83;-  const SBool  s85 = (SBool) ((s84 >> 0) & 1);-  const SBool  s86 = false != s85;-  const SWord8 s87 = (s71 >> 1) | (s71 << 7);-  const SWord8 s88 = 128 | s87;-  const SWord8 s89 = 127 & s87;-  const SWord8 s90 = s86 ? s88 : s89;-  const SBool  s91 = (SBool) ((s90 >> 0) & 1);-  const SBool  s92 = false != s91;-  const SBool  s93 = false == s92;-  const SWord8 s94 = (s78 >> 1) | (s78 << 7);-  const SWord8 s95 = 128 | s94;-  const SWord8 s96 = 127 & s94;-  const SWord8 s97 = s35 ? s95 : s96;-  const SWord8 s98 = (s97 >> 1) | (s97 << 7);-  const SWord8 s99 = 128 | s98;-  const SWord8 s100 = 127 & s98;-  const SWord8 s101 = s54 ? s99 : s100;-  const SWord8 s102 = (s101 >> 1) | (s101 << 7);-  const SWord8 s103 = 128 | s102;-  const SWord8 s104 = 127 & s102;-  const SWord8 s105 = s73 ? s103 : s104;-  const SWord8 s106 = (s105 >> 1) | (s105 << 7);-  const SWord8 s107 = 128 | s106;-  const SWord8 s108 = 127 & s106;-  const SWord8 s109 = s92 ? s107 : s108;-  const SWord8 s110 = s1 + s105;-  const SBool  s111 = s110 < s1;-  const SBool  s112 = s110 < s105;-  const SBool  s113 = s111 || s112;-  const SWord8 s114 = (s110 >> 1) | (s110 << 7);-  const SWord8 s115 = 128 | s114;-  const SWord8 s116 = 127 & s114;-  const SWord8 s117 = s113 ? s115 : s116;-  const SWord8 s118 = s93 ? s109 : s117;-  const SWord8 s119 = s1 + s101;-  const SBool  s120 = s119 < s1;-  const SBool  s121 = s119 < s101;-  const SBool  s122 = s120 || s121;-  const SWord8 s123 = (s119 >> 1) | (s119 << 7);-  const SWord8 s124 = 128 | s123;-  const SWord8 s125 = 127 & s123;-  const SWord8 s126 = s122 ? s124 : s125;-  const SWord8 s127 = (s126 >> 1) | (s126 << 7);-  const SWord8 s128 = 128 | s127;-  const SWord8 s129 = 127 & s127;-  const SWord8 s130 = s92 ? s128 : s129;-  const SWord8 s131 = s1 + s126;-  const SBool  s132 = s131 < s1;-  const SBool  s133 = s131 < s126;-  const SBool  s134 = s132 || s133;-  const SWord8 s135 = (s131 >> 1) | (s131 << 7);-  const SWord8 s136 = 128 | s135;-  const SWord8 s137 = 127 & s135;-  const SWord8 s138 = s134 ? s136 : s137;-  const SWord8 s139 = s93 ? s130 : s138;-  const SWord8 s140 = s74 ? s118 : s139;-  const SWord8 s141 = s1 + s97;-  const SBool  s142 = s141 < s1;-  const SBool  s143 = s141 < s97;-  const SBool  s144 = s142 || s143;-  const SWord8 s145 = (s141 >> 1) | (s141 << 7);-  const SWord8 s146 = 128 | s145;-  const SWord8 s147 = 127 & s145;-  const SWord8 s148 = s144 ? s146 : s147;-  const SWord8 s149 = (s148 >> 1) | (s148 << 7);-  const SWord8 s150 = 128 | s149;-  const SWord8 s151 = 127 & s149;-  const SWord8 s152 = s73 ? s150 : s151;-  const SWord8 s153 = (s152 >> 1) | (s152 << 7);-  const SWord8 s154 = 128 | s153;-  const SWord8 s155 = 127 & s153;-  const SWord8 s156 = s92 ? s154 : s155;-  const SWord8 s157 = s1 + s152;-  const SBool  s158 = s157 < s1;-  const SBool  s159 = s157 < s152;-  const SBool  s160 = s158 || s159;-  const SWord8 s161 = (s157 >> 1) | (s157 << 7);-  const SWord8 s162 = 128 | s161;-  const SWord8 s163 = 127 & s161;-  const SWord8 s164 = s160 ? s162 : s163;-  const SWord8 s165 = s93 ? s156 : s164;-  const SWord8 s166 = s1 + s148;-  const SBool  s167 = s166 < s1;-  const SBool  s168 = s166 < s148;-  const SBool  s169 = s167 || s168;-  const SWord8 s170 = (s166 >> 1) | (s166 << 7);-  const SWord8 s171 = 128 | s170;-  const SWord8 s172 = 127 & s170;-  const SWord8 s173 = s169 ? s171 : s172;-  const SWord8 s174 = (s173 >> 1) | (s173 << 7);-  const SWord8 s175 = 128 | s174;-  const SWord8 s176 = 127 & s174;-  const SWord8 s177 = s92 ? s175 : s176;-  const SWord8 s178 = s1 + s173;-  const SBool  s179 = s178 < s1;-  const SBool  s180 = s178 < s173;-  const SBool  s181 = s179 || s180;-  const SWord8 s182 = (s178 >> 1) | (s178 << 7);-  const SWord8 s183 = 128 | s182;-  const SWord8 s184 = 127 & s182;-  const SWord8 s185 = s181 ? s183 : s184;-  const SWord8 s186 = s93 ? s177 : s185;-  const SWord8 s187 = s74 ? s165 : s186;-  const SWord8 s188 = s55 ? s140 : s187;-  const SWord8 s189 = s1 + s78;-  const SBool  s190 = (SBool) ((s189 >> 0) & 1);-  const SBool  s191 = false != s190;-  const SWord8 s192 = s191 ? s82 : s83;-  const SBool  s193 = (SBool) ((s192 >> 0) & 1);-  const SBool  s194 = false != s193;-  const SWord8 s195 = s194 ? s88 : s89;-  const SBool  s196 = (SBool) ((s195 >> 0) & 1);-  const SBool  s197 = false != s196;-  const SBool  s198 = false == s197;-  const SBool  s199 = s189 < s1;-  const SBool  s200 = s189 < s78;-  const SBool  s201 = s199 || s200;-  const SWord8 s202 = (s189 >> 1) | (s189 << 7);-  const SWord8 s203 = 128 | s202;-  const SWord8 s204 = 127 & s202;-  const SWord8 s205 = s201 ? s203 : s204;-  const SWord8 s206 = (s205 >> 1) | (s205 << 7);-  const SWord8 s207 = 128 | s206;-  const SWord8 s208 = 127 & s206;-  const SWord8 s209 = s54 ? s207 : s208;-  const SWord8 s210 = (s209 >> 1) | (s209 << 7);-  const SWord8 s211 = 128 | s210;-  const SWord8 s212 = 127 & s210;-  const SWord8 s213 = s73 ? s211 : s212;-  const SWord8 s214 = (s213 >> 1) | (s213 << 7);-  const SWord8 s215 = 128 | s214;-  const SWord8 s216 = 127 & s214;-  const SWord8 s217 = s197 ? s215 : s216;-  const SWord8 s218 = s1 + s213;-  const SBool  s219 = s218 < s1;-  const SBool  s220 = s218 < s213;-  const SBool  s221 = s219 || s220;-  const SWord8 s222 = (s218 >> 1) | (s218 << 7);-  const SWord8 s223 = 128 | s222;-  const SWord8 s224 = 127 & s222;-  const SWord8 s225 = s221 ? s223 : s224;-  const SWord8 s226 = s198 ? s217 : s225;-  const SWord8 s227 = s1 + s209;-  const SBool  s228 = s227 < s1;-  const SBool  s229 = s227 < s209;-  const SBool  s230 = s228 || s229;-  const SWord8 s231 = (s227 >> 1) | (s227 << 7);-  const SWord8 s232 = 128 | s231;-  const SWord8 s233 = 127 & s231;-  const SWord8 s234 = s230 ? s232 : s233;-  const SWord8 s235 = (s234 >> 1) | (s234 << 7);-  const SWord8 s236 = 128 | s235;-  const SWord8 s237 = 127 & s235;-  const SWord8 s238 = s197 ? s236 : s237;-  const SWord8 s239 = s1 + s234;-  const SBool  s240 = s239 < s1;-  const SBool  s241 = s239 < s234;-  const SBool  s242 = s240 || s241;-  const SWord8 s243 = (s239 >> 1) | (s239 << 7);-  const SWord8 s244 = 128 | s243;-  const SWord8 s245 = 127 & s243;-  const SWord8 s246 = s242 ? s244 : s245;-  const SWord8 s247 = s198 ? s238 : s246;-  const SWord8 s248 = s74 ? s226 : s247;-  const SWord8 s249 = s1 + s205;-  const SBool  s250 = s249 < s1;-  const SBool  s251 = s249 < s205;-  const SBool  s252 = s250 || s251;-  const SWord8 s253 = (s249 >> 1) | (s249 << 7);-  const SWord8 s254 = 128 | s253;-  const SWord8 s255 = 127 & s253;-  const SWord8 s256 = s252 ? s254 : s255;-  const SWord8 s257 = (s256 >> 1) | (s256 << 7);-  const SWord8 s258 = 128 | s257;-  const SWord8 s259 = 127 & s257;-  const SWord8 s260 = s73 ? s258 : s259;-  const SWord8 s261 = (s260 >> 1) | (s260 << 7);-  const SWord8 s262 = 128 | s261;-  const SWord8 s263 = 127 & s261;-  const SWord8 s264 = s197 ? s262 : s263;-  const SWord8 s265 = s1 + s260;-  const SBool  s266 = s265 < s1;-  const SBool  s267 = s265 < s260;-  const SBool  s268 = s266 || s267;-  const SWord8 s269 = (s265 >> 1) | (s265 << 7);-  const SWord8 s270 = 128 | s269;-  const SWord8 s271 = 127 & s269;-  const SWord8 s272 = s268 ? s270 : s271;-  const SWord8 s273 = s198 ? s264 : s272;-  const SWord8 s274 = s1 + s256;-  const SBool  s275 = s274 < s1;-  const SBool  s276 = s274 < s256;-  const SBool  s277 = s275 || s276;-  const SWord8 s278 = (s274 >> 1) | (s274 << 7);-  const SWord8 s279 = 128 | s278;-  const SWord8 s280 = 127 & s278;-  const SWord8 s281 = s277 ? s279 : s280;-  const SWord8 s282 = (s281 >> 1) | (s281 << 7);-  const SWord8 s283 = 128 | s282;-  const SWord8 s284 = 127 & s282;-  const SWord8 s285 = s197 ? s283 : s284;-  const SWord8 s286 = s1 + s281;-  const SBool  s287 = s286 < s1;-  const SBool  s288 = s286 < s281;-  const SBool  s289 = s287 || s288;-  const SWord8 s290 = (s286 >> 1) | (s286 << 7);-  const SWord8 s291 = 128 | s290;-  const SWord8 s292 = 127 & s290;-  const SWord8 s293 = s289 ? s291 : s292;-  const SWord8 s294 = s198 ? s285 : s293;-  const SWord8 s295 = s74 ? s273 : s294;-  const SWord8 s296 = s55 ? s248 : s295;-  const SWord8 s297 = s36 ? s188 : s296;-  const SWord8 s298 = s1 + s59;-  const SBool  s299 = (SBool) ((s298 >> 0) & 1);-  const SBool  s300 = false != s299;-  const SWord8 s301 = s300 ? s63 : s64;-  const SBool  s302 = (SBool) ((s301 >> 0) & 1);-  const SBool  s303 = false != s302;-  const SWord8 s304 = s303 ? s69 : s70;-  const SBool  s305 = (SBool) ((s304 >> 0) & 1);-  const SBool  s306 = false != s305;-  const SBool  s307 = false == s306;-  const SBool  s308 = s298 < s1;-  const SBool  s309 = s298 < s59;-  const SBool  s310 = s308 || s309;-  const SWord8 s311 = (s298 >> 1) | (s298 << 7);-  const SWord8 s312 = 128 | s311;-  const SWord8 s313 = 127 & s311;-  const SWord8 s314 = s310 ? s312 : s313;-  const SBool  s315 = (SBool) ((s314 >> 0) & 1);-  const SBool  s316 = false != s315;-  const SWord8 s317 = (s301 >> 1) | (s301 << 7);-  const SWord8 s318 = 128 | s317;-  const SWord8 s319 = 127 & s317;-  const SWord8 s320 = s316 ? s318 : s319;-  const SBool  s321 = (SBool) ((s320 >> 0) & 1);-  const SBool  s322 = false != s321;-  const SWord8 s323 = (s304 >> 1) | (s304 << 7);-  const SWord8 s324 = 128 | s323;-  const SWord8 s325 = 127 & s323;-  const SWord8 s326 = s322 ? s324 : s325;-  const SBool  s327 = (SBool) ((s326 >> 0) & 1);-  const SBool  s328 = false != s327;-  const SBool  s329 = false == s328;-  const SWord8 s330 = (s314 >> 1) | (s314 << 7);-  const SWord8 s331 = 128 | s330;-  const SWord8 s332 = 127 & s330;-  const SWord8 s333 = s35 ? s331 : s332;-  const SWord8 s334 = (s333 >> 1) | (s333 << 7);-  const SWord8 s335 = 128 | s334;-  const SWord8 s336 = 127 & s334;-  const SWord8 s337 = s54 ? s335 : s336;-  const SWord8 s338 = (s337 >> 1) | (s337 << 7);-  const SWord8 s339 = 128 | s338;-  const SWord8 s340 = 127 & s338;-  const SWord8 s341 = s306 ? s339 : s340;-  const SWord8 s342 = (s341 >> 1) | (s341 << 7);-  const SWord8 s343 = 128 | s342;-  const SWord8 s344 = 127 & s342;-  const SWord8 s345 = s328 ? s343 : s344;-  const SWord8 s346 = s1 + s341;-  const SBool  s347 = s346 < s1;-  const SBool  s348 = s346 < s341;-  const SBool  s349 = s347 || s348;-  const SWord8 s350 = (s346 >> 1) | (s346 << 7);-  const SWord8 s351 = 128 | s350;-  const SWord8 s352 = 127 & s350;-  const SWord8 s353 = s349 ? s351 : s352;-  const SWord8 s354 = s329 ? s345 : s353;-  const SWord8 s355 = s1 + s337;-  const SBool  s356 = s355 < s1;-  const SBool  s357 = s355 < s337;-  const SBool  s358 = s356 || s357;-  const SWord8 s359 = (s355 >> 1) | (s355 << 7);-  const SWord8 s360 = 128 | s359;-  const SWord8 s361 = 127 & s359;-  const SWord8 s362 = s358 ? s360 : s361;-  const SWord8 s363 = (s362 >> 1) | (s362 << 7);-  const SWord8 s364 = 128 | s363;-  const SWord8 s365 = 127 & s363;-  const SWord8 s366 = s328 ? s364 : s365;-  const SWord8 s367 = s1 + s362;-  const SBool  s368 = s367 < s1;-  const SBool  s369 = s367 < s362;-  const SBool  s370 = s368 || s369;-  const SWord8 s371 = (s367 >> 1) | (s367 << 7);-  const SWord8 s372 = 128 | s371;-  const SWord8 s373 = 127 & s371;-  const SWord8 s374 = s370 ? s372 : s373;-  const SWord8 s375 = s329 ? s366 : s374;-  const SWord8 s376 = s307 ? s354 : s375;-  const SWord8 s377 = s1 + s333;-  const SBool  s378 = s377 < s1;-  const SBool  s379 = s377 < s333;-  const SBool  s380 = s378 || s379;-  const SWord8 s381 = (s377 >> 1) | (s377 << 7);-  const SWord8 s382 = 128 | s381;-  const SWord8 s383 = 127 & s381;-  const SWord8 s384 = s380 ? s382 : s383;-  const SWord8 s385 = (s384 >> 1) | (s384 << 7);-  const SWord8 s386 = 128 | s385;-  const SWord8 s387 = 127 & s385;-  const SWord8 s388 = s306 ? s386 : s387;-  const SWord8 s389 = (s388 >> 1) | (s388 << 7);-  const SWord8 s390 = 128 | s389;-  const SWord8 s391 = 127 & s389;-  const SWord8 s392 = s328 ? s390 : s391;-  const SWord8 s393 = s1 + s388;-  const SBool  s394 = s393 < s1;-  const SBool  s395 = s393 < s388;-  const SBool  s396 = s394 || s395;-  const SWord8 s397 = (s393 >> 1) | (s393 << 7);-  const SWord8 s398 = 128 | s397;-  const SWord8 s399 = 127 & s397;-  const SWord8 s400 = s396 ? s398 : s399;-  const SWord8 s401 = s329 ? s392 : s400;-  const SWord8 s402 = s1 + s384;-  const SBool  s403 = s402 < s1;-  const SBool  s404 = s402 < s384;-  const SBool  s405 = s403 || s404;-  const SWord8 s406 = (s402 >> 1) | (s402 << 7);-  const SWord8 s407 = 128 | s406;-  const SWord8 s408 = 127 & s406;-  const SWord8 s409 = s405 ? s407 : s408;-  const SWord8 s410 = (s409 >> 1) | (s409 << 7);-  const SWord8 s411 = 128 | s410;-  const SWord8 s412 = 127 & s410;-  const SWord8 s413 = s328 ? s411 : s412;-  const SWord8 s414 = s1 + s409;-  const SBool  s415 = s414 < s1;-  const SBool  s416 = s414 < s409;-  const SBool  s417 = s415 || s416;-  const SWord8 s418 = (s414 >> 1) | (s414 << 7);-  const SWord8 s419 = 128 | s418;-  const SWord8 s420 = 127 & s418;-  const SWord8 s421 = s417 ? s419 : s420;-  const SWord8 s422 = s329 ? s413 : s421;-  const SWord8 s423 = s307 ? s401 : s422;-  const SWord8 s424 = s55 ? s376 : s423;-  const SWord8 s425 = s1 + s314;-  const SBool  s426 = (SBool) ((s425 >> 0) & 1);-  const SBool  s427 = false != s426;-  const SWord8 s428 = s427 ? s318 : s319;-  const SBool  s429 = (SBool) ((s428 >> 0) & 1);-  const SBool  s430 = false != s429;-  const SWord8 s431 = s430 ? s324 : s325;-  const SBool  s432 = (SBool) ((s431 >> 0) & 1);-  const SBool  s433 = false != s432;-  const SBool  s434 = false == s433;-  const SBool  s435 = s425 < s1;-  const SBool  s436 = s425 < s314;-  const SBool  s437 = s435 || s436;-  const SWord8 s438 = (s425 >> 1) | (s425 << 7);-  const SWord8 s439 = 128 | s438;-  const SWord8 s440 = 127 & s438;-  const SWord8 s441 = s437 ? s439 : s440;-  const SWord8 s442 = (s441 >> 1) | (s441 << 7);-  const SWord8 s443 = 128 | s442;-  const SWord8 s444 = 127 & s442;-  const SWord8 s445 = s54 ? s443 : s444;-  const SWord8 s446 = (s445 >> 1) | (s445 << 7);-  const SWord8 s447 = 128 | s446;-  const SWord8 s448 = 127 & s446;-  const SWord8 s449 = s306 ? s447 : s448;-  const SWord8 s450 = (s449 >> 1) | (s449 << 7);-  const SWord8 s451 = 128 | s450;-  const SWord8 s452 = 127 & s450;-  const SWord8 s453 = s433 ? s451 : s452;-  const SWord8 s454 = s1 + s449;-  const SBool  s455 = s454 < s1;-  const SBool  s456 = s454 < s449;-  const SBool  s457 = s455 || s456;-  const SWord8 s458 = (s454 >> 1) | (s454 << 7);-  const SWord8 s459 = 128 | s458;-  const SWord8 s460 = 127 & s458;-  const SWord8 s461 = s457 ? s459 : s460;-  const SWord8 s462 = s434 ? s453 : s461;-  const SWord8 s463 = s1 + s445;-  const SBool  s464 = s463 < s1;-  const SBool  s465 = s463 < s445;-  const SBool  s466 = s464 || s465;-  const SWord8 s467 = (s463 >> 1) | (s463 << 7);-  const SWord8 s468 = 128 | s467;-  const SWord8 s469 = 127 & s467;-  const SWord8 s470 = s466 ? s468 : s469;-  const SWord8 s471 = (s470 >> 1) | (s470 << 7);-  const SWord8 s472 = 128 | s471;-  const SWord8 s473 = 127 & s471;-  const SWord8 s474 = s433 ? s472 : s473;-  const SWord8 s475 = s1 + s470;-  const SBool  s476 = s475 < s1;-  const SBool  s477 = s475 < s470;-  const SBool  s478 = s476 || s477;-  const SWord8 s479 = (s475 >> 1) | (s475 << 7);-  const SWord8 s480 = 128 | s479;-  const SWord8 s481 = 127 & s479;-  const SWord8 s482 = s478 ? s480 : s481;-  const SWord8 s483 = s434 ? s474 : s482;-  const SWord8 s484 = s307 ? s462 : s483;-  const SWord8 s485 = s1 + s441;-  const SBool  s486 = s485 < s1;-  const SBool  s487 = s485 < s441;-  const SBool  s488 = s486 || s487;-  const SWord8 s489 = (s485 >> 1) | (s485 << 7);-  const SWord8 s490 = 128 | s489;-  const SWord8 s491 = 127 & s489;-  const SWord8 s492 = s488 ? s490 : s491;-  const SWord8 s493 = (s492 >> 1) | (s492 << 7);-  const SWord8 s494 = 128 | s493;-  const SWord8 s495 = 127 & s493;-  const SWord8 s496 = s306 ? s494 : s495;-  const SWord8 s497 = (s496 >> 1) | (s496 << 7);-  const SWord8 s498 = 128 | s497;-  const SWord8 s499 = 127 & s497;-  const SWord8 s500 = s433 ? s498 : s499;-  const SWord8 s501 = s1 + s496;-  const SBool  s502 = s501 < s1;-  const SBool  s503 = s501 < s496;-  const SBool  s504 = s502 || s503;-  const SWord8 s505 = (s501 >> 1) | (s501 << 7);-  const SWord8 s506 = 128 | s505;-  const SWord8 s507 = 127 & s505;-  const SWord8 s508 = s504 ? s506 : s507;-  const SWord8 s509 = s434 ? s500 : s508;-  const SWord8 s510 = s1 + s492;-  const SBool  s511 = s510 < s1;-  const SBool  s512 = s510 < s492;-  const SBool  s513 = s511 || s512;-  const SWord8 s514 = (s510 >> 1) | (s510 << 7);-  const SWord8 s515 = 128 | s514;-  const SWord8 s516 = 127 & s514;-  const SWord8 s517 = s513 ? s515 : s516;-  const SWord8 s518 = (s517 >> 1) | (s517 << 7);-  const SWord8 s519 = 128 | s518;-  const SWord8 s520 = 127 & s518;-  const SWord8 s521 = s433 ? s519 : s520;-  const SWord8 s522 = s1 + s517;-  const SBool  s523 = s522 < s1;-  const SBool  s524 = s522 < s517;-  const SBool  s525 = s523 || s524;-  const SWord8 s526 = (s522 >> 1) | (s522 << 7);-  const SWord8 s527 = 128 | s526;-  const SWord8 s528 = 127 & s526;-  const SWord8 s529 = s525 ? s527 : s528;-  const SWord8 s530 = s434 ? s521 : s529;-  const SWord8 s531 = s307 ? s509 : s530;-  const SWord8 s532 = s55 ? s484 : s531;-  const SWord8 s533 = s36 ? s424 : s532;-  const SWord8 s534 = s21 ? s297 : s533;-  const SWord8 s535 = s1 + s40;-  const SBool  s536 = (SBool) ((s535 >> 0) & 1);-  const SBool  s537 = false != s536;-  const SWord8 s538 = s537 ? s44 : s45;-  const SBool  s539 = (SBool) ((s538 >> 0) & 1);-  const SBool  s540 = false != s539;-  const SWord8 s541 = s540 ? s50 : s51;-  const SBool  s542 = (SBool) ((s541 >> 0) & 1);-  const SBool  s543 = false != s542;-  const SBool  s544 = false == s543;-  const SBool  s545 = s535 < s1;-  const SBool  s546 = s535 < s40;-  const SBool  s547 = s545 || s546;-  const SWord8 s548 = (s535 >> 1) | (s535 << 7);-  const SWord8 s549 = 128 | s548;-  const SWord8 s550 = 127 & s548;-  const SWord8 s551 = s547 ? s549 : s550;-  const SBool  s552 = (SBool) ((s551 >> 0) & 1);-  const SBool  s553 = false != s552;-  const SWord8 s554 = (s538 >> 1) | (s538 << 7);-  const SWord8 s555 = 128 | s554;-  const SWord8 s556 = 127 & s554;-  const SWord8 s557 = s553 ? s555 : s556;-  const SBool  s558 = (SBool) ((s557 >> 0) & 1);-  const SBool  s559 = false != s558;-  const SWord8 s560 = (s541 >> 1) | (s541 << 7);-  const SWord8 s561 = 128 | s560;-  const SWord8 s562 = 127 & s560;-  const SWord8 s563 = s559 ? s561 : s562;-  const SBool  s564 = (SBool) ((s563 >> 0) & 1);-  const SBool  s565 = false != s564;-  const SBool  s566 = false == s565;-  const SWord8 s567 = (s551 >> 1) | (s551 << 7);-  const SWord8 s568 = 128 | s567;-  const SWord8 s569 = 127 & s567;-  const SWord8 s570 = s20 ? s568 : s569;-  const SBool  s571 = (SBool) ((s570 >> 0) & 1);-  const SBool  s572 = false != s571;-  const SWord8 s573 = (s557 >> 1) | (s557 << 7);-  const SWord8 s574 = 128 | s573;-  const SWord8 s575 = 127 & s573;-  const SWord8 s576 = s572 ? s574 : s575;-  const SBool  s577 = (SBool) ((s576 >> 0) & 1);-  const SBool  s578 = false != s577;-  const SWord8 s579 = (s563 >> 1) | (s563 << 7);-  const SWord8 s580 = 128 | s579;-  const SWord8 s581 = 127 & s579;-  const SWord8 s582 = s578 ? s580 : s581;-  const SBool  s583 = (SBool) ((s582 >> 0) & 1);-  const SBool  s584 = false != s583;-  const SBool  s585 = false == s584;-  const SWord8 s586 = (s570 >> 1) | (s570 << 7);-  const SWord8 s587 = 128 | s586;-  const SWord8 s588 = 127 & s586;-  const SWord8 s589 = s35 ? s587 : s588;-  const SWord8 s590 = (s589 >> 1) | (s589 << 7);-  const SWord8 s591 = 128 | s590;-  const SWord8 s592 = 127 & s590;-  const SWord8 s593 = s543 ? s591 : s592;-  const SWord8 s594 = (s593 >> 1) | (s593 << 7);-  const SWord8 s595 = 128 | s594;-  const SWord8 s596 = 127 & s594;-  const SWord8 s597 = s565 ? s595 : s596;-  const SWord8 s598 = (s597 >> 1) | (s597 << 7);-  const SWord8 s599 = 128 | s598;-  const SWord8 s600 = 127 & s598;-  const SWord8 s601 = s584 ? s599 : s600;-  const SWord8 s602 = s1 + s597;-  const SBool  s603 = s602 < s1;-  const SBool  s604 = s602 < s597;-  const SBool  s605 = s603 || s604;-  const SWord8 s606 = (s602 >> 1) | (s602 << 7);-  const SWord8 s607 = 128 | s606;-  const SWord8 s608 = 127 & s606;-  const SWord8 s609 = s605 ? s607 : s608;-  const SWord8 s610 = s585 ? s601 : s609;-  const SWord8 s611 = s1 + s593;-  const SBool  s612 = s611 < s1;-  const SBool  s613 = s611 < s593;-  const SBool  s614 = s612 || s613;-  const SWord8 s615 = (s611 >> 1) | (s611 << 7);-  const SWord8 s616 = 128 | s615;-  const SWord8 s617 = 127 & s615;-  const SWord8 s618 = s614 ? s616 : s617;-  const SWord8 s619 = (s618 >> 1) | (s618 << 7);-  const SWord8 s620 = 128 | s619;-  const SWord8 s621 = 127 & s619;-  const SWord8 s622 = s584 ? s620 : s621;-  const SWord8 s623 = s1 + s618;-  const SBool  s624 = s623 < s1;-  const SBool  s625 = s623 < s618;-  const SBool  s626 = s624 || s625;-  const SWord8 s627 = (s623 >> 1) | (s623 << 7);-  const SWord8 s628 = 128 | s627;-  const SWord8 s629 = 127 & s627;-  const SWord8 s630 = s626 ? s628 : s629;-  const SWord8 s631 = s585 ? s622 : s630;-  const SWord8 s632 = s566 ? s610 : s631;-  const SWord8 s633 = s1 + s589;-  const SBool  s634 = s633 < s1;-  const SBool  s635 = s633 < s589;-  const SBool  s636 = s634 || s635;-  const SWord8 s637 = (s633 >> 1) | (s633 << 7);-  const SWord8 s638 = 128 | s637;-  const SWord8 s639 = 127 & s637;-  const SWord8 s640 = s636 ? s638 : s639;-  const SWord8 s641 = (s640 >> 1) | (s640 << 7);-  const SWord8 s642 = 128 | s641;-  const SWord8 s643 = 127 & s641;-  const SWord8 s644 = s565 ? s642 : s643;-  const SWord8 s645 = (s644 >> 1) | (s644 << 7);-  const SWord8 s646 = 128 | s645;-  const SWord8 s647 = 127 & s645;-  const SWord8 s648 = s584 ? s646 : s647;-  const SWord8 s649 = s1 + s644;-  const SBool  s650 = s649 < s1;-  const SBool  s651 = s649 < s644;-  const SBool  s652 = s650 || s651;-  const SWord8 s653 = (s649 >> 1) | (s649 << 7);-  const SWord8 s654 = 128 | s653;-  const SWord8 s655 = 127 & s653;-  const SWord8 s656 = s652 ? s654 : s655;-  const SWord8 s657 = s585 ? s648 : s656;-  const SWord8 s658 = s1 + s640;-  const SBool  s659 = s658 < s1;-  const SBool  s660 = s658 < s640;-  const SBool  s661 = s659 || s660;-  const SWord8 s662 = (s658 >> 1) | (s658 << 7);-  const SWord8 s663 = 128 | s662;-  const SWord8 s664 = 127 & s662;-  const SWord8 s665 = s661 ? s663 : s664;-  const SWord8 s666 = (s665 >> 1) | (s665 << 7);-  const SWord8 s667 = 128 | s666;-  const SWord8 s668 = 127 & s666;-  const SWord8 s669 = s584 ? s667 : s668;-  const SWord8 s670 = s1 + s665;-  const SBool  s671 = s670 < s1;-  const SBool  s672 = s670 < s665;-  const SBool  s673 = s671 || s672;-  const SWord8 s674 = (s670 >> 1) | (s670 << 7);-  const SWord8 s675 = 128 | s674;-  const SWord8 s676 = 127 & s674;-  const SWord8 s677 = s673 ? s675 : s676;-  const SWord8 s678 = s585 ? s669 : s677;-  const SWord8 s679 = s566 ? s657 : s678;-  const SWord8 s680 = s544 ? s632 : s679;-  const SWord8 s681 = s1 + s570;-  const SBool  s682 = (SBool) ((s681 >> 0) & 1);-  const SBool  s683 = false != s682;-  const SWord8 s684 = s683 ? s574 : s575;-  const SBool  s685 = (SBool) ((s684 >> 0) & 1);-  const SBool  s686 = false != s685;-  const SWord8 s687 = s686 ? s580 : s581;-  const SBool  s688 = (SBool) ((s687 >> 0) & 1);-  const SBool  s689 = false != s688;-  const SBool  s690 = false == s689;-  const SBool  s691 = s681 < s1;-  const SBool  s692 = s681 < s570;-  const SBool  s693 = s691 || s692;-  const SWord8 s694 = (s681 >> 1) | (s681 << 7);-  const SWord8 s695 = 128 | s694;-  const SWord8 s696 = 127 & s694;-  const SWord8 s697 = s693 ? s695 : s696;-  const SWord8 s698 = (s697 >> 1) | (s697 << 7);-  const SWord8 s699 = 128 | s698;-  const SWord8 s700 = 127 & s698;-  const SWord8 s701 = s543 ? s699 : s700;-  const SWord8 s702 = (s701 >> 1) | (s701 << 7);-  const SWord8 s703 = 128 | s702;-  const SWord8 s704 = 127 & s702;-  const SWord8 s705 = s565 ? s703 : s704;-  const SWord8 s706 = (s705 >> 1) | (s705 << 7);-  const SWord8 s707 = 128 | s706;-  const SWord8 s708 = 127 & s706;-  const SWord8 s709 = s689 ? s707 : s708;-  const SWord8 s710 = s1 + s705;-  const SBool  s711 = s710 < s1;-  const SBool  s712 = s710 < s705;-  const SBool  s713 = s711 || s712;-  const SWord8 s714 = (s710 >> 1) | (s710 << 7);-  const SWord8 s715 = 128 | s714;-  const SWord8 s716 = 127 & s714;-  const SWord8 s717 = s713 ? s715 : s716;-  const SWord8 s718 = s690 ? s709 : s717;-  const SWord8 s719 = s1 + s701;-  const SBool  s720 = s719 < s1;-  const SBool  s721 = s719 < s701;-  const SBool  s722 = s720 || s721;-  const SWord8 s723 = (s719 >> 1) | (s719 << 7);-  const SWord8 s724 = 128 | s723;-  const SWord8 s725 = 127 & s723;-  const SWord8 s726 = s722 ? s724 : s725;-  const SWord8 s727 = (s726 >> 1) | (s726 << 7);-  const SWord8 s728 = 128 | s727;-  const SWord8 s729 = 127 & s727;-  const SWord8 s730 = s689 ? s728 : s729;-  const SWord8 s731 = s1 + s726;-  const SBool  s732 = s731 < s1;-  const SBool  s733 = s731 < s726;-  const SBool  s734 = s732 || s733;-  const SWord8 s735 = (s731 >> 1) | (s731 << 7);-  const SWord8 s736 = 128 | s735;-  const SWord8 s737 = 127 & s735;-  const SWord8 s738 = s734 ? s736 : s737;-  const SWord8 s739 = s690 ? s730 : s738;-  const SWord8 s740 = s566 ? s718 : s739;-  const SWord8 s741 = s1 + s697;-  const SBool  s742 = s741 < s1;-  const SBool  s743 = s741 < s697;-  const SBool  s744 = s742 || s743;-  const SWord8 s745 = (s741 >> 1) | (s741 << 7);-  const SWord8 s746 = 128 | s745;-  const SWord8 s747 = 127 & s745;-  const SWord8 s748 = s744 ? s746 : s747;-  const SWord8 s749 = (s748 >> 1) | (s748 << 7);-  const SWord8 s750 = 128 | s749;-  const SWord8 s751 = 127 & s749;-  const SWord8 s752 = s565 ? s750 : s751;-  const SWord8 s753 = (s752 >> 1) | (s752 << 7);-  const SWord8 s754 = 128 | s753;-  const SWord8 s755 = 127 & s753;-  const SWord8 s756 = s689 ? s754 : s755;-  const SWord8 s757 = s1 + s752;-  const SBool  s758 = s757 < s1;-  const SBool  s759 = s757 < s752;-  const SBool  s760 = s758 || s759;-  const SWord8 s761 = (s757 >> 1) | (s757 << 7);-  const SWord8 s762 = 128 | s761;-  const SWord8 s763 = 127 & s761;-  const SWord8 s764 = s760 ? s762 : s763;-  const SWord8 s765 = s690 ? s756 : s764;-  const SWord8 s766 = s1 + s748;-  const SBool  s767 = s766 < s1;-  const SBool  s768 = s766 < s748;-  const SBool  s769 = s767 || s768;-  const SWord8 s770 = (s766 >> 1) | (s766 << 7);-  const SWord8 s771 = 128 | s770;-  const SWord8 s772 = 127 & s770;-  const SWord8 s773 = s769 ? s771 : s772;-  const SWord8 s774 = (s773 >> 1) | (s773 << 7);-  const SWord8 s775 = 128 | s774;-  const SWord8 s776 = 127 & s774;-  const SWord8 s777 = s689 ? s775 : s776;-  const SWord8 s778 = s1 + s773;-  const SBool  s779 = s778 < s1;-  const SBool  s780 = s778 < s773;-  const SBool  s781 = s779 || s780;-  const SWord8 s782 = (s778 >> 1) | (s778 << 7);-  const SWord8 s783 = 128 | s782;-  const SWord8 s784 = 127 & s782;-  const SWord8 s785 = s781 ? s783 : s784;-  const SWord8 s786 = s690 ? s777 : s785;-  const SWord8 s787 = s566 ? s765 : s786;-  const SWord8 s788 = s544 ? s740 : s787;-  const SWord8 s789 = s36 ? s680 : s788;-  const SWord8 s790 = s1 + s551;-  const SBool  s791 = (SBool) ((s790 >> 0) & 1);-  const SBool  s792 = false != s791;-  const SWord8 s793 = s792 ? s555 : s556;-  const SBool  s794 = (SBool) ((s793 >> 0) & 1);-  const SBool  s795 = false != s794;-  const SWord8 s796 = s795 ? s561 : s562;-  const SBool  s797 = (SBool) ((s796 >> 0) & 1);-  const SBool  s798 = false != s797;-  const SBool  s799 = false == s798;-  const SBool  s800 = s790 < s1;-  const SBool  s801 = s790 < s551;-  const SBool  s802 = s800 || s801;-  const SWord8 s803 = (s790 >> 1) | (s790 << 7);-  const SWord8 s804 = 128 | s803;-  const SWord8 s805 = 127 & s803;-  const SWord8 s806 = s802 ? s804 : s805;-  const SBool  s807 = (SBool) ((s806 >> 0) & 1);-  const SBool  s808 = false != s807;-  const SWord8 s809 = (s793 >> 1) | (s793 << 7);-  const SWord8 s810 = 128 | s809;-  const SWord8 s811 = 127 & s809;-  const SWord8 s812 = s808 ? s810 : s811;-  const SBool  s813 = (SBool) ((s812 >> 0) & 1);-  const SBool  s814 = false != s813;-  const SWord8 s815 = (s796 >> 1) | (s796 << 7);-  const SWord8 s816 = 128 | s815;-  const SWord8 s817 = 127 & s815;-  const SWord8 s818 = s814 ? s816 : s817;-  const SBool  s819 = (SBool) ((s818 >> 0) & 1);-  const SBool  s820 = false != s819;-  const SBool  s821 = false == s820;-  const SWord8 s822 = (s806 >> 1) | (s806 << 7);-  const SWord8 s823 = 128 | s822;-  const SWord8 s824 = 127 & s822;-  const SWord8 s825 = s35 ? s823 : s824;-  const SWord8 s826 = (s825 >> 1) | (s825 << 7);-  const SWord8 s827 = 128 | s826;-  const SWord8 s828 = 127 & s826;-  const SWord8 s829 = s543 ? s827 : s828;-  const SWord8 s830 = (s829 >> 1) | (s829 << 7);-  const SWord8 s831 = 128 | s830;-  const SWord8 s832 = 127 & s830;-  const SWord8 s833 = s798 ? s831 : s832;-  const SWord8 s834 = (s833 >> 1) | (s833 << 7);-  const SWord8 s835 = 128 | s834;-  const SWord8 s836 = 127 & s834;-  const SWord8 s837 = s820 ? s835 : s836;-  const SWord8 s838 = s1 + s833;-  const SBool  s839 = s838 < s1;-  const SBool  s840 = s838 < s833;-  const SBool  s841 = s839 || s840;-  const SWord8 s842 = (s838 >> 1) | (s838 << 7);-  const SWord8 s843 = 128 | s842;-  const SWord8 s844 = 127 & s842;-  const SWord8 s845 = s841 ? s843 : s844;-  const SWord8 s846 = s821 ? s837 : s845;-  const SWord8 s847 = s1 + s829;-  const SBool  s848 = s847 < s1;-  const SBool  s849 = s847 < s829;-  const SBool  s850 = s848 || s849;-  const SWord8 s851 = (s847 >> 1) | (s847 << 7);-  const SWord8 s852 = 128 | s851;-  const SWord8 s853 = 127 & s851;-  const SWord8 s854 = s850 ? s852 : s853;-  const SWord8 s855 = (s854 >> 1) | (s854 << 7);-  const SWord8 s856 = 128 | s855;-  const SWord8 s857 = 127 & s855;-  const SWord8 s858 = s820 ? s856 : s857;-  const SWord8 s859 = s1 + s854;-  const SBool  s860 = s859 < s1;-  const SBool  s861 = s859 < s854;-  const SBool  s862 = s860 || s861;-  const SWord8 s863 = (s859 >> 1) | (s859 << 7);-  const SWord8 s864 = 128 | s863;-  const SWord8 s865 = 127 & s863;-  const SWord8 s866 = s862 ? s864 : s865;-  const SWord8 s867 = s821 ? s858 : s866;-  const SWord8 s868 = s799 ? s846 : s867;-  const SWord8 s869 = s1 + s825;-  const SBool  s870 = s869 < s1;-  const SBool  s871 = s869 < s825;-  const SBool  s872 = s870 || s871;-  const SWord8 s873 = (s869 >> 1) | (s869 << 7);-  const SWord8 s874 = 128 | s873;-  const SWord8 s875 = 127 & s873;-  const SWord8 s876 = s872 ? s874 : s875;-  const SWord8 s877 = (s876 >> 1) | (s876 << 7);-  const SWord8 s878 = 128 | s877;-  const SWord8 s879 = 127 & s877;-  const SWord8 s880 = s798 ? s878 : s879;-  const SWord8 s881 = (s880 >> 1) | (s880 << 7);-  const SWord8 s882 = 128 | s881;-  const SWord8 s883 = 127 & s881;-  const SWord8 s884 = s820 ? s882 : s883;-  const SWord8 s885 = s1 + s880;-  const SBool  s886 = s885 < s1;-  const SBool  s887 = s885 < s880;-  const SBool  s888 = s886 || s887;-  const SWord8 s889 = (s885 >> 1) | (s885 << 7);-  const SWord8 s890 = 128 | s889;-  const SWord8 s891 = 127 & s889;-  const SWord8 s892 = s888 ? s890 : s891;-  const SWord8 s893 = s821 ? s884 : s892;-  const SWord8 s894 = s1 + s876;-  const SBool  s895 = s894 < s1;-  const SBool  s896 = s894 < s876;-  const SBool  s897 = s895 || s896;-  const SWord8 s898 = (s894 >> 1) | (s894 << 7);-  const SWord8 s899 = 128 | s898;-  const SWord8 s900 = 127 & s898;-  const SWord8 s901 = s897 ? s899 : s900;-  const SWord8 s902 = (s901 >> 1) | (s901 << 7);-  const SWord8 s903 = 128 | s902;-  const SWord8 s904 = 127 & s902;-  const SWord8 s905 = s820 ? s903 : s904;-  const SWord8 s906 = s1 + s901;-  const SBool  s907 = s906 < s1;-  const SBool  s908 = s906 < s901;-  const SBool  s909 = s907 || s908;-  const SWord8 s910 = (s906 >> 1) | (s906 << 7);-  const SWord8 s911 = 128 | s910;-  const SWord8 s912 = 127 & s910;-  const SWord8 s913 = s909 ? s911 : s912;-  const SWord8 s914 = s821 ? s905 : s913;-  const SWord8 s915 = s799 ? s893 : s914;-  const SWord8 s916 = s544 ? s868 : s915;-  const SWord8 s917 = s1 + s806;-  const SBool  s918 = (SBool) ((s917 >> 0) & 1);-  const SBool  s919 = false != s918;-  const SWord8 s920 = s919 ? s810 : s811;-  const SBool  s921 = (SBool) ((s920 >> 0) & 1);-  const SBool  s922 = false != s921;-  const SWord8 s923 = s922 ? s816 : s817;-  const SBool  s924 = (SBool) ((s923 >> 0) & 1);-  const SBool  s925 = false != s924;-  const SBool  s926 = false == s925;-  const SBool  s927 = s917 < s1;-  const SBool  s928 = s917 < s806;-  const SBool  s929 = s927 || s928;-  const SWord8 s930 = (s917 >> 1) | (s917 << 7);-  const SWord8 s931 = 128 | s930;-  const SWord8 s932 = 127 & s930;-  const SWord8 s933 = s929 ? s931 : s932;-  const SWord8 s934 = (s933 >> 1) | (s933 << 7);-  const SWord8 s935 = 128 | s934;-  const SWord8 s936 = 127 & s934;-  const SWord8 s937 = s543 ? s935 : s936;-  const SWord8 s938 = (s937 >> 1) | (s937 << 7);-  const SWord8 s939 = 128 | s938;-  const SWord8 s940 = 127 & s938;-  const SWord8 s941 = s798 ? s939 : s940;-  const SWord8 s942 = (s941 >> 1) | (s941 << 7);-  const SWord8 s943 = 128 | s942;-  const SWord8 s944 = 127 & s942;-  const SWord8 s945 = s925 ? s943 : s944;-  const SWord8 s946 = s1 + s941;-  const SBool  s947 = s946 < s1;-  const SBool  s948 = s946 < s941;-  const SBool  s949 = s947 || s948;-  const SWord8 s950 = (s946 >> 1) | (s946 << 7);-  const SWord8 s951 = 128 | s950;-  const SWord8 s952 = 127 & s950;-  const SWord8 s953 = s949 ? s951 : s952;-  const SWord8 s954 = s926 ? s945 : s953;-  const SWord8 s955 = s1 + s937;-  const SBool  s956 = s955 < s1;-  const SBool  s957 = s955 < s937;-  const SBool  s958 = s956 || s957;-  const SWord8 s959 = (s955 >> 1) | (s955 << 7);-  const SWord8 s960 = 128 | s959;-  const SWord8 s961 = 127 & s959;-  const SWord8 s962 = s958 ? s960 : s961;-  const SWord8 s963 = (s962 >> 1) | (s962 << 7);-  const SWord8 s964 = 128 | s963;-  const SWord8 s965 = 127 & s963;-  const SWord8 s966 = s925 ? s964 : s965;-  const SWord8 s967 = s1 + s962;-  const SBool  s968 = s967 < s1;-  const SBool  s969 = s967 < s962;-  const SBool  s970 = s968 || s969;-  const SWord8 s971 = (s967 >> 1) | (s967 << 7);-  const SWord8 s972 = 128 | s971;-  const SWord8 s973 = 127 & s971;-  const SWord8 s974 = s970 ? s972 : s973;-  const SWord8 s975 = s926 ? s966 : s974;-  const SWord8 s976 = s799 ? s954 : s975;-  const SWord8 s977 = s1 + s933;-  const SBool  s978 = s977 < s1;-  const SBool  s979 = s977 < s933;-  const SBool  s980 = s978 || s979;-  const SWord8 s981 = (s977 >> 1) | (s977 << 7);-  const SWord8 s982 = 128 | s981;-  const SWord8 s983 = 127 & s981;-  const SWord8 s984 = s980 ? s982 : s983;-  const SWord8 s985 = (s984 >> 1) | (s984 << 7);-  const SWord8 s986 = 128 | s985;-  const SWord8 s987 = 127 & s985;-  const SWord8 s988 = s798 ? s986 : s987;-  const SWord8 s989 = (s988 >> 1) | (s988 << 7);-  const SWord8 s990 = 128 | s989;-  const SWord8 s991 = 127 & s989;-  const SWord8 s992 = s925 ? s990 : s991;-  const SWord8 s993 = s1 + s988;-  const SBool  s994 = s993 < s1;-  const SBool  s995 = s993 < s988;-  const SBool  s996 = s994 || s995;-  const SWord8 s997 = (s993 >> 1) | (s993 << 7);-  const SWord8 s998 = 128 | s997;-  const SWord8 s999 = 127 & s997;-  const SWord8 s1000 = s996 ? s998 : s999;-  const SWord8 s1001 = s926 ? s992 : s1000;-  const SWord8 s1002 = s1 + s984;-  const SBool  s1003 = s1002 < s1;-  const SBool  s1004 = s1002 < s984;-  const SBool  s1005 = s1003 || s1004;-  const SWord8 s1006 = (s1002 >> 1) | (s1002 << 7);-  const SWord8 s1007 = 128 | s1006;-  const SWord8 s1008 = 127 & s1006;-  const SWord8 s1009 = s1005 ? s1007 : s1008;-  const SWord8 s1010 = (s1009 >> 1) | (s1009 << 7);-  const SWord8 s1011 = 128 | s1010;-  const SWord8 s1012 = 127 & s1010;-  const SWord8 s1013 = s925 ? s1011 : s1012;-  const SWord8 s1014 = s1 + s1009;-  const SBool  s1015 = s1014 < s1;-  const SBool  s1016 = s1014 < s1009;-  const SBool  s1017 = s1015 || s1016;-  const SWord8 s1018 = (s1014 >> 1) | (s1014 << 7);-  const SWord8 s1019 = 128 | s1018;-  const SWord8 s1020 = 127 & s1018;-  const SWord8 s1021 = s1017 ? s1019 : s1020;-  const SWord8 s1022 = s926 ? s1013 : s1021;-  const SWord8 s1023 = s799 ? s1001 : s1022;-  const SWord8 s1024 = s544 ? s976 : s1023;-  const SWord8 s1025 = s36 ? s916 : s1024;-  const SWord8 s1026 = s21 ? s789 : s1025;-  const SWord8 s1027 = s16 ? s534 : s1026;-  const SWord8 s1028 = s1 + s24;-  const SBool  s1029 = (SBool) ((s1028 >> 0) & 1);-  const SBool  s1030 = false != s1029;-  const SWord8 s1031 = s1030 ? 128 : 0;-  const SBool  s1032 = (SBool) ((s1031 >> 0) & 1);-  const SBool  s1033 = false != s1032;-  const SWord8 s1034 = s1033 ? s31 : s32;-  const SBool  s1035 = (SBool) ((s1034 >> 0) & 1);-  const SBool  s1036 = false != s1035;-  const SBool  s1037 = false == s1036;-  const SBool  s1038 = s1028 < s1;-  const SBool  s1039 = s1028 < s24;-  const SBool  s1040 = s1038 || s1039;-  const SWord8 s1041 = (s1028 >> 1) | (s1028 << 7);-  const SWord8 s1042 = 128 | s1041;-  const SWord8 s1043 = 127 & s1041;-  const SWord8 s1044 = s1040 ? s1042 : s1043;-  const SBool  s1045 = (SBool) ((s1044 >> 0) & 1);-  const SBool  s1046 = false != s1045;-  const SWord8 s1047 = (s1031 >> 1) | (s1031 << 7);-  const SWord8 s1048 = 128 | s1047;-  const SWord8 s1049 = 127 & s1047;-  const SWord8 s1050 = s1046 ? s1048 : s1049;-  const SBool  s1051 = (SBool) ((s1050 >> 0) & 1);-  const SBool  s1052 = false != s1051;-  const SWord8 s1053 = (s1034 >> 1) | (s1034 << 7);-  const SWord8 s1054 = 128 | s1053;-  const SWord8 s1055 = 127 & s1053;-  const SWord8 s1056 = s1052 ? s1054 : s1055;-  const SBool  s1057 = (SBool) ((s1056 >> 0) & 1);-  const SBool  s1058 = false != s1057;-  const SBool  s1059 = false == s1058;-  const SWord8 s1060 = (s1044 >> 1) | (s1044 << 7);-  const SWord8 s1061 = 128 | s1060;-  const SWord8 s1062 = 127 & s1060;-  const SWord8 s1063 = s15 ? s1061 : s1062;-  const SBool  s1064 = (SBool) ((s1063 >> 0) & 1);-  const SBool  s1065 = false != s1064;-  const SWord8 s1066 = (s1050 >> 1) | (s1050 << 7);-  const SWord8 s1067 = 128 | s1066;-  const SWord8 s1068 = 127 & s1066;-  const SWord8 s1069 = s1065 ? s1067 : s1068;-  const SBool  s1070 = (SBool) ((s1069 >> 0) & 1);-  const SBool  s1071 = false != s1070;-  const SWord8 s1072 = (s1056 >> 1) | (s1056 << 7);-  const SWord8 s1073 = 128 | s1072;-  const SWord8 s1074 = 127 & s1072;-  const SWord8 s1075 = s1071 ? s1073 : s1074;-  const SBool  s1076 = (SBool) ((s1075 >> 0) & 1);-  const SBool  s1077 = false != s1076;-  const SBool  s1078 = false == s1077;-  const SWord8 s1079 = (s1063 >> 1) | (s1063 << 7);-  const SWord8 s1080 = 128 | s1079;-  const SWord8 s1081 = 127 & s1079;-  const SWord8 s1082 = s20 ? s1080 : s1081;-  const SBool  s1083 = (SBool) ((s1082 >> 0) & 1);-  const SBool  s1084 = false != s1083;-  const SWord8 s1085 = (s1069 >> 1) | (s1069 << 7);-  const SWord8 s1086 = 128 | s1085;-  const SWord8 s1087 = 127 & s1085;-  const SWord8 s1088 = s1084 ? s1086 : s1087;-  const SBool  s1089 = (SBool) ((s1088 >> 0) & 1);-  const SBool  s1090 = false != s1089;-  const SWord8 s1091 = (s1075 >> 1) | (s1075 << 7);-  const SWord8 s1092 = 128 | s1091;-  const SWord8 s1093 = 127 & s1091;-  const SWord8 s1094 = s1090 ? s1092 : s1093;-  const SBool  s1095 = (SBool) ((s1094 >> 0) & 1);-  const SBool  s1096 = false != s1095;-  const SBool  s1097 = false == s1096;-  const SWord8 s1098 = (s1082 >> 1) | (s1082 << 7);-  const SWord8 s1099 = 128 | s1098;-  const SWord8 s1100 = 127 & s1098;-  const SWord8 s1101 = s1036 ? s1099 : s1100;-  const SWord8 s1102 = (s1101 >> 1) | (s1101 << 7);-  const SWord8 s1103 = 128 | s1102;-  const SWord8 s1104 = 127 & s1102;-  const SWord8 s1105 = s1058 ? s1103 : s1104;-  const SWord8 s1106 = (s1105 >> 1) | (s1105 << 7);-  const SWord8 s1107 = 128 | s1106;-  const SWord8 s1108 = 127 & s1106;-  const SWord8 s1109 = s1077 ? s1107 : s1108;-  const SWord8 s1110 = (s1109 >> 1) | (s1109 << 7);-  const SWord8 s1111 = 128 | s1110;-  const SWord8 s1112 = 127 & s1110;-  const SWord8 s1113 = s1096 ? s1111 : s1112;-  const SWord8 s1114 = s1 + s1109;-  const SBool  s1115 = s1114 < s1;-  const SBool  s1116 = s1114 < s1109;-  const SBool  s1117 = s1115 || s1116;-  const SWord8 s1118 = (s1114 >> 1) | (s1114 << 7);-  const SWord8 s1119 = 128 | s1118;-  const SWord8 s1120 = 127 & s1118;-  const SWord8 s1121 = s1117 ? s1119 : s1120;-  const SWord8 s1122 = s1097 ? s1113 : s1121;-  const SWord8 s1123 = s1 + s1105;-  const SBool  s1124 = s1123 < s1;-  const SBool  s1125 = s1123 < s1105;-  const SBool  s1126 = s1124 || s1125;-  const SWord8 s1127 = (s1123 >> 1) | (s1123 << 7);-  const SWord8 s1128 = 128 | s1127;-  const SWord8 s1129 = 127 & s1127;-  const SWord8 s1130 = s1126 ? s1128 : s1129;-  const SWord8 s1131 = (s1130 >> 1) | (s1130 << 7);-  const SWord8 s1132 = 128 | s1131;-  const SWord8 s1133 = 127 & s1131;-  const SWord8 s1134 = s1096 ? s1132 : s1133;-  const SWord8 s1135 = s1 + s1130;-  const SBool  s1136 = s1135 < s1;-  const SBool  s1137 = s1135 < s1130;-  const SBool  s1138 = s1136 || s1137;-  const SWord8 s1139 = (s1135 >> 1) | (s1135 << 7);-  const SWord8 s1140 = 128 | s1139;-  const SWord8 s1141 = 127 & s1139;-  const SWord8 s1142 = s1138 ? s1140 : s1141;-  const SWord8 s1143 = s1097 ? s1134 : s1142;-  const SWord8 s1144 = s1078 ? s1122 : s1143;-  const SWord8 s1145 = s1 + s1101;-  const SBool  s1146 = s1145 < s1;-  const SBool  s1147 = s1145 < s1101;-  const SBool  s1148 = s1146 || s1147;-  const SWord8 s1149 = (s1145 >> 1) | (s1145 << 7);-  const SWord8 s1150 = 128 | s1149;-  const SWord8 s1151 = 127 & s1149;-  const SWord8 s1152 = s1148 ? s1150 : s1151;-  const SWord8 s1153 = (s1152 >> 1) | (s1152 << 7);-  const SWord8 s1154 = 128 | s1153;-  const SWord8 s1155 = 127 & s1153;-  const SWord8 s1156 = s1077 ? s1154 : s1155;-  const SWord8 s1157 = (s1156 >> 1) | (s1156 << 7);-  const SWord8 s1158 = 128 | s1157;-  const SWord8 s1159 = 127 & s1157;-  const SWord8 s1160 = s1096 ? s1158 : s1159;-  const SWord8 s1161 = s1 + s1156;-  const SBool  s1162 = s1161 < s1;-  const SBool  s1163 = s1161 < s1156;-  const SBool  s1164 = s1162 || s1163;-  const SWord8 s1165 = (s1161 >> 1) | (s1161 << 7);-  const SWord8 s1166 = 128 | s1165;-  const SWord8 s1167 = 127 & s1165;-  const SWord8 s1168 = s1164 ? s1166 : s1167;-  const SWord8 s1169 = s1097 ? s1160 : s1168;-  const SWord8 s1170 = s1 + s1152;-  const SBool  s1171 = s1170 < s1;-  const SBool  s1172 = s1170 < s1152;-  const SBool  s1173 = s1171 || s1172;-  const SWord8 s1174 = (s1170 >> 1) | (s1170 << 7);-  const SWord8 s1175 = 128 | s1174;-  const SWord8 s1176 = 127 & s1174;-  const SWord8 s1177 = s1173 ? s1175 : s1176;-  const SWord8 s1178 = (s1177 >> 1) | (s1177 << 7);-  const SWord8 s1179 = 128 | s1178;-  const SWord8 s1180 = 127 & s1178;-  const SWord8 s1181 = s1096 ? s1179 : s1180;-  const SWord8 s1182 = s1 + s1177;-  const SBool  s1183 = s1182 < s1;-  const SBool  s1184 = s1182 < s1177;-  const SBool  s1185 = s1183 || s1184;-  const SWord8 s1186 = (s1182 >> 1) | (s1182 << 7);-  const SWord8 s1187 = 128 | s1186;-  const SWord8 s1188 = 127 & s1186;-  const SWord8 s1189 = s1185 ? s1187 : s1188;-  const SWord8 s1190 = s1097 ? s1181 : s1189;-  const SWord8 s1191 = s1078 ? s1169 : s1190;-  const SWord8 s1192 = s1059 ? s1144 : s1191;-  const SWord8 s1193 = s1 + s1082;-  const SBool  s1194 = (SBool) ((s1193 >> 0) & 1);-  const SBool  s1195 = false != s1194;-  const SWord8 s1196 = s1195 ? s1086 : s1087;-  const SBool  s1197 = (SBool) ((s1196 >> 0) & 1);-  const SBool  s1198 = false != s1197;-  const SWord8 s1199 = s1198 ? s1092 : s1093;-  const SBool  s1200 = (SBool) ((s1199 >> 0) & 1);-  const SBool  s1201 = false != s1200;-  const SBool  s1202 = false == s1201;-  const SBool  s1203 = s1193 < s1;-  const SBool  s1204 = s1193 < s1082;-  const SBool  s1205 = s1203 || s1204;-  const SWord8 s1206 = (s1193 >> 1) | (s1193 << 7);-  const SWord8 s1207 = 128 | s1206;-  const SWord8 s1208 = 127 & s1206;-  const SWord8 s1209 = s1205 ? s1207 : s1208;-  const SWord8 s1210 = (s1209 >> 1) | (s1209 << 7);-  const SWord8 s1211 = 128 | s1210;-  const SWord8 s1212 = 127 & s1210;-  const SWord8 s1213 = s1058 ? s1211 : s1212;-  const SWord8 s1214 = (s1213 >> 1) | (s1213 << 7);-  const SWord8 s1215 = 128 | s1214;-  const SWord8 s1216 = 127 & s1214;-  const SWord8 s1217 = s1077 ? s1215 : s1216;-  const SWord8 s1218 = (s1217 >> 1) | (s1217 << 7);-  const SWord8 s1219 = 128 | s1218;-  const SWord8 s1220 = 127 & s1218;-  const SWord8 s1221 = s1201 ? s1219 : s1220;-  const SWord8 s1222 = s1 + s1217;-  const SBool  s1223 = s1222 < s1;-  const SBool  s1224 = s1222 < s1217;-  const SBool  s1225 = s1223 || s1224;-  const SWord8 s1226 = (s1222 >> 1) | (s1222 << 7);-  const SWord8 s1227 = 128 | s1226;-  const SWord8 s1228 = 127 & s1226;-  const SWord8 s1229 = s1225 ? s1227 : s1228;-  const SWord8 s1230 = s1202 ? s1221 : s1229;-  const SWord8 s1231 = s1 + s1213;-  const SBool  s1232 = s1231 < s1;-  const SBool  s1233 = s1231 < s1213;-  const SBool  s1234 = s1232 || s1233;-  const SWord8 s1235 = (s1231 >> 1) | (s1231 << 7);-  const SWord8 s1236 = 128 | s1235;-  const SWord8 s1237 = 127 & s1235;-  const SWord8 s1238 = s1234 ? s1236 : s1237;-  const SWord8 s1239 = (s1238 >> 1) | (s1238 << 7);-  const SWord8 s1240 = 128 | s1239;-  const SWord8 s1241 = 127 & s1239;-  const SWord8 s1242 = s1201 ? s1240 : s1241;-  const SWord8 s1243 = s1 + s1238;-  const SBool  s1244 = s1243 < s1;-  const SBool  s1245 = s1243 < s1238;-  const SBool  s1246 = s1244 || s1245;-  const SWord8 s1247 = (s1243 >> 1) | (s1243 << 7);-  const SWord8 s1248 = 128 | s1247;-  const SWord8 s1249 = 127 & s1247;-  const SWord8 s1250 = s1246 ? s1248 : s1249;-  const SWord8 s1251 = s1202 ? s1242 : s1250;-  const SWord8 s1252 = s1078 ? s1230 : s1251;-  const SWord8 s1253 = s1 + s1209;-  const SBool  s1254 = s1253 < s1;-  const SBool  s1255 = s1253 < s1209;-  const SBool  s1256 = s1254 || s1255;-  const SWord8 s1257 = (s1253 >> 1) | (s1253 << 7);-  const SWord8 s1258 = 128 | s1257;-  const SWord8 s1259 = 127 & s1257;-  const SWord8 s1260 = s1256 ? s1258 : s1259;-  const SWord8 s1261 = (s1260 >> 1) | (s1260 << 7);-  const SWord8 s1262 = 128 | s1261;-  const SWord8 s1263 = 127 & s1261;-  const SWord8 s1264 = s1077 ? s1262 : s1263;-  const SWord8 s1265 = (s1264 >> 1) | (s1264 << 7);-  const SWord8 s1266 = 128 | s1265;-  const SWord8 s1267 = 127 & s1265;-  const SWord8 s1268 = s1201 ? s1266 : s1267;-  const SWord8 s1269 = s1 + s1264;-  const SBool  s1270 = s1269 < s1;-  const SBool  s1271 = s1269 < s1264;-  const SBool  s1272 = s1270 || s1271;-  const SWord8 s1273 = (s1269 >> 1) | (s1269 << 7);-  const SWord8 s1274 = 128 | s1273;-  const SWord8 s1275 = 127 & s1273;-  const SWord8 s1276 = s1272 ? s1274 : s1275;-  const SWord8 s1277 = s1202 ? s1268 : s1276;-  const SWord8 s1278 = s1 + s1260;-  const SBool  s1279 = s1278 < s1;-  const SBool  s1280 = s1278 < s1260;-  const SBool  s1281 = s1279 || s1280;-  const SWord8 s1282 = (s1278 >> 1) | (s1278 << 7);-  const SWord8 s1283 = 128 | s1282;-  const SWord8 s1284 = 127 & s1282;-  const SWord8 s1285 = s1281 ? s1283 : s1284;-  const SWord8 s1286 = (s1285 >> 1) | (s1285 << 7);-  const SWord8 s1287 = 128 | s1286;-  const SWord8 s1288 = 127 & s1286;-  const SWord8 s1289 = s1201 ? s1287 : s1288;-  const SWord8 s1290 = s1 + s1285;-  const SBool  s1291 = s1290 < s1;-  const SBool  s1292 = s1290 < s1285;-  const SBool  s1293 = s1291 || s1292;-  const SWord8 s1294 = (s1290 >> 1) | (s1290 << 7);-  const SWord8 s1295 = 128 | s1294;-  const SWord8 s1296 = 127 & s1294;-  const SWord8 s1297 = s1293 ? s1295 : s1296;-  const SWord8 s1298 = s1202 ? s1289 : s1297;-  const SWord8 s1299 = s1078 ? s1277 : s1298;-  const SWord8 s1300 = s1059 ? s1252 : s1299;-  const SWord8 s1301 = s1037 ? s1192 : s1300;-  const SWord8 s1302 = s1 + s1063;-  const SBool  s1303 = (SBool) ((s1302 >> 0) & 1);-  const SBool  s1304 = false != s1303;-  const SWord8 s1305 = s1304 ? s1067 : s1068;-  const SBool  s1306 = (SBool) ((s1305 >> 0) & 1);-  const SBool  s1307 = false != s1306;-  const SWord8 s1308 = s1307 ? s1073 : s1074;-  const SBool  s1309 = (SBool) ((s1308 >> 0) & 1);-  const SBool  s1310 = false != s1309;-  const SBool  s1311 = false == s1310;-  const SBool  s1312 = s1302 < s1;-  const SBool  s1313 = s1302 < s1063;-  const SBool  s1314 = s1312 || s1313;-  const SWord8 s1315 = (s1302 >> 1) | (s1302 << 7);-  const SWord8 s1316 = 128 | s1315;-  const SWord8 s1317 = 127 & s1315;-  const SWord8 s1318 = s1314 ? s1316 : s1317;-  const SBool  s1319 = (SBool) ((s1318 >> 0) & 1);-  const SBool  s1320 = false != s1319;-  const SWord8 s1321 = (s1305 >> 1) | (s1305 << 7);-  const SWord8 s1322 = 128 | s1321;-  const SWord8 s1323 = 127 & s1321;-  const SWord8 s1324 = s1320 ? s1322 : s1323;-  const SBool  s1325 = (SBool) ((s1324 >> 0) & 1);-  const SBool  s1326 = false != s1325;-  const SWord8 s1327 = (s1308 >> 1) | (s1308 << 7);-  const SWord8 s1328 = 128 | s1327;-  const SWord8 s1329 = 127 & s1327;-  const SWord8 s1330 = s1326 ? s1328 : s1329;-  const SBool  s1331 = (SBool) ((s1330 >> 0) & 1);-  const SBool  s1332 = false != s1331;-  const SBool  s1333 = false == s1332;-  const SWord8 s1334 = (s1318 >> 1) | (s1318 << 7);-  const SWord8 s1335 = 128 | s1334;-  const SWord8 s1336 = 127 & s1334;-  const SWord8 s1337 = s1036 ? s1335 : s1336;-  const SWord8 s1338 = (s1337 >> 1) | (s1337 << 7);-  const SWord8 s1339 = 128 | s1338;-  const SWord8 s1340 = 127 & s1338;-  const SWord8 s1341 = s1058 ? s1339 : s1340;-  const SWord8 s1342 = (s1341 >> 1) | (s1341 << 7);-  const SWord8 s1343 = 128 | s1342;-  const SWord8 s1344 = 127 & s1342;-  const SWord8 s1345 = s1310 ? s1343 : s1344;-  const SWord8 s1346 = (s1345 >> 1) | (s1345 << 7);-  const SWord8 s1347 = 128 | s1346;-  const SWord8 s1348 = 127 & s1346;-  const SWord8 s1349 = s1332 ? s1347 : s1348;-  const SWord8 s1350 = s1 + s1345;-  const SBool  s1351 = s1350 < s1;-  const SBool  s1352 = s1350 < s1345;-  const SBool  s1353 = s1351 || s1352;-  const SWord8 s1354 = (s1350 >> 1) | (s1350 << 7);-  const SWord8 s1355 = 128 | s1354;-  const SWord8 s1356 = 127 & s1354;-  const SWord8 s1357 = s1353 ? s1355 : s1356;-  const SWord8 s1358 = s1333 ? s1349 : s1357;-  const SWord8 s1359 = s1 + s1341;-  const SBool  s1360 = s1359 < s1;-  const SBool  s1361 = s1359 < s1341;-  const SBool  s1362 = s1360 || s1361;-  const SWord8 s1363 = (s1359 >> 1) | (s1359 << 7);-  const SWord8 s1364 = 128 | s1363;-  const SWord8 s1365 = 127 & s1363;-  const SWord8 s1366 = s1362 ? s1364 : s1365;-  const SWord8 s1367 = (s1366 >> 1) | (s1366 << 7);-  const SWord8 s1368 = 128 | s1367;-  const SWord8 s1369 = 127 & s1367;-  const SWord8 s1370 = s1332 ? s1368 : s1369;-  const SWord8 s1371 = s1 + s1366;-  const SBool  s1372 = s1371 < s1;-  const SBool  s1373 = s1371 < s1366;-  const SBool  s1374 = s1372 || s1373;-  const SWord8 s1375 = (s1371 >> 1) | (s1371 << 7);-  const SWord8 s1376 = 128 | s1375;-  const SWord8 s1377 = 127 & s1375;-  const SWord8 s1378 = s1374 ? s1376 : s1377;-  const SWord8 s1379 = s1333 ? s1370 : s1378;-  const SWord8 s1380 = s1311 ? s1358 : s1379;-  const SWord8 s1381 = s1 + s1337;-  const SBool  s1382 = s1381 < s1;-  const SBool  s1383 = s1381 < s1337;-  const SBool  s1384 = s1382 || s1383;-  const SWord8 s1385 = (s1381 >> 1) | (s1381 << 7);-  const SWord8 s1386 = 128 | s1385;-  const SWord8 s1387 = 127 & s1385;-  const SWord8 s1388 = s1384 ? s1386 : s1387;-  const SWord8 s1389 = (s1388 >> 1) | (s1388 << 7);-  const SWord8 s1390 = 128 | s1389;-  const SWord8 s1391 = 127 & s1389;-  const SWord8 s1392 = s1310 ? s1390 : s1391;-  const SWord8 s1393 = (s1392 >> 1) | (s1392 << 7);-  const SWord8 s1394 = 128 | s1393;-  const SWord8 s1395 = 127 & s1393;-  const SWord8 s1396 = s1332 ? s1394 : s1395;-  const SWord8 s1397 = s1 + s1392;-  const SBool  s1398 = s1397 < s1;-  const SBool  s1399 = s1397 < s1392;-  const SBool  s1400 = s1398 || s1399;-  const SWord8 s1401 = (s1397 >> 1) | (s1397 << 7);-  const SWord8 s1402 = 128 | s1401;-  const SWord8 s1403 = 127 & s1401;-  const SWord8 s1404 = s1400 ? s1402 : s1403;-  const SWord8 s1405 = s1333 ? s1396 : s1404;-  const SWord8 s1406 = s1 + s1388;-  const SBool  s1407 = s1406 < s1;-  const SBool  s1408 = s1406 < s1388;-  const SBool  s1409 = s1407 || s1408;-  const SWord8 s1410 = (s1406 >> 1) | (s1406 << 7);-  const SWord8 s1411 = 128 | s1410;-  const SWord8 s1412 = 127 & s1410;-  const SWord8 s1413 = s1409 ? s1411 : s1412;-  const SWord8 s1414 = (s1413 >> 1) | (s1413 << 7);-  const SWord8 s1415 = 128 | s1414;-  const SWord8 s1416 = 127 & s1414;-  const SWord8 s1417 = s1332 ? s1415 : s1416;-  const SWord8 s1418 = s1 + s1413;-  const SBool  s1419 = s1418 < s1;-  const SBool  s1420 = s1418 < s1413;-  const SBool  s1421 = s1419 || s1420;-  const SWord8 s1422 = (s1418 >> 1) | (s1418 << 7);-  const SWord8 s1423 = 128 | s1422;-  const SWord8 s1424 = 127 & s1422;-  const SWord8 s1425 = s1421 ? s1423 : s1424;-  const SWord8 s1426 = s1333 ? s1417 : s1425;-  const SWord8 s1427 = s1311 ? s1405 : s1426;-  const SWord8 s1428 = s1059 ? s1380 : s1427;-  const SWord8 s1429 = s1 + s1318;-  const SBool  s1430 = (SBool) ((s1429 >> 0) & 1);-  const SBool  s1431 = false != s1430;-  const SWord8 s1432 = s1431 ? s1322 : s1323;-  const SBool  s1433 = (SBool) ((s1432 >> 0) & 1);-  const SBool  s1434 = false != s1433;-  const SWord8 s1435 = s1434 ? s1328 : s1329;-  const SBool  s1436 = (SBool) ((s1435 >> 0) & 1);-  const SBool  s1437 = false != s1436;-  const SBool  s1438 = false == s1437;-  const SBool  s1439 = s1429 < s1;-  const SBool  s1440 = s1429 < s1318;-  const SBool  s1441 = s1439 || s1440;-  const SWord8 s1442 = (s1429 >> 1) | (s1429 << 7);-  const SWord8 s1443 = 128 | s1442;-  const SWord8 s1444 = 127 & s1442;-  const SWord8 s1445 = s1441 ? s1443 : s1444;-  const SWord8 s1446 = (s1445 >> 1) | (s1445 << 7);-  const SWord8 s1447 = 128 | s1446;-  const SWord8 s1448 = 127 & s1446;-  const SWord8 s1449 = s1058 ? s1447 : s1448;-  const SWord8 s1450 = (s1449 >> 1) | (s1449 << 7);-  const SWord8 s1451 = 128 | s1450;-  const SWord8 s1452 = 127 & s1450;-  const SWord8 s1453 = s1310 ? s1451 : s1452;-  const SWord8 s1454 = (s1453 >> 1) | (s1453 << 7);-  const SWord8 s1455 = 128 | s1454;-  const SWord8 s1456 = 127 & s1454;-  const SWord8 s1457 = s1437 ? s1455 : s1456;-  const SWord8 s1458 = s1 + s1453;-  const SBool  s1459 = s1458 < s1;-  const SBool  s1460 = s1458 < s1453;-  const SBool  s1461 = s1459 || s1460;-  const SWord8 s1462 = (s1458 >> 1) | (s1458 << 7);-  const SWord8 s1463 = 128 | s1462;-  const SWord8 s1464 = 127 & s1462;-  const SWord8 s1465 = s1461 ? s1463 : s1464;-  const SWord8 s1466 = s1438 ? s1457 : s1465;-  const SWord8 s1467 = s1 + s1449;-  const SBool  s1468 = s1467 < s1;-  const SBool  s1469 = s1467 < s1449;-  const SBool  s1470 = s1468 || s1469;-  const SWord8 s1471 = (s1467 >> 1) | (s1467 << 7);-  const SWord8 s1472 = 128 | s1471;-  const SWord8 s1473 = 127 & s1471;-  const SWord8 s1474 = s1470 ? s1472 : s1473;-  const SWord8 s1475 = (s1474 >> 1) | (s1474 << 7);-  const SWord8 s1476 = 128 | s1475;-  const SWord8 s1477 = 127 & s1475;-  const SWord8 s1478 = s1437 ? s1476 : s1477;-  const SWord8 s1479 = s1 + s1474;-  const SBool  s1480 = s1479 < s1;-  const SBool  s1481 = s1479 < s1474;-  const SBool  s1482 = s1480 || s1481;-  const SWord8 s1483 = (s1479 >> 1) | (s1479 << 7);-  const SWord8 s1484 = 128 | s1483;-  const SWord8 s1485 = 127 & s1483;-  const SWord8 s1486 = s1482 ? s1484 : s1485;-  const SWord8 s1487 = s1438 ? s1478 : s1486;-  const SWord8 s1488 = s1311 ? s1466 : s1487;-  const SWord8 s1489 = s1 + s1445;-  const SBool  s1490 = s1489 < s1;-  const SBool  s1491 = s1489 < s1445;-  const SBool  s1492 = s1490 || s1491;-  const SWord8 s1493 = (s1489 >> 1) | (s1489 << 7);-  const SWord8 s1494 = 128 | s1493;-  const SWord8 s1495 = 127 & s1493;-  const SWord8 s1496 = s1492 ? s1494 : s1495;-  const SWord8 s1497 = (s1496 >> 1) | (s1496 << 7);-  const SWord8 s1498 = 128 | s1497;-  const SWord8 s1499 = 127 & s1497;-  const SWord8 s1500 = s1310 ? s1498 : s1499;-  const SWord8 s1501 = (s1500 >> 1) | (s1500 << 7);-  const SWord8 s1502 = 128 | s1501;-  const SWord8 s1503 = 127 & s1501;-  const SWord8 s1504 = s1437 ? s1502 : s1503;-  const SWord8 s1505 = s1 + s1500;-  const SBool  s1506 = s1505 < s1;-  const SBool  s1507 = s1505 < s1500;-  const SBool  s1508 = s1506 || s1507;-  const SWord8 s1509 = (s1505 >> 1) | (s1505 << 7);-  const SWord8 s1510 = 128 | s1509;-  const SWord8 s1511 = 127 & s1509;-  const SWord8 s1512 = s1508 ? s1510 : s1511;-  const SWord8 s1513 = s1438 ? s1504 : s1512;-  const SWord8 s1514 = s1 + s1496;-  const SBool  s1515 = s1514 < s1;-  const SBool  s1516 = s1514 < s1496;-  const SBool  s1517 = s1515 || s1516;-  const SWord8 s1518 = (s1514 >> 1) | (s1514 << 7);-  const SWord8 s1519 = 128 | s1518;-  const SWord8 s1520 = 127 & s1518;-  const SWord8 s1521 = s1517 ? s1519 : s1520;-  const SWord8 s1522 = (s1521 >> 1) | (s1521 << 7);-  const SWord8 s1523 = 128 | s1522;-  const SWord8 s1524 = 127 & s1522;-  const SWord8 s1525 = s1437 ? s1523 : s1524;-  const SWord8 s1526 = s1 + s1521;-  const SBool  s1527 = s1526 < s1;-  const SBool  s1528 = s1526 < s1521;-  const SBool  s1529 = s1527 || s1528;-  const SWord8 s1530 = (s1526 >> 1) | (s1526 << 7);-  const SWord8 s1531 = 128 | s1530;-  const SWord8 s1532 = 127 & s1530;-  const SWord8 s1533 = s1529 ? s1531 : s1532;-  const SWord8 s1534 = s1438 ? s1525 : s1533;-  const SWord8 s1535 = s1311 ? s1513 : s1534;-  const SWord8 s1536 = s1059 ? s1488 : s1535;-  const SWord8 s1537 = s1037 ? s1428 : s1536;-  const SWord8 s1538 = s21 ? s1301 : s1537;-  const SWord8 s1539 = s1 + s1044;-  const SBool  s1540 = (SBool) ((s1539 >> 0) & 1);-  const SBool  s1541 = false != s1540;-  const SWord8 s1542 = s1541 ? s1048 : s1049;-  const SBool  s1543 = (SBool) ((s1542 >> 0) & 1);-  const SBool  s1544 = false != s1543;-  const SWord8 s1545 = s1544 ? s1054 : s1055;-  const SBool  s1546 = (SBool) ((s1545 >> 0) & 1);-  const SBool  s1547 = false != s1546;-  const SBool  s1548 = false == s1547;-  const SBool  s1549 = s1539 < s1;-  const SBool  s1550 = s1539 < s1044;-  const SBool  s1551 = s1549 || s1550;-  const SWord8 s1552 = (s1539 >> 1) | (s1539 << 7);-  const SWord8 s1553 = 128 | s1552;-  const SWord8 s1554 = 127 & s1552;-  const SWord8 s1555 = s1551 ? s1553 : s1554;-  const SBool  s1556 = (SBool) ((s1555 >> 0) & 1);-  const SBool  s1557 = false != s1556;-  const SWord8 s1558 = (s1542 >> 1) | (s1542 << 7);-  const SWord8 s1559 = 128 | s1558;-  const SWord8 s1560 = 127 & s1558;-  const SWord8 s1561 = s1557 ? s1559 : s1560;-  const SBool  s1562 = (SBool) ((s1561 >> 0) & 1);-  const SBool  s1563 = false != s1562;-  const SWord8 s1564 = (s1545 >> 1) | (s1545 << 7);-  const SWord8 s1565 = 128 | s1564;-  const SWord8 s1566 = 127 & s1564;-  const SWord8 s1567 = s1563 ? s1565 : s1566;-  const SBool  s1568 = (SBool) ((s1567 >> 0) & 1);-  const SBool  s1569 = false != s1568;-  const SBool  s1570 = false == s1569;-  const SWord8 s1571 = (s1555 >> 1) | (s1555 << 7);-  const SWord8 s1572 = 128 | s1571;-  const SWord8 s1573 = 127 & s1571;-  const SWord8 s1574 = s20 ? s1572 : s1573;-  const SBool  s1575 = (SBool) ((s1574 >> 0) & 1);-  const SBool  s1576 = false != s1575;-  const SWord8 s1577 = (s1561 >> 1) | (s1561 << 7);-  const SWord8 s1578 = 128 | s1577;-  const SWord8 s1579 = 127 & s1577;-  const SWord8 s1580 = s1576 ? s1578 : s1579;-  const SBool  s1581 = (SBool) ((s1580 >> 0) & 1);-  const SBool  s1582 = false != s1581;-  const SWord8 s1583 = (s1567 >> 1) | (s1567 << 7);-  const SWord8 s1584 = 128 | s1583;-  const SWord8 s1585 = 127 & s1583;-  const SWord8 s1586 = s1582 ? s1584 : s1585;-  const SBool  s1587 = (SBool) ((s1586 >> 0) & 1);-  const SBool  s1588 = false != s1587;-  const SBool  s1589 = false == s1588;-  const SWord8 s1590 = (s1574 >> 1) | (s1574 << 7);-  const SWord8 s1591 = 128 | s1590;-  const SWord8 s1592 = 127 & s1590;-  const SWord8 s1593 = s1036 ? s1591 : s1592;-  const SWord8 s1594 = (s1593 >> 1) | (s1593 << 7);-  const SWord8 s1595 = 128 | s1594;-  const SWord8 s1596 = 127 & s1594;-  const SWord8 s1597 = s1547 ? s1595 : s1596;-  const SWord8 s1598 = (s1597 >> 1) | (s1597 << 7);-  const SWord8 s1599 = 128 | s1598;-  const SWord8 s1600 = 127 & s1598;-  const SWord8 s1601 = s1569 ? s1599 : s1600;-  const SWord8 s1602 = (s1601 >> 1) | (s1601 << 7);-  const SWord8 s1603 = 128 | s1602;-  const SWord8 s1604 = 127 & s1602;-  const SWord8 s1605 = s1588 ? s1603 : s1604;-  const SWord8 s1606 = s1 + s1601;-  const SBool  s1607 = s1606 < s1;-  const SBool  s1608 = s1606 < s1601;-  const SBool  s1609 = s1607 || s1608;-  const SWord8 s1610 = (s1606 >> 1) | (s1606 << 7);-  const SWord8 s1611 = 128 | s1610;-  const SWord8 s1612 = 127 & s1610;-  const SWord8 s1613 = s1609 ? s1611 : s1612;-  const SWord8 s1614 = s1589 ? s1605 : s1613;-  const SWord8 s1615 = s1 + s1597;-  const SBool  s1616 = s1615 < s1;-  const SBool  s1617 = s1615 < s1597;-  const SBool  s1618 = s1616 || s1617;-  const SWord8 s1619 = (s1615 >> 1) | (s1615 << 7);-  const SWord8 s1620 = 128 | s1619;-  const SWord8 s1621 = 127 & s1619;-  const SWord8 s1622 = s1618 ? s1620 : s1621;-  const SWord8 s1623 = (s1622 >> 1) | (s1622 << 7);-  const SWord8 s1624 = 128 | s1623;-  const SWord8 s1625 = 127 & s1623;-  const SWord8 s1626 = s1588 ? s1624 : s1625;-  const SWord8 s1627 = s1 + s1622;-  const SBool  s1628 = s1627 < s1;-  const SBool  s1629 = s1627 < s1622;-  const SBool  s1630 = s1628 || s1629;-  const SWord8 s1631 = (s1627 >> 1) | (s1627 << 7);-  const SWord8 s1632 = 128 | s1631;-  const SWord8 s1633 = 127 & s1631;-  const SWord8 s1634 = s1630 ? s1632 : s1633;-  const SWord8 s1635 = s1589 ? s1626 : s1634;-  const SWord8 s1636 = s1570 ? s1614 : s1635;-  const SWord8 s1637 = s1 + s1593;-  const SBool  s1638 = s1637 < s1;-  const SBool  s1639 = s1637 < s1593;-  const SBool  s1640 = s1638 || s1639;-  const SWord8 s1641 = (s1637 >> 1) | (s1637 << 7);-  const SWord8 s1642 = 128 | s1641;-  const SWord8 s1643 = 127 & s1641;-  const SWord8 s1644 = s1640 ? s1642 : s1643;-  const SWord8 s1645 = (s1644 >> 1) | (s1644 << 7);-  const SWord8 s1646 = 128 | s1645;-  const SWord8 s1647 = 127 & s1645;-  const SWord8 s1648 = s1569 ? s1646 : s1647;-  const SWord8 s1649 = (s1648 >> 1) | (s1648 << 7);-  const SWord8 s1650 = 128 | s1649;-  const SWord8 s1651 = 127 & s1649;-  const SWord8 s1652 = s1588 ? s1650 : s1651;-  const SWord8 s1653 = s1 + s1648;-  const SBool  s1654 = s1653 < s1;-  const SBool  s1655 = s1653 < s1648;-  const SBool  s1656 = s1654 || s1655;-  const SWord8 s1657 = (s1653 >> 1) | (s1653 << 7);-  const SWord8 s1658 = 128 | s1657;-  const SWord8 s1659 = 127 & s1657;-  const SWord8 s1660 = s1656 ? s1658 : s1659;-  const SWord8 s1661 = s1589 ? s1652 : s1660;-  const SWord8 s1662 = s1 + s1644;-  const SBool  s1663 = s1662 < s1;-  const SBool  s1664 = s1662 < s1644;-  const SBool  s1665 = s1663 || s1664;-  const SWord8 s1666 = (s1662 >> 1) | (s1662 << 7);-  const SWord8 s1667 = 128 | s1666;-  const SWord8 s1668 = 127 & s1666;-  const SWord8 s1669 = s1665 ? s1667 : s1668;-  const SWord8 s1670 = (s1669 >> 1) | (s1669 << 7);-  const SWord8 s1671 = 128 | s1670;-  const SWord8 s1672 = 127 & s1670;-  const SWord8 s1673 = s1588 ? s1671 : s1672;-  const SWord8 s1674 = s1 + s1669;-  const SBool  s1675 = s1674 < s1;-  const SBool  s1676 = s1674 < s1669;-  const SBool  s1677 = s1675 || s1676;-  const SWord8 s1678 = (s1674 >> 1) | (s1674 << 7);-  const SWord8 s1679 = 128 | s1678;-  const SWord8 s1680 = 127 & s1678;-  const SWord8 s1681 = s1677 ? s1679 : s1680;-  const SWord8 s1682 = s1589 ? s1673 : s1681;-  const SWord8 s1683 = s1570 ? s1661 : s1682;-  const SWord8 s1684 = s1548 ? s1636 : s1683;-  const SWord8 s1685 = s1 + s1574;-  const SBool  s1686 = (SBool) ((s1685 >> 0) & 1);-  const SBool  s1687 = false != s1686;-  const SWord8 s1688 = s1687 ? s1578 : s1579;-  const SBool  s1689 = (SBool) ((s1688 >> 0) & 1);-  const SBool  s1690 = false != s1689;-  const SWord8 s1691 = s1690 ? s1584 : s1585;-  const SBool  s1692 = (SBool) ((s1691 >> 0) & 1);-  const SBool  s1693 = false != s1692;-  const SBool  s1694 = false == s1693;-  const SBool  s1695 = s1685 < s1;-  const SBool  s1696 = s1685 < s1574;-  const SBool  s1697 = s1695 || s1696;-  const SWord8 s1698 = (s1685 >> 1) | (s1685 << 7);-  const SWord8 s1699 = 128 | s1698;-  const SWord8 s1700 = 127 & s1698;-  const SWord8 s1701 = s1697 ? s1699 : s1700;-  const SWord8 s1702 = (s1701 >> 1) | (s1701 << 7);-  const SWord8 s1703 = 128 | s1702;-  const SWord8 s1704 = 127 & s1702;-  const SWord8 s1705 = s1547 ? s1703 : s1704;-  const SWord8 s1706 = (s1705 >> 1) | (s1705 << 7);-  const SWord8 s1707 = 128 | s1706;-  const SWord8 s1708 = 127 & s1706;-  const SWord8 s1709 = s1569 ? s1707 : s1708;-  const SWord8 s1710 = (s1709 >> 1) | (s1709 << 7);-  const SWord8 s1711 = 128 | s1710;-  const SWord8 s1712 = 127 & s1710;-  const SWord8 s1713 = s1693 ? s1711 : s1712;-  const SWord8 s1714 = s1 + s1709;-  const SBool  s1715 = s1714 < s1;-  const SBool  s1716 = s1714 < s1709;-  const SBool  s1717 = s1715 || s1716;-  const SWord8 s1718 = (s1714 >> 1) | (s1714 << 7);-  const SWord8 s1719 = 128 | s1718;-  const SWord8 s1720 = 127 & s1718;-  const SWord8 s1721 = s1717 ? s1719 : s1720;-  const SWord8 s1722 = s1694 ? s1713 : s1721;-  const SWord8 s1723 = s1 + s1705;-  const SBool  s1724 = s1723 < s1;-  const SBool  s1725 = s1723 < s1705;-  const SBool  s1726 = s1724 || s1725;-  const SWord8 s1727 = (s1723 >> 1) | (s1723 << 7);-  const SWord8 s1728 = 128 | s1727;-  const SWord8 s1729 = 127 & s1727;-  const SWord8 s1730 = s1726 ? s1728 : s1729;-  const SWord8 s1731 = (s1730 >> 1) | (s1730 << 7);-  const SWord8 s1732 = 128 | s1731;-  const SWord8 s1733 = 127 & s1731;-  const SWord8 s1734 = s1693 ? s1732 : s1733;-  const SWord8 s1735 = s1 + s1730;-  const SBool  s1736 = s1735 < s1;-  const SBool  s1737 = s1735 < s1730;-  const SBool  s1738 = s1736 || s1737;-  const SWord8 s1739 = (s1735 >> 1) | (s1735 << 7);-  const SWord8 s1740 = 128 | s1739;-  const SWord8 s1741 = 127 & s1739;-  const SWord8 s1742 = s1738 ? s1740 : s1741;-  const SWord8 s1743 = s1694 ? s1734 : s1742;-  const SWord8 s1744 = s1570 ? s1722 : s1743;-  const SWord8 s1745 = s1 + s1701;-  const SBool  s1746 = s1745 < s1;-  const SBool  s1747 = s1745 < s1701;-  const SBool  s1748 = s1746 || s1747;-  const SWord8 s1749 = (s1745 >> 1) | (s1745 << 7);-  const SWord8 s1750 = 128 | s1749;-  const SWord8 s1751 = 127 & s1749;-  const SWord8 s1752 = s1748 ? s1750 : s1751;-  const SWord8 s1753 = (s1752 >> 1) | (s1752 << 7);-  const SWord8 s1754 = 128 | s1753;-  const SWord8 s1755 = 127 & s1753;-  const SWord8 s1756 = s1569 ? s1754 : s1755;-  const SWord8 s1757 = (s1756 >> 1) | (s1756 << 7);-  const SWord8 s1758 = 128 | s1757;-  const SWord8 s1759 = 127 & s1757;-  const SWord8 s1760 = s1693 ? s1758 : s1759;-  const SWord8 s1761 = s1 + s1756;-  const SBool  s1762 = s1761 < s1;-  const SBool  s1763 = s1761 < s1756;-  const SBool  s1764 = s1762 || s1763;-  const SWord8 s1765 = (s1761 >> 1) | (s1761 << 7);-  const SWord8 s1766 = 128 | s1765;-  const SWord8 s1767 = 127 & s1765;-  const SWord8 s1768 = s1764 ? s1766 : s1767;-  const SWord8 s1769 = s1694 ? s1760 : s1768;-  const SWord8 s1770 = s1 + s1752;-  const SBool  s1771 = s1770 < s1;-  const SBool  s1772 = s1770 < s1752;-  const SBool  s1773 = s1771 || s1772;-  const SWord8 s1774 = (s1770 >> 1) | (s1770 << 7);-  const SWord8 s1775 = 128 | s1774;-  const SWord8 s1776 = 127 & s1774;-  const SWord8 s1777 = s1773 ? s1775 : s1776;-  const SWord8 s1778 = (s1777 >> 1) | (s1777 << 7);-  const SWord8 s1779 = 128 | s1778;-  const SWord8 s1780 = 127 & s1778;-  const SWord8 s1781 = s1693 ? s1779 : s1780;-  const SWord8 s1782 = s1 + s1777;-  const SBool  s1783 = s1782 < s1;-  const SBool  s1784 = s1782 < s1777;-  const SBool  s1785 = s1783 || s1784;-  const SWord8 s1786 = (s1782 >> 1) | (s1782 << 7);-  const SWord8 s1787 = 128 | s1786;-  const SWord8 s1788 = 127 & s1786;-  const SWord8 s1789 = s1785 ? s1787 : s1788;-  const SWord8 s1790 = s1694 ? s1781 : s1789;-  const SWord8 s1791 = s1570 ? s1769 : s1790;-  const SWord8 s1792 = s1548 ? s1744 : s1791;-  const SWord8 s1793 = s1037 ? s1684 : s1792;-  const SWord8 s1794 = s1 + s1555;-  const SBool  s1795 = (SBool) ((s1794 >> 0) & 1);-  const SBool  s1796 = false != s1795;-  const SWord8 s1797 = s1796 ? s1559 : s1560;-  const SBool  s1798 = (SBool) ((s1797 >> 0) & 1);-  const SBool  s1799 = false != s1798;-  const SWord8 s1800 = s1799 ? s1565 : s1566;-  const SBool  s1801 = (SBool) ((s1800 >> 0) & 1);-  const SBool  s1802 = false != s1801;-  const SBool  s1803 = false == s1802;-  const SBool  s1804 = s1794 < s1;-  const SBool  s1805 = s1794 < s1555;-  const SBool  s1806 = s1804 || s1805;-  const SWord8 s1807 = (s1794 >> 1) | (s1794 << 7);-  const SWord8 s1808 = 128 | s1807;-  const SWord8 s1809 = 127 & s1807;-  const SWord8 s1810 = s1806 ? s1808 : s1809;-  const SBool  s1811 = (SBool) ((s1810 >> 0) & 1);-  const SBool  s1812 = false != s1811;-  const SWord8 s1813 = (s1797 >> 1) | (s1797 << 7);-  const SWord8 s1814 = 128 | s1813;-  const SWord8 s1815 = 127 & s1813;-  const SWord8 s1816 = s1812 ? s1814 : s1815;-  const SBool  s1817 = (SBool) ((s1816 >> 0) & 1);-  const SBool  s1818 = false != s1817;-  const SWord8 s1819 = (s1800 >> 1) | (s1800 << 7);-  const SWord8 s1820 = 128 | s1819;-  const SWord8 s1821 = 127 & s1819;-  const SWord8 s1822 = s1818 ? s1820 : s1821;-  const SBool  s1823 = (SBool) ((s1822 >> 0) & 1);-  const SBool  s1824 = false != s1823;-  const SBool  s1825 = false == s1824;-  const SWord8 s1826 = (s1810 >> 1) | (s1810 << 7);-  const SWord8 s1827 = 128 | s1826;-  const SWord8 s1828 = 127 & s1826;-  const SWord8 s1829 = s1036 ? s1827 : s1828;-  const SWord8 s1830 = (s1829 >> 1) | (s1829 << 7);-  const SWord8 s1831 = 128 | s1830;-  const SWord8 s1832 = 127 & s1830;-  const SWord8 s1833 = s1547 ? s1831 : s1832;-  const SWord8 s1834 = (s1833 >> 1) | (s1833 << 7);-  const SWord8 s1835 = 128 | s1834;-  const SWord8 s1836 = 127 & s1834;-  const SWord8 s1837 = s1802 ? s1835 : s1836;-  const SWord8 s1838 = (s1837 >> 1) | (s1837 << 7);-  const SWord8 s1839 = 128 | s1838;-  const SWord8 s1840 = 127 & s1838;-  const SWord8 s1841 = s1824 ? s1839 : s1840;-  const SWord8 s1842 = s1 + s1837;-  const SBool  s1843 = s1842 < s1;-  const SBool  s1844 = s1842 < s1837;-  const SBool  s1845 = s1843 || s1844;-  const SWord8 s1846 = (s1842 >> 1) | (s1842 << 7);-  const SWord8 s1847 = 128 | s1846;-  const SWord8 s1848 = 127 & s1846;-  const SWord8 s1849 = s1845 ? s1847 : s1848;-  const SWord8 s1850 = s1825 ? s1841 : s1849;-  const SWord8 s1851 = s1 + s1833;-  const SBool  s1852 = s1851 < s1;-  const SBool  s1853 = s1851 < s1833;-  const SBool  s1854 = s1852 || s1853;-  const SWord8 s1855 = (s1851 >> 1) | (s1851 << 7);-  const SWord8 s1856 = 128 | s1855;-  const SWord8 s1857 = 127 & s1855;-  const SWord8 s1858 = s1854 ? s1856 : s1857;-  const SWord8 s1859 = (s1858 >> 1) | (s1858 << 7);-  const SWord8 s1860 = 128 | s1859;-  const SWord8 s1861 = 127 & s1859;-  const SWord8 s1862 = s1824 ? s1860 : s1861;-  const SWord8 s1863 = s1 + s1858;-  const SBool  s1864 = s1863 < s1;-  const SBool  s1865 = s1863 < s1858;-  const SBool  s1866 = s1864 || s1865;-  const SWord8 s1867 = (s1863 >> 1) | (s1863 << 7);-  const SWord8 s1868 = 128 | s1867;-  const SWord8 s1869 = 127 & s1867;-  const SWord8 s1870 = s1866 ? s1868 : s1869;-  const SWord8 s1871 = s1825 ? s1862 : s1870;-  const SWord8 s1872 = s1803 ? s1850 : s1871;-  const SWord8 s1873 = s1 + s1829;-  const SBool  s1874 = s1873 < s1;-  const SBool  s1875 = s1873 < s1829;-  const SBool  s1876 = s1874 || s1875;-  const SWord8 s1877 = (s1873 >> 1) | (s1873 << 7);-  const SWord8 s1878 = 128 | s1877;-  const SWord8 s1879 = 127 & s1877;-  const SWord8 s1880 = s1876 ? s1878 : s1879;-  const SWord8 s1881 = (s1880 >> 1) | (s1880 << 7);-  const SWord8 s1882 = 128 | s1881;-  const SWord8 s1883 = 127 & s1881;-  const SWord8 s1884 = s1802 ? s1882 : s1883;-  const SWord8 s1885 = (s1884 >> 1) | (s1884 << 7);-  const SWord8 s1886 = 128 | s1885;-  const SWord8 s1887 = 127 & s1885;-  const SWord8 s1888 = s1824 ? s1886 : s1887;-  const SWord8 s1889 = s1 + s1884;-  const SBool  s1890 = s1889 < s1;-  const SBool  s1891 = s1889 < s1884;-  const SBool  s1892 = s1890 || s1891;-  const SWord8 s1893 = (s1889 >> 1) | (s1889 << 7);-  const SWord8 s1894 = 128 | s1893;-  const SWord8 s1895 = 127 & s1893;-  const SWord8 s1896 = s1892 ? s1894 : s1895;-  const SWord8 s1897 = s1825 ? s1888 : s1896;-  const SWord8 s1898 = s1 + s1880;-  const SBool  s1899 = s1898 < s1;-  const SBool  s1900 = s1898 < s1880;-  const SBool  s1901 = s1899 || s1900;-  const SWord8 s1902 = (s1898 >> 1) | (s1898 << 7);-  const SWord8 s1903 = 128 | s1902;-  const SWord8 s1904 = 127 & s1902;-  const SWord8 s1905 = s1901 ? s1903 : s1904;-  const SWord8 s1906 = (s1905 >> 1) | (s1905 << 7);-  const SWord8 s1907 = 128 | s1906;-  const SWord8 s1908 = 127 & s1906;-  const SWord8 s1909 = s1824 ? s1907 : s1908;-  const SWord8 s1910 = s1 + s1905;-  const SBool  s1911 = s1910 < s1;-  const SBool  s1912 = s1910 < s1905;-  const SBool  s1913 = s1911 || s1912;-  const SWord8 s1914 = (s1910 >> 1) | (s1910 << 7);-  const SWord8 s1915 = 128 | s1914;-  const SWord8 s1916 = 127 & s1914;-  const SWord8 s1917 = s1913 ? s1915 : s1916;-  const SWord8 s1918 = s1825 ? s1909 : s1917;-  const SWord8 s1919 = s1803 ? s1897 : s1918;-  const SWord8 s1920 = s1548 ? s1872 : s1919;-  const SWord8 s1921 = s1 + s1810;-  const SBool  s1922 = (SBool) ((s1921 >> 0) & 1);-  const SBool  s1923 = false != s1922;-  const SWord8 s1924 = s1923 ? s1814 : s1815;-  const SBool  s1925 = (SBool) ((s1924 >> 0) & 1);-  const SBool  s1926 = false != s1925;-  const SWord8 s1927 = s1926 ? s1820 : s1821;-  const SBool  s1928 = (SBool) ((s1927 >> 0) & 1);-  const SBool  s1929 = false != s1928;-  const SBool  s1930 = false == s1929;-  const SBool  s1931 = s1921 < s1;-  const SBool  s1932 = s1921 < s1810;-  const SBool  s1933 = s1931 || s1932;-  const SWord8 s1934 = (s1921 >> 1) | (s1921 << 7);-  const SWord8 s1935 = 128 | s1934;-  const SWord8 s1936 = 127 & s1934;-  const SWord8 s1937 = s1933 ? s1935 : s1936;-  const SWord8 s1938 = (s1937 >> 1) | (s1937 << 7);-  const SWord8 s1939 = 128 | s1938;-  const SWord8 s1940 = 127 & s1938;-  const SWord8 s1941 = s1547 ? s1939 : s1940;-  const SWord8 s1942 = (s1941 >> 1) | (s1941 << 7);-  const SWord8 s1943 = 128 | s1942;-  const SWord8 s1944 = 127 & s1942;-  const SWord8 s1945 = s1802 ? s1943 : s1944;-  const SWord8 s1946 = (s1945 >> 1) | (s1945 << 7);-  const SWord8 s1947 = 128 | s1946;-  const SWord8 s1948 = 127 & s1946;-  const SWord8 s1949 = s1929 ? s1947 : s1948;-  const SWord8 s1950 = s1 + s1945;-  const SBool  s1951 = s1950 < s1;-  const SBool  s1952 = s1950 < s1945;-  const SBool  s1953 = s1951 || s1952;-  const SWord8 s1954 = (s1950 >> 1) | (s1950 << 7);-  const SWord8 s1955 = 128 | s1954;-  const SWord8 s1956 = 127 & s1954;-  const SWord8 s1957 = s1953 ? s1955 : s1956;-  const SWord8 s1958 = s1930 ? s1949 : s1957;-  const SWord8 s1959 = s1 + s1941;-  const SBool  s1960 = s1959 < s1;-  const SBool  s1961 = s1959 < s1941;-  const SBool  s1962 = s1960 || s1961;-  const SWord8 s1963 = (s1959 >> 1) | (s1959 << 7);-  const SWord8 s1964 = 128 | s1963;-  const SWord8 s1965 = 127 & s1963;-  const SWord8 s1966 = s1962 ? s1964 : s1965;-  const SWord8 s1967 = (s1966 >> 1) | (s1966 << 7);-  const SWord8 s1968 = 128 | s1967;-  const SWord8 s1969 = 127 & s1967;-  const SWord8 s1970 = s1929 ? s1968 : s1969;-  const SWord8 s1971 = s1 + s1966;-  const SBool  s1972 = s1971 < s1;-  const SBool  s1973 = s1971 < s1966;-  const SBool  s1974 = s1972 || s1973;-  const SWord8 s1975 = (s1971 >> 1) | (s1971 << 7);-  const SWord8 s1976 = 128 | s1975;-  const SWord8 s1977 = 127 & s1975;-  const SWord8 s1978 = s1974 ? s1976 : s1977;-  const SWord8 s1979 = s1930 ? s1970 : s1978;-  const SWord8 s1980 = s1803 ? s1958 : s1979;-  const SWord8 s1981 = s1 + s1937;-  const SBool  s1982 = s1981 < s1;-  const SBool  s1983 = s1981 < s1937;-  const SBool  s1984 = s1982 || s1983;-  const SWord8 s1985 = (s1981 >> 1) | (s1981 << 7);-  const SWord8 s1986 = 128 | s1985;-  const SWord8 s1987 = 127 & s1985;-  const SWord8 s1988 = s1984 ? s1986 : s1987;-  const SWord8 s1989 = (s1988 >> 1) | (s1988 << 7);-  const SWord8 s1990 = 128 | s1989;-  const SWord8 s1991 = 127 & s1989;-  const SWord8 s1992 = s1802 ? s1990 : s1991;-  const SWord8 s1993 = (s1992 >> 1) | (s1992 << 7);-  const SWord8 s1994 = 128 | s1993;-  const SWord8 s1995 = 127 & s1993;-  const SWord8 s1996 = s1929 ? s1994 : s1995;-  const SWord8 s1997 = s1 + s1992;-  const SBool  s1998 = s1997 < s1;-  const SBool  s1999 = s1997 < s1992;-  const SBool  s2000 = s1998 || s1999;-  const SWord8 s2001 = (s1997 >> 1) | (s1997 << 7);-  const SWord8 s2002 = 128 | s2001;-  const SWord8 s2003 = 127 & s2001;-  const SWord8 s2004 = s2000 ? s2002 : s2003;-  const SWord8 s2005 = s1930 ? s1996 : s2004;-  const SWord8 s2006 = s1 + s1988;-  const SBool  s2007 = s2006 < s1;-  const SBool  s2008 = s2006 < s1988;-  const SBool  s2009 = s2007 || s2008;-  const SWord8 s2010 = (s2006 >> 1) | (s2006 << 7);-  const SWord8 s2011 = 128 | s2010;-  const SWord8 s2012 = 127 & s2010;-  const SWord8 s2013 = s2009 ? s2011 : s2012;-  const SWord8 s2014 = (s2013 >> 1) | (s2013 << 7);-  const SWord8 s2015 = 128 | s2014;-  const SWord8 s2016 = 127 & s2014;-  const SWord8 s2017 = s1929 ? s2015 : s2016;-  const SWord8 s2018 = s1 + s2013;-  const SBool  s2019 = s2018 < s1;-  const SBool  s2020 = s2018 < s2013;-  const SBool  s2021 = s2019 || s2020;-  const SWord8 s2022 = (s2018 >> 1) | (s2018 << 7);-  const SWord8 s2023 = 128 | s2022;-  const SWord8 s2024 = 127 & s2022;-  const SWord8 s2025 = s2021 ? s2023 : s2024;-  const SWord8 s2026 = s1930 ? s2017 : s2025;-  const SWord8 s2027 = s1803 ? s2005 : s2026;-  const SWord8 s2028 = s1548 ? s1980 : s2027;-  const SWord8 s2029 = s1037 ? s1920 : s2028;-  const SWord8 s2030 = s21 ? s1793 : s2029;-  const SWord8 s2031 = s16 ? s1538 : s2030;-  const SWord8 s2032 = s11 ? s1027 : s2031;-  const SBool  s2033 = (SBool) ((s1 >> 0) & 1);-  const SBool  s2034 = false != s2033;-  const SWord8 s2035 = s2034 ? 128 : 0;-  const SBool  s2036 = (SBool) ((s2035 >> 0) & 1);-  const SBool  s2037 = false != s2036;-  const SWord8 s2038 = s17 | 128;-  const SWord8 s2039 = s2037 ? s2038 : s18;-  const SBool  s2040 = (SBool) ((s2039 >> 0) & 1);-  const SBool  s2041 = false != s2040;-  const SBool  s2042 = false == s2041;-  const SWord8 s2043 = (s1 >> 1) | (s1 << 7);-  const SWord8 s2044 = 127 & s2043;-  const SBool  s2045 = (SBool) ((s2044 >> 0) & 1);-  const SBool  s2046 = false != s2045;-  const SWord8 s2047 = (s2035 >> 1) | (s2035 << 7);-  const SWord8 s2048 = 128 | s2047;-  const SWord8 s2049 = 127 & s2047;-  const SWord8 s2050 = s2046 ? s2048 : s2049;-  const SBool  s2051 = (SBool) ((s2050 >> 0) & 1);-  const SBool  s2052 = false != s2051;-  const SWord8 s2053 = (s2039 >> 1) | (s2039 << 7);-  const SWord8 s2054 = 128 | s2053;-  const SWord8 s2055 = 127 & s2053;-  const SWord8 s2056 = s2052 ? s2054 : s2055;-  const SBool  s2057 = (SBool) ((s2056 >> 0) & 1);-  const SBool  s2058 = false != s2057;-  const SBool  s2059 = false == s2058;-  const SWord8 s2060 = (s2044 >> 1) | (s2044 << 7);-  const SWord8 s2061 = 128 | s2060;-  const SWord8 s2062 = 127 & s2060;-  const SWord8 s2063 = s10 ? s2061 : s2062;-  const SBool  s2064 = (SBool) ((s2063 >> 0) & 1);-  const SBool  s2065 = false != s2064;-  const SWord8 s2066 = (s2050 >> 1) | (s2050 << 7);-  const SWord8 s2067 = 128 | s2066;-  const SWord8 s2068 = 127 & s2066;-  const SWord8 s2069 = s2065 ? s2067 : s2068;-  const SBool  s2070 = (SBool) ((s2069 >> 0) & 1);-  const SBool  s2071 = false != s2070;-  const SWord8 s2072 = (s2056 >> 1) | (s2056 << 7);-  const SWord8 s2073 = 128 | s2072;-  const SWord8 s2074 = 127 & s2072;-  const SWord8 s2075 = s2071 ? s2073 : s2074;-  const SBool  s2076 = (SBool) ((s2075 >> 0) & 1);-  const SBool  s2077 = false != s2076;-  const SBool  s2078 = false == s2077;-  const SWord8 s2079 = (s2063 >> 1) | (s2063 << 7);-  const SWord8 s2080 = 128 | s2079;-  const SWord8 s2081 = 127 & s2079;-  const SWord8 s2082 = s15 ? s2080 : s2081;-  const SBool  s2083 = (SBool) ((s2082 >> 0) & 1);-  const SBool  s2084 = false != s2083;-  const SWord8 s2085 = (s2069 >> 1) | (s2069 << 7);-  const SWord8 s2086 = 128 | s2085;-  const SWord8 s2087 = 127 & s2085;-  const SWord8 s2088 = s2084 ? s2086 : s2087;-  const SBool  s2089 = (SBool) ((s2088 >> 0) & 1);-  const SBool  s2090 = false != s2089;-  const SWord8 s2091 = (s2075 >> 1) | (s2075 << 7);-  const SWord8 s2092 = 128 | s2091;-  const SWord8 s2093 = 127 & s2091;-  const SWord8 s2094 = s2090 ? s2092 : s2093;-  const SBool  s2095 = (SBool) ((s2094 >> 0) & 1);-  const SBool  s2096 = false != s2095;-  const SBool  s2097 = false == s2096;-  const SWord8 s2098 = (s2082 >> 1) | (s2082 << 7);-  const SWord8 s2099 = 128 | s2098;-  const SWord8 s2100 = 127 & s2098;-  const SWord8 s2101 = s2041 ? s2099 : s2100;-  const SBool  s2102 = (SBool) ((s2101 >> 0) & 1);-  const SBool  s2103 = false != s2102;-  const SWord8 s2104 = (s2088 >> 1) | (s2088 << 7);-  const SWord8 s2105 = 128 | s2104;-  const SWord8 s2106 = 127 & s2104;-  const SWord8 s2107 = s2103 ? s2105 : s2106;-  const SBool  s2108 = (SBool) ((s2107 >> 0) & 1);-  const SBool  s2109 = false != s2108;-  const SWord8 s2110 = (s2094 >> 1) | (s2094 << 7);-  const SWord8 s2111 = 128 | s2110;-  const SWord8 s2112 = 127 & s2110;-  const SWord8 s2113 = s2109 ? s2111 : s2112;-  const SBool  s2114 = (SBool) ((s2113 >> 0) & 1);-  const SBool  s2115 = false != s2114;-  const SBool  s2116 = false == s2115;-  const SWord8 s2117 = (s2101 >> 1) | (s2101 << 7);-  const SWord8 s2118 = 128 | s2117;-  const SWord8 s2119 = 127 & s2117;-  const SWord8 s2120 = s2058 ? s2118 : s2119;-  const SWord8 s2121 = (s2120 >> 1) | (s2120 << 7);-  const SWord8 s2122 = 128 | s2121;-  const SWord8 s2123 = 127 & s2121;-  const SWord8 s2124 = s2077 ? s2122 : s2123;-  const SWord8 s2125 = (s2124 >> 1) | (s2124 << 7);-  const SWord8 s2126 = 128 | s2125;-  const SWord8 s2127 = 127 & s2125;-  const SWord8 s2128 = s2096 ? s2126 : s2127;-  const SWord8 s2129 = (s2128 >> 1) | (s2128 << 7);-  const SWord8 s2130 = 128 | s2129;-  const SWord8 s2131 = 127 & s2129;-  const SWord8 s2132 = s2115 ? s2130 : s2131;-  const SWord8 s2133 = s1 + s2128;-  const SBool  s2134 = s2133 < s1;-  const SBool  s2135 = s2133 < s2128;-  const SBool  s2136 = s2134 || s2135;-  const SWord8 s2137 = (s2133 >> 1) | (s2133 << 7);-  const SWord8 s2138 = 128 | s2137;-  const SWord8 s2139 = 127 & s2137;-  const SWord8 s2140 = s2136 ? s2138 : s2139;-  const SWord8 s2141 = s2116 ? s2132 : s2140;-  const SWord8 s2142 = s1 + s2124;-  const SBool  s2143 = s2142 < s1;-  const SBool  s2144 = s2142 < s2124;-  const SBool  s2145 = s2143 || s2144;-  const SWord8 s2146 = (s2142 >> 1) | (s2142 << 7);-  const SWord8 s2147 = 128 | s2146;-  const SWord8 s2148 = 127 & s2146;-  const SWord8 s2149 = s2145 ? s2147 : s2148;-  const SWord8 s2150 = (s2149 >> 1) | (s2149 << 7);-  const SWord8 s2151 = 128 | s2150;-  const SWord8 s2152 = 127 & s2150;-  const SWord8 s2153 = s2115 ? s2151 : s2152;-  const SWord8 s2154 = s1 + s2149;-  const SBool  s2155 = s2154 < s1;-  const SBool  s2156 = s2154 < s2149;-  const SBool  s2157 = s2155 || s2156;-  const SWord8 s2158 = (s2154 >> 1) | (s2154 << 7);-  const SWord8 s2159 = 128 | s2158;-  const SWord8 s2160 = 127 & s2158;-  const SWord8 s2161 = s2157 ? s2159 : s2160;-  const SWord8 s2162 = s2116 ? s2153 : s2161;-  const SWord8 s2163 = s2097 ? s2141 : s2162;-  const SWord8 s2164 = s1 + s2120;-  const SBool  s2165 = s2164 < s1;-  const SBool  s2166 = s2164 < s2120;-  const SBool  s2167 = s2165 || s2166;-  const SWord8 s2168 = (s2164 >> 1) | (s2164 << 7);-  const SWord8 s2169 = 128 | s2168;-  const SWord8 s2170 = 127 & s2168;-  const SWord8 s2171 = s2167 ? s2169 : s2170;-  const SWord8 s2172 = (s2171 >> 1) | (s2171 << 7);-  const SWord8 s2173 = 128 | s2172;-  const SWord8 s2174 = 127 & s2172;-  const SWord8 s2175 = s2096 ? s2173 : s2174;-  const SWord8 s2176 = (s2175 >> 1) | (s2175 << 7);-  const SWord8 s2177 = 128 | s2176;-  const SWord8 s2178 = 127 & s2176;-  const SWord8 s2179 = s2115 ? s2177 : s2178;-  const SWord8 s2180 = s1 + s2175;-  const SBool  s2181 = s2180 < s1;-  const SBool  s2182 = s2180 < s2175;-  const SBool  s2183 = s2181 || s2182;-  const SWord8 s2184 = (s2180 >> 1) | (s2180 << 7);-  const SWord8 s2185 = 128 | s2184;-  const SWord8 s2186 = 127 & s2184;-  const SWord8 s2187 = s2183 ? s2185 : s2186;-  const SWord8 s2188 = s2116 ? s2179 : s2187;-  const SWord8 s2189 = s1 + s2171;-  const SBool  s2190 = s2189 < s1;-  const SBool  s2191 = s2189 < s2171;-  const SBool  s2192 = s2190 || s2191;-  const SWord8 s2193 = (s2189 >> 1) | (s2189 << 7);-  const SWord8 s2194 = 128 | s2193;-  const SWord8 s2195 = 127 & s2193;-  const SWord8 s2196 = s2192 ? s2194 : s2195;-  const SWord8 s2197 = (s2196 >> 1) | (s2196 << 7);-  const SWord8 s2198 = 128 | s2197;-  const SWord8 s2199 = 127 & s2197;-  const SWord8 s2200 = s2115 ? s2198 : s2199;-  const SWord8 s2201 = s1 + s2196;-  const SBool  s2202 = s2201 < s1;-  const SBool  s2203 = s2201 < s2196;-  const SBool  s2204 = s2202 || s2203;-  const SWord8 s2205 = (s2201 >> 1) | (s2201 << 7);-  const SWord8 s2206 = 128 | s2205;-  const SWord8 s2207 = 127 & s2205;-  const SWord8 s2208 = s2204 ? s2206 : s2207;-  const SWord8 s2209 = s2116 ? s2200 : s2208;-  const SWord8 s2210 = s2097 ? s2188 : s2209;-  const SWord8 s2211 = s2078 ? s2163 : s2210;-  const SWord8 s2212 = s1 + s2101;-  const SBool  s2213 = (SBool) ((s2212 >> 0) & 1);-  const SBool  s2214 = false != s2213;-  const SWord8 s2215 = s2214 ? s2105 : s2106;-  const SBool  s2216 = (SBool) ((s2215 >> 0) & 1);-  const SBool  s2217 = false != s2216;-  const SWord8 s2218 = s2217 ? s2111 : s2112;-  const SBool  s2219 = (SBool) ((s2218 >> 0) & 1);-  const SBool  s2220 = false != s2219;-  const SBool  s2221 = false == s2220;-  const SBool  s2222 = s2212 < s1;-  const SBool  s2223 = s2212 < s2101;-  const SBool  s2224 = s2222 || s2223;-  const SWord8 s2225 = (s2212 >> 1) | (s2212 << 7);-  const SWord8 s2226 = 128 | s2225;-  const SWord8 s2227 = 127 & s2225;-  const SWord8 s2228 = s2224 ? s2226 : s2227;-  const SWord8 s2229 = (s2228 >> 1) | (s2228 << 7);-  const SWord8 s2230 = 128 | s2229;-  const SWord8 s2231 = 127 & s2229;-  const SWord8 s2232 = s2077 ? s2230 : s2231;-  const SWord8 s2233 = (s2232 >> 1) | (s2232 << 7);-  const SWord8 s2234 = 128 | s2233;-  const SWord8 s2235 = 127 & s2233;-  const SWord8 s2236 = s2096 ? s2234 : s2235;-  const SWord8 s2237 = (s2236 >> 1) | (s2236 << 7);-  const SWord8 s2238 = 128 | s2237;-  const SWord8 s2239 = 127 & s2237;-  const SWord8 s2240 = s2220 ? s2238 : s2239;-  const SWord8 s2241 = s1 + s2236;-  const SBool  s2242 = s2241 < s1;-  const SBool  s2243 = s2241 < s2236;-  const SBool  s2244 = s2242 || s2243;-  const SWord8 s2245 = (s2241 >> 1) | (s2241 << 7);-  const SWord8 s2246 = 128 | s2245;-  const SWord8 s2247 = 127 & s2245;-  const SWord8 s2248 = s2244 ? s2246 : s2247;-  const SWord8 s2249 = s2221 ? s2240 : s2248;-  const SWord8 s2250 = s1 + s2232;-  const SBool  s2251 = s2250 < s1;-  const SBool  s2252 = s2250 < s2232;-  const SBool  s2253 = s2251 || s2252;-  const SWord8 s2254 = (s2250 >> 1) | (s2250 << 7);-  const SWord8 s2255 = 128 | s2254;-  const SWord8 s2256 = 127 & s2254;-  const SWord8 s2257 = s2253 ? s2255 : s2256;-  const SWord8 s2258 = (s2257 >> 1) | (s2257 << 7);-  const SWord8 s2259 = 128 | s2258;-  const SWord8 s2260 = 127 & s2258;-  const SWord8 s2261 = s2220 ? s2259 : s2260;-  const SWord8 s2262 = s1 + s2257;-  const SBool  s2263 = s2262 < s1;-  const SBool  s2264 = s2262 < s2257;-  const SBool  s2265 = s2263 || s2264;-  const SWord8 s2266 = (s2262 >> 1) | (s2262 << 7);-  const SWord8 s2267 = 128 | s2266;-  const SWord8 s2268 = 127 & s2266;-  const SWord8 s2269 = s2265 ? s2267 : s2268;-  const SWord8 s2270 = s2221 ? s2261 : s2269;-  const SWord8 s2271 = s2097 ? s2249 : s2270;-  const SWord8 s2272 = s1 + s2228;-  const SBool  s2273 = s2272 < s1;-  const SBool  s2274 = s2272 < s2228;-  const SBool  s2275 = s2273 || s2274;-  const SWord8 s2276 = (s2272 >> 1) | (s2272 << 7);-  const SWord8 s2277 = 128 | s2276;-  const SWord8 s2278 = 127 & s2276;-  const SWord8 s2279 = s2275 ? s2277 : s2278;-  const SWord8 s2280 = (s2279 >> 1) | (s2279 << 7);-  const SWord8 s2281 = 128 | s2280;-  const SWord8 s2282 = 127 & s2280;-  const SWord8 s2283 = s2096 ? s2281 : s2282;-  const SWord8 s2284 = (s2283 >> 1) | (s2283 << 7);-  const SWord8 s2285 = 128 | s2284;-  const SWord8 s2286 = 127 & s2284;-  const SWord8 s2287 = s2220 ? s2285 : s2286;-  const SWord8 s2288 = s1 + s2283;-  const SBool  s2289 = s2288 < s1;-  const SBool  s2290 = s2288 < s2283;-  const SBool  s2291 = s2289 || s2290;-  const SWord8 s2292 = (s2288 >> 1) | (s2288 << 7);-  const SWord8 s2293 = 128 | s2292;-  const SWord8 s2294 = 127 & s2292;-  const SWord8 s2295 = s2291 ? s2293 : s2294;-  const SWord8 s2296 = s2221 ? s2287 : s2295;-  const SWord8 s2297 = s1 + s2279;-  const SBool  s2298 = s2297 < s1;-  const SBool  s2299 = s2297 < s2279;-  const SBool  s2300 = s2298 || s2299;-  const SWord8 s2301 = (s2297 >> 1) | (s2297 << 7);-  const SWord8 s2302 = 128 | s2301;-  const SWord8 s2303 = 127 & s2301;-  const SWord8 s2304 = s2300 ? s2302 : s2303;-  const SWord8 s2305 = (s2304 >> 1) | (s2304 << 7);-  const SWord8 s2306 = 128 | s2305;-  const SWord8 s2307 = 127 & s2305;-  const SWord8 s2308 = s2220 ? s2306 : s2307;-  const SWord8 s2309 = s1 + s2304;-  const SBool  s2310 = s2309 < s1;-  const SBool  s2311 = s2309 < s2304;-  const SBool  s2312 = s2310 || s2311;-  const SWord8 s2313 = (s2309 >> 1) | (s2309 << 7);-  const SWord8 s2314 = 128 | s2313;-  const SWord8 s2315 = 127 & s2313;-  const SWord8 s2316 = s2312 ? s2314 : s2315;-  const SWord8 s2317 = s2221 ? s2308 : s2316;-  const SWord8 s2318 = s2097 ? s2296 : s2317;-  const SWord8 s2319 = s2078 ? s2271 : s2318;-  const SWord8 s2320 = s2059 ? s2211 : s2319;-  const SWord8 s2321 = s1 + s2082;-  const SBool  s2322 = (SBool) ((s2321 >> 0) & 1);-  const SBool  s2323 = false != s2322;-  const SWord8 s2324 = s2323 ? s2086 : s2087;-  const SBool  s2325 = (SBool) ((s2324 >> 0) & 1);-  const SBool  s2326 = false != s2325;-  const SWord8 s2327 = s2326 ? s2092 : s2093;-  const SBool  s2328 = (SBool) ((s2327 >> 0) & 1);-  const SBool  s2329 = false != s2328;-  const SBool  s2330 = false == s2329;-  const SBool  s2331 = s2321 < s1;-  const SBool  s2332 = s2321 < s2082;-  const SBool  s2333 = s2331 || s2332;-  const SWord8 s2334 = (s2321 >> 1) | (s2321 << 7);-  const SWord8 s2335 = 128 | s2334;-  const SWord8 s2336 = 127 & s2334;-  const SWord8 s2337 = s2333 ? s2335 : s2336;-  const SBool  s2338 = (SBool) ((s2337 >> 0) & 1);-  const SBool  s2339 = false != s2338;-  const SWord8 s2340 = (s2324 >> 1) | (s2324 << 7);-  const SWord8 s2341 = 128 | s2340;-  const SWord8 s2342 = 127 & s2340;-  const SWord8 s2343 = s2339 ? s2341 : s2342;-  const SBool  s2344 = (SBool) ((s2343 >> 0) & 1);-  const SBool  s2345 = false != s2344;-  const SWord8 s2346 = (s2327 >> 1) | (s2327 << 7);-  const SWord8 s2347 = 128 | s2346;-  const SWord8 s2348 = 127 & s2346;-  const SWord8 s2349 = s2345 ? s2347 : s2348;-  const SBool  s2350 = (SBool) ((s2349 >> 0) & 1);-  const SBool  s2351 = false != s2350;-  const SBool  s2352 = false == s2351;-  const SWord8 s2353 = (s2337 >> 1) | (s2337 << 7);-  const SWord8 s2354 = 128 | s2353;-  const SWord8 s2355 = 127 & s2353;-  const SWord8 s2356 = s2058 ? s2354 : s2355;-  const SWord8 s2357 = (s2356 >> 1) | (s2356 << 7);-  const SWord8 s2358 = 128 | s2357;-  const SWord8 s2359 = 127 & s2357;-  const SWord8 s2360 = s2077 ? s2358 : s2359;-  const SWord8 s2361 = (s2360 >> 1) | (s2360 << 7);-  const SWord8 s2362 = 128 | s2361;-  const SWord8 s2363 = 127 & s2361;-  const SWord8 s2364 = s2329 ? s2362 : s2363;-  const SWord8 s2365 = (s2364 >> 1) | (s2364 << 7);-  const SWord8 s2366 = 128 | s2365;-  const SWord8 s2367 = 127 & s2365;-  const SWord8 s2368 = s2351 ? s2366 : s2367;-  const SWord8 s2369 = s1 + s2364;-  const SBool  s2370 = s2369 < s1;-  const SBool  s2371 = s2369 < s2364;-  const SBool  s2372 = s2370 || s2371;-  const SWord8 s2373 = (s2369 >> 1) | (s2369 << 7);-  const SWord8 s2374 = 128 | s2373;-  const SWord8 s2375 = 127 & s2373;-  const SWord8 s2376 = s2372 ? s2374 : s2375;-  const SWord8 s2377 = s2352 ? s2368 : s2376;-  const SWord8 s2378 = s1 + s2360;-  const SBool  s2379 = s2378 < s1;-  const SBool  s2380 = s2378 < s2360;-  const SBool  s2381 = s2379 || s2380;-  const SWord8 s2382 = (s2378 >> 1) | (s2378 << 7);-  const SWord8 s2383 = 128 | s2382;-  const SWord8 s2384 = 127 & s2382;-  const SWord8 s2385 = s2381 ? s2383 : s2384;-  const SWord8 s2386 = (s2385 >> 1) | (s2385 << 7);-  const SWord8 s2387 = 128 | s2386;-  const SWord8 s2388 = 127 & s2386;-  const SWord8 s2389 = s2351 ? s2387 : s2388;-  const SWord8 s2390 = s1 + s2385;-  const SBool  s2391 = s2390 < s1;-  const SBool  s2392 = s2390 < s2385;-  const SBool  s2393 = s2391 || s2392;-  const SWord8 s2394 = (s2390 >> 1) | (s2390 << 7);-  const SWord8 s2395 = 128 | s2394;-  const SWord8 s2396 = 127 & s2394;-  const SWord8 s2397 = s2393 ? s2395 : s2396;-  const SWord8 s2398 = s2352 ? s2389 : s2397;-  const SWord8 s2399 = s2330 ? s2377 : s2398;-  const SWord8 s2400 = s1 + s2356;-  const SBool  s2401 = s2400 < s1;-  const SBool  s2402 = s2400 < s2356;-  const SBool  s2403 = s2401 || s2402;-  const SWord8 s2404 = (s2400 >> 1) | (s2400 << 7);-  const SWord8 s2405 = 128 | s2404;-  const SWord8 s2406 = 127 & s2404;-  const SWord8 s2407 = s2403 ? s2405 : s2406;-  const SWord8 s2408 = (s2407 >> 1) | (s2407 << 7);-  const SWord8 s2409 = 128 | s2408;-  const SWord8 s2410 = 127 & s2408;-  const SWord8 s2411 = s2329 ? s2409 : s2410;-  const SWord8 s2412 = (s2411 >> 1) | (s2411 << 7);-  const SWord8 s2413 = 128 | s2412;-  const SWord8 s2414 = 127 & s2412;-  const SWord8 s2415 = s2351 ? s2413 : s2414;-  const SWord8 s2416 = s1 + s2411;-  const SBool  s2417 = s2416 < s1;-  const SBool  s2418 = s2416 < s2411;-  const SBool  s2419 = s2417 || s2418;-  const SWord8 s2420 = (s2416 >> 1) | (s2416 << 7);-  const SWord8 s2421 = 128 | s2420;-  const SWord8 s2422 = 127 & s2420;-  const SWord8 s2423 = s2419 ? s2421 : s2422;-  const SWord8 s2424 = s2352 ? s2415 : s2423;-  const SWord8 s2425 = s1 + s2407;-  const SBool  s2426 = s2425 < s1;-  const SBool  s2427 = s2425 < s2407;-  const SBool  s2428 = s2426 || s2427;-  const SWord8 s2429 = (s2425 >> 1) | (s2425 << 7);-  const SWord8 s2430 = 128 | s2429;-  const SWord8 s2431 = 127 & s2429;-  const SWord8 s2432 = s2428 ? s2430 : s2431;-  const SWord8 s2433 = (s2432 >> 1) | (s2432 << 7);-  const SWord8 s2434 = 128 | s2433;-  const SWord8 s2435 = 127 & s2433;-  const SWord8 s2436 = s2351 ? s2434 : s2435;-  const SWord8 s2437 = s1 + s2432;-  const SBool  s2438 = s2437 < s1;-  const SBool  s2439 = s2437 < s2432;-  const SBool  s2440 = s2438 || s2439;-  const SWord8 s2441 = (s2437 >> 1) | (s2437 << 7);-  const SWord8 s2442 = 128 | s2441;-  const SWord8 s2443 = 127 & s2441;-  const SWord8 s2444 = s2440 ? s2442 : s2443;-  const SWord8 s2445 = s2352 ? s2436 : s2444;-  const SWord8 s2446 = s2330 ? s2424 : s2445;-  const SWord8 s2447 = s2078 ? s2399 : s2446;-  const SWord8 s2448 = s1 + s2337;-  const SBool  s2449 = (SBool) ((s2448 >> 0) & 1);-  const SBool  s2450 = false != s2449;-  const SWord8 s2451 = s2450 ? s2341 : s2342;-  const SBool  s2452 = (SBool) ((s2451 >> 0) & 1);-  const SBool  s2453 = false != s2452;-  const SWord8 s2454 = s2453 ? s2347 : s2348;-  const SBool  s2455 = (SBool) ((s2454 >> 0) & 1);-  const SBool  s2456 = false != s2455;-  const SBool  s2457 = false == s2456;-  const SBool  s2458 = s2448 < s1;-  const SBool  s2459 = s2448 < s2337;-  const SBool  s2460 = s2458 || s2459;-  const SWord8 s2461 = (s2448 >> 1) | (s2448 << 7);-  const SWord8 s2462 = 128 | s2461;-  const SWord8 s2463 = 127 & s2461;-  const SWord8 s2464 = s2460 ? s2462 : s2463;-  const SWord8 s2465 = (s2464 >> 1) | (s2464 << 7);-  const SWord8 s2466 = 128 | s2465;-  const SWord8 s2467 = 127 & s2465;-  const SWord8 s2468 = s2077 ? s2466 : s2467;-  const SWord8 s2469 = (s2468 >> 1) | (s2468 << 7);-  const SWord8 s2470 = 128 | s2469;-  const SWord8 s2471 = 127 & s2469;-  const SWord8 s2472 = s2329 ? s2470 : s2471;-  const SWord8 s2473 = (s2472 >> 1) | (s2472 << 7);-  const SWord8 s2474 = 128 | s2473;-  const SWord8 s2475 = 127 & s2473;-  const SWord8 s2476 = s2456 ? s2474 : s2475;-  const SWord8 s2477 = s1 + s2472;-  const SBool  s2478 = s2477 < s1;-  const SBool  s2479 = s2477 < s2472;-  const SBool  s2480 = s2478 || s2479;-  const SWord8 s2481 = (s2477 >> 1) | (s2477 << 7);-  const SWord8 s2482 = 128 | s2481;-  const SWord8 s2483 = 127 & s2481;-  const SWord8 s2484 = s2480 ? s2482 : s2483;-  const SWord8 s2485 = s2457 ? s2476 : s2484;-  const SWord8 s2486 = s1 + s2468;-  const SBool  s2487 = s2486 < s1;-  const SBool  s2488 = s2486 < s2468;-  const SBool  s2489 = s2487 || s2488;-  const SWord8 s2490 = (s2486 >> 1) | (s2486 << 7);-  const SWord8 s2491 = 128 | s2490;-  const SWord8 s2492 = 127 & s2490;-  const SWord8 s2493 = s2489 ? s2491 : s2492;-  const SWord8 s2494 = (s2493 >> 1) | (s2493 << 7);-  const SWord8 s2495 = 128 | s2494;-  const SWord8 s2496 = 127 & s2494;-  const SWord8 s2497 = s2456 ? s2495 : s2496;-  const SWord8 s2498 = s1 + s2493;-  const SBool  s2499 = s2498 < s1;-  const SBool  s2500 = s2498 < s2493;-  const SBool  s2501 = s2499 || s2500;-  const SWord8 s2502 = (s2498 >> 1) | (s2498 << 7);-  const SWord8 s2503 = 128 | s2502;-  const SWord8 s2504 = 127 & s2502;-  const SWord8 s2505 = s2501 ? s2503 : s2504;-  const SWord8 s2506 = s2457 ? s2497 : s2505;-  const SWord8 s2507 = s2330 ? s2485 : s2506;-  const SWord8 s2508 = s1 + s2464;-  const SBool  s2509 = s2508 < s1;-  const SBool  s2510 = s2508 < s2464;-  const SBool  s2511 = s2509 || s2510;-  const SWord8 s2512 = (s2508 >> 1) | (s2508 << 7);-  const SWord8 s2513 = 128 | s2512;-  const SWord8 s2514 = 127 & s2512;-  const SWord8 s2515 = s2511 ? s2513 : s2514;-  const SWord8 s2516 = (s2515 >> 1) | (s2515 << 7);-  const SWord8 s2517 = 128 | s2516;-  const SWord8 s2518 = 127 & s2516;-  const SWord8 s2519 = s2329 ? s2517 : s2518;-  const SWord8 s2520 = (s2519 >> 1) | (s2519 << 7);-  const SWord8 s2521 = 128 | s2520;-  const SWord8 s2522 = 127 & s2520;-  const SWord8 s2523 = s2456 ? s2521 : s2522;-  const SWord8 s2524 = s1 + s2519;-  const SBool  s2525 = s2524 < s1;-  const SBool  s2526 = s2524 < s2519;-  const SBool  s2527 = s2525 || s2526;-  const SWord8 s2528 = (s2524 >> 1) | (s2524 << 7);-  const SWord8 s2529 = 128 | s2528;-  const SWord8 s2530 = 127 & s2528;-  const SWord8 s2531 = s2527 ? s2529 : s2530;-  const SWord8 s2532 = s2457 ? s2523 : s2531;-  const SWord8 s2533 = s1 + s2515;-  const SBool  s2534 = s2533 < s1;-  const SBool  s2535 = s2533 < s2515;-  const SBool  s2536 = s2534 || s2535;-  const SWord8 s2537 = (s2533 >> 1) | (s2533 << 7);-  const SWord8 s2538 = 128 | s2537;-  const SWord8 s2539 = 127 & s2537;-  const SWord8 s2540 = s2536 ? s2538 : s2539;-  const SWord8 s2541 = (s2540 >> 1) | (s2540 << 7);-  const SWord8 s2542 = 128 | s2541;-  const SWord8 s2543 = 127 & s2541;-  const SWord8 s2544 = s2456 ? s2542 : s2543;-  const SWord8 s2545 = s1 + s2540;-  const SBool  s2546 = s2545 < s1;-  const SBool  s2547 = s2545 < s2540;-  const SBool  s2548 = s2546 || s2547;-  const SWord8 s2549 = (s2545 >> 1) | (s2545 << 7);-  const SWord8 s2550 = 128 | s2549;-  const SWord8 s2551 = 127 & s2549;-  const SWord8 s2552 = s2548 ? s2550 : s2551;-  const SWord8 s2553 = s2457 ? s2544 : s2552;-  const SWord8 s2554 = s2330 ? s2532 : s2553;-  const SWord8 s2555 = s2078 ? s2507 : s2554;-  const SWord8 s2556 = s2059 ? s2447 : s2555;-  const SWord8 s2557 = s2042 ? s2320 : s2556;-  const SWord8 s2558 = s1 + s2063;-  const SBool  s2559 = (SBool) ((s2558 >> 0) & 1);-  const SBool  s2560 = false != s2559;-  const SWord8 s2561 = s2560 ? s2067 : s2068;-  const SBool  s2562 = (SBool) ((s2561 >> 0) & 1);-  const SBool  s2563 = false != s2562;-  const SWord8 s2564 = s2563 ? s2073 : s2074;-  const SBool  s2565 = (SBool) ((s2564 >> 0) & 1);-  const SBool  s2566 = false != s2565;-  const SBool  s2567 = false == s2566;-  const SBool  s2568 = s2558 < s1;-  const SBool  s2569 = s2558 < s2063;-  const SBool  s2570 = s2568 || s2569;-  const SWord8 s2571 = (s2558 >> 1) | (s2558 << 7);-  const SWord8 s2572 = 128 | s2571;-  const SWord8 s2573 = 127 & s2571;-  const SWord8 s2574 = s2570 ? s2572 : s2573;-  const SBool  s2575 = (SBool) ((s2574 >> 0) & 1);-  const SBool  s2576 = false != s2575;-  const SWord8 s2577 = (s2561 >> 1) | (s2561 << 7);-  const SWord8 s2578 = 128 | s2577;-  const SWord8 s2579 = 127 & s2577;-  const SWord8 s2580 = s2576 ? s2578 : s2579;-  const SBool  s2581 = (SBool) ((s2580 >> 0) & 1);-  const SBool  s2582 = false != s2581;-  const SWord8 s2583 = (s2564 >> 1) | (s2564 << 7);-  const SWord8 s2584 = 128 | s2583;-  const SWord8 s2585 = 127 & s2583;-  const SWord8 s2586 = s2582 ? s2584 : s2585;-  const SBool  s2587 = (SBool) ((s2586 >> 0) & 1);-  const SBool  s2588 = false != s2587;-  const SBool  s2589 = false == s2588;-  const SWord8 s2590 = (s2574 >> 1) | (s2574 << 7);-  const SWord8 s2591 = 128 | s2590;-  const SWord8 s2592 = 127 & s2590;-  const SWord8 s2593 = s2041 ? s2591 : s2592;-  const SBool  s2594 = (SBool) ((s2593 >> 0) & 1);-  const SBool  s2595 = false != s2594;-  const SWord8 s2596 = (s2580 >> 1) | (s2580 << 7);-  const SWord8 s2597 = 128 | s2596;-  const SWord8 s2598 = 127 & s2596;-  const SWord8 s2599 = s2595 ? s2597 : s2598;-  const SBool  s2600 = (SBool) ((s2599 >> 0) & 1);-  const SBool  s2601 = false != s2600;-  const SWord8 s2602 = (s2586 >> 1) | (s2586 << 7);-  const SWord8 s2603 = 128 | s2602;-  const SWord8 s2604 = 127 & s2602;-  const SWord8 s2605 = s2601 ? s2603 : s2604;-  const SBool  s2606 = (SBool) ((s2605 >> 0) & 1);-  const SBool  s2607 = false != s2606;-  const SBool  s2608 = false == s2607;-  const SWord8 s2609 = (s2593 >> 1) | (s2593 << 7);-  const SWord8 s2610 = 128 | s2609;-  const SWord8 s2611 = 127 & s2609;-  const SWord8 s2612 = s2058 ? s2610 : s2611;-  const SWord8 s2613 = (s2612 >> 1) | (s2612 << 7);-  const SWord8 s2614 = 128 | s2613;-  const SWord8 s2615 = 127 & s2613;-  const SWord8 s2616 = s2566 ? s2614 : s2615;-  const SWord8 s2617 = (s2616 >> 1) | (s2616 << 7);-  const SWord8 s2618 = 128 | s2617;-  const SWord8 s2619 = 127 & s2617;-  const SWord8 s2620 = s2588 ? s2618 : s2619;-  const SWord8 s2621 = (s2620 >> 1) | (s2620 << 7);-  const SWord8 s2622 = 128 | s2621;-  const SWord8 s2623 = 127 & s2621;-  const SWord8 s2624 = s2607 ? s2622 : s2623;-  const SWord8 s2625 = s1 + s2620;-  const SBool  s2626 = s2625 < s1;-  const SBool  s2627 = s2625 < s2620;-  const SBool  s2628 = s2626 || s2627;-  const SWord8 s2629 = (s2625 >> 1) | (s2625 << 7);-  const SWord8 s2630 = 128 | s2629;-  const SWord8 s2631 = 127 & s2629;-  const SWord8 s2632 = s2628 ? s2630 : s2631;-  const SWord8 s2633 = s2608 ? s2624 : s2632;-  const SWord8 s2634 = s1 + s2616;-  const SBool  s2635 = s2634 < s1;-  const SBool  s2636 = s2634 < s2616;-  const SBool  s2637 = s2635 || s2636;-  const SWord8 s2638 = (s2634 >> 1) | (s2634 << 7);-  const SWord8 s2639 = 128 | s2638;-  const SWord8 s2640 = 127 & s2638;-  const SWord8 s2641 = s2637 ? s2639 : s2640;-  const SWord8 s2642 = (s2641 >> 1) | (s2641 << 7);-  const SWord8 s2643 = 128 | s2642;-  const SWord8 s2644 = 127 & s2642;-  const SWord8 s2645 = s2607 ? s2643 : s2644;-  const SWord8 s2646 = s1 + s2641;-  const SBool  s2647 = s2646 < s1;-  const SBool  s2648 = s2646 < s2641;-  const SBool  s2649 = s2647 || s2648;-  const SWord8 s2650 = (s2646 >> 1) | (s2646 << 7);-  const SWord8 s2651 = 128 | s2650;-  const SWord8 s2652 = 127 & s2650;-  const SWord8 s2653 = s2649 ? s2651 : s2652;-  const SWord8 s2654 = s2608 ? s2645 : s2653;-  const SWord8 s2655 = s2589 ? s2633 : s2654;-  const SWord8 s2656 = s1 + s2612;-  const SBool  s2657 = s2656 < s1;-  const SBool  s2658 = s2656 < s2612;-  const SBool  s2659 = s2657 || s2658;-  const SWord8 s2660 = (s2656 >> 1) | (s2656 << 7);-  const SWord8 s2661 = 128 | s2660;-  const SWord8 s2662 = 127 & s2660;-  const SWord8 s2663 = s2659 ? s2661 : s2662;-  const SWord8 s2664 = (s2663 >> 1) | (s2663 << 7);-  const SWord8 s2665 = 128 | s2664;-  const SWord8 s2666 = 127 & s2664;-  const SWord8 s2667 = s2588 ? s2665 : s2666;-  const SWord8 s2668 = (s2667 >> 1) | (s2667 << 7);-  const SWord8 s2669 = 128 | s2668;-  const SWord8 s2670 = 127 & s2668;-  const SWord8 s2671 = s2607 ? s2669 : s2670;-  const SWord8 s2672 = s1 + s2667;-  const SBool  s2673 = s2672 < s1;-  const SBool  s2674 = s2672 < s2667;-  const SBool  s2675 = s2673 || s2674;-  const SWord8 s2676 = (s2672 >> 1) | (s2672 << 7);-  const SWord8 s2677 = 128 | s2676;-  const SWord8 s2678 = 127 & s2676;-  const SWord8 s2679 = s2675 ? s2677 : s2678;-  const SWord8 s2680 = s2608 ? s2671 : s2679;-  const SWord8 s2681 = s1 + s2663;-  const SBool  s2682 = s2681 < s1;-  const SBool  s2683 = s2681 < s2663;-  const SBool  s2684 = s2682 || s2683;-  const SWord8 s2685 = (s2681 >> 1) | (s2681 << 7);-  const SWord8 s2686 = 128 | s2685;-  const SWord8 s2687 = 127 & s2685;-  const SWord8 s2688 = s2684 ? s2686 : s2687;-  const SWord8 s2689 = (s2688 >> 1) | (s2688 << 7);-  const SWord8 s2690 = 128 | s2689;-  const SWord8 s2691 = 127 & s2689;-  const SWord8 s2692 = s2607 ? s2690 : s2691;-  const SWord8 s2693 = s1 + s2688;-  const SBool  s2694 = s2693 < s1;-  const SBool  s2695 = s2693 < s2688;-  const SBool  s2696 = s2694 || s2695;-  const SWord8 s2697 = (s2693 >> 1) | (s2693 << 7);-  const SWord8 s2698 = 128 | s2697;-  const SWord8 s2699 = 127 & s2697;-  const SWord8 s2700 = s2696 ? s2698 : s2699;-  const SWord8 s2701 = s2608 ? s2692 : s2700;-  const SWord8 s2702 = s2589 ? s2680 : s2701;-  const SWord8 s2703 = s2567 ? s2655 : s2702;-  const SWord8 s2704 = s1 + s2593;-  const SBool  s2705 = (SBool) ((s2704 >> 0) & 1);-  const SBool  s2706 = false != s2705;-  const SWord8 s2707 = s2706 ? s2597 : s2598;-  const SBool  s2708 = (SBool) ((s2707 >> 0) & 1);-  const SBool  s2709 = false != s2708;-  const SWord8 s2710 = s2709 ? s2603 : s2604;-  const SBool  s2711 = (SBool) ((s2710 >> 0) & 1);-  const SBool  s2712 = false != s2711;-  const SBool  s2713 = false == s2712;-  const SBool  s2714 = s2704 < s1;-  const SBool  s2715 = s2704 < s2593;-  const SBool  s2716 = s2714 || s2715;-  const SWord8 s2717 = (s2704 >> 1) | (s2704 << 7);-  const SWord8 s2718 = 128 | s2717;-  const SWord8 s2719 = 127 & s2717;-  const SWord8 s2720 = s2716 ? s2718 : s2719;-  const SWord8 s2721 = (s2720 >> 1) | (s2720 << 7);-  const SWord8 s2722 = 128 | s2721;-  const SWord8 s2723 = 127 & s2721;-  const SWord8 s2724 = s2566 ? s2722 : s2723;-  const SWord8 s2725 = (s2724 >> 1) | (s2724 << 7);-  const SWord8 s2726 = 128 | s2725;-  const SWord8 s2727 = 127 & s2725;-  const SWord8 s2728 = s2588 ? s2726 : s2727;-  const SWord8 s2729 = (s2728 >> 1) | (s2728 << 7);-  const SWord8 s2730 = 128 | s2729;-  const SWord8 s2731 = 127 & s2729;-  const SWord8 s2732 = s2712 ? s2730 : s2731;-  const SWord8 s2733 = s1 + s2728;-  const SBool  s2734 = s2733 < s1;-  const SBool  s2735 = s2733 < s2728;-  const SBool  s2736 = s2734 || s2735;-  const SWord8 s2737 = (s2733 >> 1) | (s2733 << 7);-  const SWord8 s2738 = 128 | s2737;-  const SWord8 s2739 = 127 & s2737;-  const SWord8 s2740 = s2736 ? s2738 : s2739;-  const SWord8 s2741 = s2713 ? s2732 : s2740;-  const SWord8 s2742 = s1 + s2724;-  const SBool  s2743 = s2742 < s1;-  const SBool  s2744 = s2742 < s2724;-  const SBool  s2745 = s2743 || s2744;-  const SWord8 s2746 = (s2742 >> 1) | (s2742 << 7);-  const SWord8 s2747 = 128 | s2746;-  const SWord8 s2748 = 127 & s2746;-  const SWord8 s2749 = s2745 ? s2747 : s2748;-  const SWord8 s2750 = (s2749 >> 1) | (s2749 << 7);-  const SWord8 s2751 = 128 | s2750;-  const SWord8 s2752 = 127 & s2750;-  const SWord8 s2753 = s2712 ? s2751 : s2752;-  const SWord8 s2754 = s1 + s2749;-  const SBool  s2755 = s2754 < s1;-  const SBool  s2756 = s2754 < s2749;-  const SBool  s2757 = s2755 || s2756;-  const SWord8 s2758 = (s2754 >> 1) | (s2754 << 7);-  const SWord8 s2759 = 128 | s2758;-  const SWord8 s2760 = 127 & s2758;-  const SWord8 s2761 = s2757 ? s2759 : s2760;-  const SWord8 s2762 = s2713 ? s2753 : s2761;-  const SWord8 s2763 = s2589 ? s2741 : s2762;-  const SWord8 s2764 = s1 + s2720;-  const SBool  s2765 = s2764 < s1;-  const SBool  s2766 = s2764 < s2720;-  const SBool  s2767 = s2765 || s2766;-  const SWord8 s2768 = (s2764 >> 1) | (s2764 << 7);-  const SWord8 s2769 = 128 | s2768;-  const SWord8 s2770 = 127 & s2768;-  const SWord8 s2771 = s2767 ? s2769 : s2770;-  const SWord8 s2772 = (s2771 >> 1) | (s2771 << 7);-  const SWord8 s2773 = 128 | s2772;-  const SWord8 s2774 = 127 & s2772;-  const SWord8 s2775 = s2588 ? s2773 : s2774;-  const SWord8 s2776 = (s2775 >> 1) | (s2775 << 7);-  const SWord8 s2777 = 128 | s2776;-  const SWord8 s2778 = 127 & s2776;-  const SWord8 s2779 = s2712 ? s2777 : s2778;-  const SWord8 s2780 = s1 + s2775;-  const SBool  s2781 = s2780 < s1;-  const SBool  s2782 = s2780 < s2775;-  const SBool  s2783 = s2781 || s2782;-  const SWord8 s2784 = (s2780 >> 1) | (s2780 << 7);-  const SWord8 s2785 = 128 | s2784;-  const SWord8 s2786 = 127 & s2784;-  const SWord8 s2787 = s2783 ? s2785 : s2786;-  const SWord8 s2788 = s2713 ? s2779 : s2787;-  const SWord8 s2789 = s1 + s2771;-  const SBool  s2790 = s2789 < s1;-  const SBool  s2791 = s2789 < s2771;-  const SBool  s2792 = s2790 || s2791;-  const SWord8 s2793 = (s2789 >> 1) | (s2789 << 7);-  const SWord8 s2794 = 128 | s2793;-  const SWord8 s2795 = 127 & s2793;-  const SWord8 s2796 = s2792 ? s2794 : s2795;-  const SWord8 s2797 = (s2796 >> 1) | (s2796 << 7);-  const SWord8 s2798 = 128 | s2797;-  const SWord8 s2799 = 127 & s2797;-  const SWord8 s2800 = s2712 ? s2798 : s2799;-  const SWord8 s2801 = s1 + s2796;-  const SBool  s2802 = s2801 < s1;-  const SBool  s2803 = s2801 < s2796;-  const SBool  s2804 = s2802 || s2803;-  const SWord8 s2805 = (s2801 >> 1) | (s2801 << 7);-  const SWord8 s2806 = 128 | s2805;-  const SWord8 s2807 = 127 & s2805;-  const SWord8 s2808 = s2804 ? s2806 : s2807;-  const SWord8 s2809 = s2713 ? s2800 : s2808;-  const SWord8 s2810 = s2589 ? s2788 : s2809;-  const SWord8 s2811 = s2567 ? s2763 : s2810;-  const SWord8 s2812 = s2059 ? s2703 : s2811;-  const SWord8 s2813 = s1 + s2574;-  const SBool  s2814 = (SBool) ((s2813 >> 0) & 1);-  const SBool  s2815 = false != s2814;-  const SWord8 s2816 = s2815 ? s2578 : s2579;-  const SBool  s2817 = (SBool) ((s2816 >> 0) & 1);-  const SBool  s2818 = false != s2817;-  const SWord8 s2819 = s2818 ? s2584 : s2585;-  const SBool  s2820 = (SBool) ((s2819 >> 0) & 1);-  const SBool  s2821 = false != s2820;-  const SBool  s2822 = false == s2821;-  const SBool  s2823 = s2813 < s1;-  const SBool  s2824 = s2813 < s2574;-  const SBool  s2825 = s2823 || s2824;-  const SWord8 s2826 = (s2813 >> 1) | (s2813 << 7);-  const SWord8 s2827 = 128 | s2826;-  const SWord8 s2828 = 127 & s2826;-  const SWord8 s2829 = s2825 ? s2827 : s2828;-  const SBool  s2830 = (SBool) ((s2829 >> 0) & 1);-  const SBool  s2831 = false != s2830;-  const SWord8 s2832 = (s2816 >> 1) | (s2816 << 7);-  const SWord8 s2833 = 128 | s2832;-  const SWord8 s2834 = 127 & s2832;-  const SWord8 s2835 = s2831 ? s2833 : s2834;-  const SBool  s2836 = (SBool) ((s2835 >> 0) & 1);-  const SBool  s2837 = false != s2836;-  const SWord8 s2838 = (s2819 >> 1) | (s2819 << 7);-  const SWord8 s2839 = 128 | s2838;-  const SWord8 s2840 = 127 & s2838;-  const SWord8 s2841 = s2837 ? s2839 : s2840;-  const SBool  s2842 = (SBool) ((s2841 >> 0) & 1);-  const SBool  s2843 = false != s2842;-  const SBool  s2844 = false == s2843;-  const SWord8 s2845 = (s2829 >> 1) | (s2829 << 7);-  const SWord8 s2846 = 128 | s2845;-  const SWord8 s2847 = 127 & s2845;-  const SWord8 s2848 = s2058 ? s2846 : s2847;-  const SWord8 s2849 = (s2848 >> 1) | (s2848 << 7);-  const SWord8 s2850 = 128 | s2849;-  const SWord8 s2851 = 127 & s2849;-  const SWord8 s2852 = s2566 ? s2850 : s2851;-  const SWord8 s2853 = (s2852 >> 1) | (s2852 << 7);-  const SWord8 s2854 = 128 | s2853;-  const SWord8 s2855 = 127 & s2853;-  const SWord8 s2856 = s2821 ? s2854 : s2855;-  const SWord8 s2857 = (s2856 >> 1) | (s2856 << 7);-  const SWord8 s2858 = 128 | s2857;-  const SWord8 s2859 = 127 & s2857;-  const SWord8 s2860 = s2843 ? s2858 : s2859;-  const SWord8 s2861 = s1 + s2856;-  const SBool  s2862 = s2861 < s1;-  const SBool  s2863 = s2861 < s2856;-  const SBool  s2864 = s2862 || s2863;-  const SWord8 s2865 = (s2861 >> 1) | (s2861 << 7);-  const SWord8 s2866 = 128 | s2865;-  const SWord8 s2867 = 127 & s2865;-  const SWord8 s2868 = s2864 ? s2866 : s2867;-  const SWord8 s2869 = s2844 ? s2860 : s2868;-  const SWord8 s2870 = s1 + s2852;-  const SBool  s2871 = s2870 < s1;-  const SBool  s2872 = s2870 < s2852;-  const SBool  s2873 = s2871 || s2872;-  const SWord8 s2874 = (s2870 >> 1) | (s2870 << 7);-  const SWord8 s2875 = 128 | s2874;-  const SWord8 s2876 = 127 & s2874;-  const SWord8 s2877 = s2873 ? s2875 : s2876;-  const SWord8 s2878 = (s2877 >> 1) | (s2877 << 7);-  const SWord8 s2879 = 128 | s2878;-  const SWord8 s2880 = 127 & s2878;-  const SWord8 s2881 = s2843 ? s2879 : s2880;-  const SWord8 s2882 = s1 + s2877;-  const SBool  s2883 = s2882 < s1;-  const SBool  s2884 = s2882 < s2877;-  const SBool  s2885 = s2883 || s2884;-  const SWord8 s2886 = (s2882 >> 1) | (s2882 << 7);-  const SWord8 s2887 = 128 | s2886;-  const SWord8 s2888 = 127 & s2886;-  const SWord8 s2889 = s2885 ? s2887 : s2888;-  const SWord8 s2890 = s2844 ? s2881 : s2889;-  const SWord8 s2891 = s2822 ? s2869 : s2890;-  const SWord8 s2892 = s1 + s2848;-  const SBool  s2893 = s2892 < s1;-  const SBool  s2894 = s2892 < s2848;-  const SBool  s2895 = s2893 || s2894;-  const SWord8 s2896 = (s2892 >> 1) | (s2892 << 7);-  const SWord8 s2897 = 128 | s2896;-  const SWord8 s2898 = 127 & s2896;-  const SWord8 s2899 = s2895 ? s2897 : s2898;-  const SWord8 s2900 = (s2899 >> 1) | (s2899 << 7);-  const SWord8 s2901 = 128 | s2900;-  const SWord8 s2902 = 127 & s2900;-  const SWord8 s2903 = s2821 ? s2901 : s2902;-  const SWord8 s2904 = (s2903 >> 1) | (s2903 << 7);-  const SWord8 s2905 = 128 | s2904;-  const SWord8 s2906 = 127 & s2904;-  const SWord8 s2907 = s2843 ? s2905 : s2906;-  const SWord8 s2908 = s1 + s2903;-  const SBool  s2909 = s2908 < s1;-  const SBool  s2910 = s2908 < s2903;-  const SBool  s2911 = s2909 || s2910;-  const SWord8 s2912 = (s2908 >> 1) | (s2908 << 7);-  const SWord8 s2913 = 128 | s2912;-  const SWord8 s2914 = 127 & s2912;-  const SWord8 s2915 = s2911 ? s2913 : s2914;-  const SWord8 s2916 = s2844 ? s2907 : s2915;-  const SWord8 s2917 = s1 + s2899;-  const SBool  s2918 = s2917 < s1;-  const SBool  s2919 = s2917 < s2899;-  const SBool  s2920 = s2918 || s2919;-  const SWord8 s2921 = (s2917 >> 1) | (s2917 << 7);-  const SWord8 s2922 = 128 | s2921;-  const SWord8 s2923 = 127 & s2921;-  const SWord8 s2924 = s2920 ? s2922 : s2923;-  const SWord8 s2925 = (s2924 >> 1) | (s2924 << 7);-  const SWord8 s2926 = 128 | s2925;-  const SWord8 s2927 = 127 & s2925;-  const SWord8 s2928 = s2843 ? s2926 : s2927;-  const SWord8 s2929 = s1 + s2924;-  const SBool  s2930 = s2929 < s1;-  const SBool  s2931 = s2929 < s2924;-  const SBool  s2932 = s2930 || s2931;-  const SWord8 s2933 = (s2929 >> 1) | (s2929 << 7);-  const SWord8 s2934 = 128 | s2933;-  const SWord8 s2935 = 127 & s2933;-  const SWord8 s2936 = s2932 ? s2934 : s2935;-  const SWord8 s2937 = s2844 ? s2928 : s2936;-  const SWord8 s2938 = s2822 ? s2916 : s2937;-  const SWord8 s2939 = s2567 ? s2891 : s2938;-  const SWord8 s2940 = s1 + s2829;-  const SBool  s2941 = (SBool) ((s2940 >> 0) & 1);-  const SBool  s2942 = false != s2941;-  const SWord8 s2943 = s2942 ? s2833 : s2834;-  const SBool  s2944 = (SBool) ((s2943 >> 0) & 1);-  const SBool  s2945 = false != s2944;-  const SWord8 s2946 = s2945 ? s2839 : s2840;-  const SBool  s2947 = (SBool) ((s2946 >> 0) & 1);-  const SBool  s2948 = false != s2947;-  const SBool  s2949 = false == s2948;-  const SBool  s2950 = s2940 < s1;-  const SBool  s2951 = s2940 < s2829;-  const SBool  s2952 = s2950 || s2951;-  const SWord8 s2953 = (s2940 >> 1) | (s2940 << 7);-  const SWord8 s2954 = 128 | s2953;-  const SWord8 s2955 = 127 & s2953;-  const SWord8 s2956 = s2952 ? s2954 : s2955;-  const SWord8 s2957 = (s2956 >> 1) | (s2956 << 7);-  const SWord8 s2958 = 128 | s2957;-  const SWord8 s2959 = 127 & s2957;-  const SWord8 s2960 = s2566 ? s2958 : s2959;-  const SWord8 s2961 = (s2960 >> 1) | (s2960 << 7);-  const SWord8 s2962 = 128 | s2961;-  const SWord8 s2963 = 127 & s2961;-  const SWord8 s2964 = s2821 ? s2962 : s2963;-  const SWord8 s2965 = (s2964 >> 1) | (s2964 << 7);-  const SWord8 s2966 = 128 | s2965;-  const SWord8 s2967 = 127 & s2965;-  const SWord8 s2968 = s2948 ? s2966 : s2967;-  const SWord8 s2969 = s1 + s2964;-  const SBool  s2970 = s2969 < s1;-  const SBool  s2971 = s2969 < s2964;-  const SBool  s2972 = s2970 || s2971;-  const SWord8 s2973 = (s2969 >> 1) | (s2969 << 7);-  const SWord8 s2974 = 128 | s2973;-  const SWord8 s2975 = 127 & s2973;-  const SWord8 s2976 = s2972 ? s2974 : s2975;-  const SWord8 s2977 = s2949 ? s2968 : s2976;-  const SWord8 s2978 = s1 + s2960;-  const SBool  s2979 = s2978 < s1;-  const SBool  s2980 = s2978 < s2960;-  const SBool  s2981 = s2979 || s2980;-  const SWord8 s2982 = (s2978 >> 1) | (s2978 << 7);-  const SWord8 s2983 = 128 | s2982;-  const SWord8 s2984 = 127 & s2982;-  const SWord8 s2985 = s2981 ? s2983 : s2984;-  const SWord8 s2986 = (s2985 >> 1) | (s2985 << 7);-  const SWord8 s2987 = 128 | s2986;-  const SWord8 s2988 = 127 & s2986;-  const SWord8 s2989 = s2948 ? s2987 : s2988;-  const SWord8 s2990 = s1 + s2985;-  const SBool  s2991 = s2990 < s1;-  const SBool  s2992 = s2990 < s2985;-  const SBool  s2993 = s2991 || s2992;-  const SWord8 s2994 = (s2990 >> 1) | (s2990 << 7);-  const SWord8 s2995 = 128 | s2994;-  const SWord8 s2996 = 127 & s2994;-  const SWord8 s2997 = s2993 ? s2995 : s2996;-  const SWord8 s2998 = s2949 ? s2989 : s2997;-  const SWord8 s2999 = s2822 ? s2977 : s2998;-  const SWord8 s3000 = s1 + s2956;-  const SBool  s3001 = s3000 < s1;-  const SBool  s3002 = s3000 < s2956;-  const SBool  s3003 = s3001 || s3002;-  const SWord8 s3004 = (s3000 >> 1) | (s3000 << 7);-  const SWord8 s3005 = 128 | s3004;-  const SWord8 s3006 = 127 & s3004;-  const SWord8 s3007 = s3003 ? s3005 : s3006;-  const SWord8 s3008 = (s3007 >> 1) | (s3007 << 7);-  const SWord8 s3009 = 128 | s3008;-  const SWord8 s3010 = 127 & s3008;-  const SWord8 s3011 = s2821 ? s3009 : s3010;-  const SWord8 s3012 = (s3011 >> 1) | (s3011 << 7);-  const SWord8 s3013 = 128 | s3012;-  const SWord8 s3014 = 127 & s3012;-  const SWord8 s3015 = s2948 ? s3013 : s3014;-  const SWord8 s3016 = s1 + s3011;-  const SBool  s3017 = s3016 < s1;-  const SBool  s3018 = s3016 < s3011;-  const SBool  s3019 = s3017 || s3018;-  const SWord8 s3020 = (s3016 >> 1) | (s3016 << 7);-  const SWord8 s3021 = 128 | s3020;-  const SWord8 s3022 = 127 & s3020;-  const SWord8 s3023 = s3019 ? s3021 : s3022;-  const SWord8 s3024 = s2949 ? s3015 : s3023;-  const SWord8 s3025 = s1 + s3007;-  const SBool  s3026 = s3025 < s1;-  const SBool  s3027 = s3025 < s3007;-  const SBool  s3028 = s3026 || s3027;-  const SWord8 s3029 = (s3025 >> 1) | (s3025 << 7);-  const SWord8 s3030 = 128 | s3029;-  const SWord8 s3031 = 127 & s3029;-  const SWord8 s3032 = s3028 ? s3030 : s3031;-  const SWord8 s3033 = (s3032 >> 1) | (s3032 << 7);-  const SWord8 s3034 = 128 | s3033;-  const SWord8 s3035 = 127 & s3033;-  const SWord8 s3036 = s2948 ? s3034 : s3035;-  const SWord8 s3037 = s1 + s3032;-  const SBool  s3038 = s3037 < s1;-  const SBool  s3039 = s3037 < s3032;-  const SBool  s3040 = s3038 || s3039;-  const SWord8 s3041 = (s3037 >> 1) | (s3037 << 7);-  const SWord8 s3042 = 128 | s3041;-  const SWord8 s3043 = 127 & s3041;-  const SWord8 s3044 = s3040 ? s3042 : s3043;-  const SWord8 s3045 = s2949 ? s3036 : s3044;-  const SWord8 s3046 = s2822 ? s3024 : s3045;-  const SWord8 s3047 = s2567 ? s2999 : s3046;-  const SWord8 s3048 = s2059 ? s2939 : s3047;-  const SWord8 s3049 = s2042 ? s2812 : s3048;-  const SWord8 s3050 = s16 ? s2557 : s3049;-  const SWord8 s3051 = s1 + s2044;-  const SBool  s3052 = (SBool) ((s3051 >> 0) & 1);-  const SBool  s3053 = false != s3052;-  const SWord8 s3054 = s3053 ? s2048 : s2049;-  const SBool  s3055 = (SBool) ((s3054 >> 0) & 1);-  const SBool  s3056 = false != s3055;-  const SWord8 s3057 = s3056 ? s2054 : s2055;-  const SBool  s3058 = (SBool) ((s3057 >> 0) & 1);-  const SBool  s3059 = false != s3058;-  const SBool  s3060 = false == s3059;-  const SBool  s3061 = s3051 < s1;-  const SBool  s3062 = s3051 < s2044;-  const SBool  s3063 = s3061 || s3062;-  const SWord8 s3064 = (s3051 >> 1) | (s3051 << 7);-  const SWord8 s3065 = 128 | s3064;-  const SWord8 s3066 = 127 & s3064;-  const SWord8 s3067 = s3063 ? s3065 : s3066;-  const SBool  s3068 = (SBool) ((s3067 >> 0) & 1);-  const SBool  s3069 = false != s3068;-  const SWord8 s3070 = (s3054 >> 1) | (s3054 << 7);-  const SWord8 s3071 = 128 | s3070;-  const SWord8 s3072 = 127 & s3070;-  const SWord8 s3073 = s3069 ? s3071 : s3072;-  const SBool  s3074 = (SBool) ((s3073 >> 0) & 1);-  const SBool  s3075 = false != s3074;-  const SWord8 s3076 = (s3057 >> 1) | (s3057 << 7);-  const SWord8 s3077 = 128 | s3076;-  const SWord8 s3078 = 127 & s3076;-  const SWord8 s3079 = s3075 ? s3077 : s3078;-  const SBool  s3080 = (SBool) ((s3079 >> 0) & 1);-  const SBool  s3081 = false != s3080;-  const SBool  s3082 = false == s3081;-  const SWord8 s3083 = (s3067 >> 1) | (s3067 << 7);-  const SWord8 s3084 = 128 | s3083;-  const SWord8 s3085 = 127 & s3083;-  const SWord8 s3086 = s15 ? s3084 : s3085;-  const SBool  s3087 = (SBool) ((s3086 >> 0) & 1);-  const SBool  s3088 = false != s3087;-  const SWord8 s3089 = (s3073 >> 1) | (s3073 << 7);-  const SWord8 s3090 = 128 | s3089;-  const SWord8 s3091 = 127 & s3089;-  const SWord8 s3092 = s3088 ? s3090 : s3091;-  const SBool  s3093 = (SBool) ((s3092 >> 0) & 1);-  const SBool  s3094 = false != s3093;-  const SWord8 s3095 = (s3079 >> 1) | (s3079 << 7);-  const SWord8 s3096 = 128 | s3095;-  const SWord8 s3097 = 127 & s3095;-  const SWord8 s3098 = s3094 ? s3096 : s3097;-  const SBool  s3099 = (SBool) ((s3098 >> 0) & 1);-  const SBool  s3100 = false != s3099;-  const SBool  s3101 = false == s3100;-  const SWord8 s3102 = (s3086 >> 1) | (s3086 << 7);-  const SWord8 s3103 = 128 | s3102;-  const SWord8 s3104 = 127 & s3102;-  const SWord8 s3105 = s2041 ? s3103 : s3104;-  const SBool  s3106 = (SBool) ((s3105 >> 0) & 1);-  const SBool  s3107 = false != s3106;-  const SWord8 s3108 = (s3092 >> 1) | (s3092 << 7);-  const SWord8 s3109 = 128 | s3108;-  const SWord8 s3110 = 127 & s3108;-  const SWord8 s3111 = s3107 ? s3109 : s3110;-  const SBool  s3112 = (SBool) ((s3111 >> 0) & 1);-  const SBool  s3113 = false != s3112;-  const SWord8 s3114 = (s3098 >> 1) | (s3098 << 7);-  const SWord8 s3115 = 128 | s3114;-  const SWord8 s3116 = 127 & s3114;-  const SWord8 s3117 = s3113 ? s3115 : s3116;-  const SBool  s3118 = (SBool) ((s3117 >> 0) & 1);-  const SBool  s3119 = false != s3118;-  const SBool  s3120 = false == s3119;-  const SWord8 s3121 = (s3105 >> 1) | (s3105 << 7);-  const SWord8 s3122 = 128 | s3121;-  const SWord8 s3123 = 127 & s3121;-  const SWord8 s3124 = s3059 ? s3122 : s3123;-  const SWord8 s3125 = (s3124 >> 1) | (s3124 << 7);-  const SWord8 s3126 = 128 | s3125;-  const SWord8 s3127 = 127 & s3125;-  const SWord8 s3128 = s3081 ? s3126 : s3127;-  const SWord8 s3129 = (s3128 >> 1) | (s3128 << 7);-  const SWord8 s3130 = 128 | s3129;-  const SWord8 s3131 = 127 & s3129;-  const SWord8 s3132 = s3100 ? s3130 : s3131;-  const SWord8 s3133 = (s3132 >> 1) | (s3132 << 7);-  const SWord8 s3134 = 128 | s3133;-  const SWord8 s3135 = 127 & s3133;-  const SWord8 s3136 = s3119 ? s3134 : s3135;-  const SWord8 s3137 = s1 + s3132;-  const SBool  s3138 = s3137 < s1;-  const SBool  s3139 = s3137 < s3132;-  const SBool  s3140 = s3138 || s3139;-  const SWord8 s3141 = (s3137 >> 1) | (s3137 << 7);-  const SWord8 s3142 = 128 | s3141;-  const SWord8 s3143 = 127 & s3141;-  const SWord8 s3144 = s3140 ? s3142 : s3143;-  const SWord8 s3145 = s3120 ? s3136 : s3144;-  const SWord8 s3146 = s1 + s3128;-  const SBool  s3147 = s3146 < s1;-  const SBool  s3148 = s3146 < s3128;-  const SBool  s3149 = s3147 || s3148;-  const SWord8 s3150 = (s3146 >> 1) | (s3146 << 7);-  const SWord8 s3151 = 128 | s3150;-  const SWord8 s3152 = 127 & s3150;-  const SWord8 s3153 = s3149 ? s3151 : s3152;-  const SWord8 s3154 = (s3153 >> 1) | (s3153 << 7);-  const SWord8 s3155 = 128 | s3154;-  const SWord8 s3156 = 127 & s3154;-  const SWord8 s3157 = s3119 ? s3155 : s3156;-  const SWord8 s3158 = s1 + s3153;-  const SBool  s3159 = s3158 < s1;-  const SBool  s3160 = s3158 < s3153;-  const SBool  s3161 = s3159 || s3160;-  const SWord8 s3162 = (s3158 >> 1) | (s3158 << 7);-  const SWord8 s3163 = 128 | s3162;-  const SWord8 s3164 = 127 & s3162;-  const SWord8 s3165 = s3161 ? s3163 : s3164;-  const SWord8 s3166 = s3120 ? s3157 : s3165;-  const SWord8 s3167 = s3101 ? s3145 : s3166;-  const SWord8 s3168 = s1 + s3124;-  const SBool  s3169 = s3168 < s1;-  const SBool  s3170 = s3168 < s3124;-  const SBool  s3171 = s3169 || s3170;-  const SWord8 s3172 = (s3168 >> 1) | (s3168 << 7);-  const SWord8 s3173 = 128 | s3172;-  const SWord8 s3174 = 127 & s3172;-  const SWord8 s3175 = s3171 ? s3173 : s3174;-  const SWord8 s3176 = (s3175 >> 1) | (s3175 << 7);-  const SWord8 s3177 = 128 | s3176;-  const SWord8 s3178 = 127 & s3176;-  const SWord8 s3179 = s3100 ? s3177 : s3178;-  const SWord8 s3180 = (s3179 >> 1) | (s3179 << 7);-  const SWord8 s3181 = 128 | s3180;-  const SWord8 s3182 = 127 & s3180;-  const SWord8 s3183 = s3119 ? s3181 : s3182;-  const SWord8 s3184 = s1 + s3179;-  const SBool  s3185 = s3184 < s1;-  const SBool  s3186 = s3184 < s3179;-  const SBool  s3187 = s3185 || s3186;-  const SWord8 s3188 = (s3184 >> 1) | (s3184 << 7);-  const SWord8 s3189 = 128 | s3188;-  const SWord8 s3190 = 127 & s3188;-  const SWord8 s3191 = s3187 ? s3189 : s3190;-  const SWord8 s3192 = s3120 ? s3183 : s3191;-  const SWord8 s3193 = s1 + s3175;-  const SBool  s3194 = s3193 < s1;-  const SBool  s3195 = s3193 < s3175;-  const SBool  s3196 = s3194 || s3195;-  const SWord8 s3197 = (s3193 >> 1) | (s3193 << 7);-  const SWord8 s3198 = 128 | s3197;-  const SWord8 s3199 = 127 & s3197;-  const SWord8 s3200 = s3196 ? s3198 : s3199;-  const SWord8 s3201 = (s3200 >> 1) | (s3200 << 7);-  const SWord8 s3202 = 128 | s3201;-  const SWord8 s3203 = 127 & s3201;-  const SWord8 s3204 = s3119 ? s3202 : s3203;-  const SWord8 s3205 = s1 + s3200;-  const SBool  s3206 = s3205 < s1;-  const SBool  s3207 = s3205 < s3200;-  const SBool  s3208 = s3206 || s3207;-  const SWord8 s3209 = (s3205 >> 1) | (s3205 << 7);-  const SWord8 s3210 = 128 | s3209;-  const SWord8 s3211 = 127 & s3209;-  const SWord8 s3212 = s3208 ? s3210 : s3211;-  const SWord8 s3213 = s3120 ? s3204 : s3212;-  const SWord8 s3214 = s3101 ? s3192 : s3213;-  const SWord8 s3215 = s3082 ? s3167 : s3214;-  const SWord8 s3216 = s1 + s3105;-  const SBool  s3217 = (SBool) ((s3216 >> 0) & 1);-  const SBool  s3218 = false != s3217;-  const SWord8 s3219 = s3218 ? s3109 : s3110;-  const SBool  s3220 = (SBool) ((s3219 >> 0) & 1);-  const SBool  s3221 = false != s3220;-  const SWord8 s3222 = s3221 ? s3115 : s3116;-  const SBool  s3223 = (SBool) ((s3222 >> 0) & 1);-  const SBool  s3224 = false != s3223;-  const SBool  s3225 = false == s3224;-  const SBool  s3226 = s3216 < s1;-  const SBool  s3227 = s3216 < s3105;-  const SBool  s3228 = s3226 || s3227;-  const SWord8 s3229 = (s3216 >> 1) | (s3216 << 7);-  const SWord8 s3230 = 128 | s3229;-  const SWord8 s3231 = 127 & s3229;-  const SWord8 s3232 = s3228 ? s3230 : s3231;-  const SWord8 s3233 = (s3232 >> 1) | (s3232 << 7);-  const SWord8 s3234 = 128 | s3233;-  const SWord8 s3235 = 127 & s3233;-  const SWord8 s3236 = s3081 ? s3234 : s3235;-  const SWord8 s3237 = (s3236 >> 1) | (s3236 << 7);-  const SWord8 s3238 = 128 | s3237;-  const SWord8 s3239 = 127 & s3237;-  const SWord8 s3240 = s3100 ? s3238 : s3239;-  const SWord8 s3241 = (s3240 >> 1) | (s3240 << 7);-  const SWord8 s3242 = 128 | s3241;-  const SWord8 s3243 = 127 & s3241;-  const SWord8 s3244 = s3224 ? s3242 : s3243;-  const SWord8 s3245 = s1 + s3240;-  const SBool  s3246 = s3245 < s1;-  const SBool  s3247 = s3245 < s3240;-  const SBool  s3248 = s3246 || s3247;-  const SWord8 s3249 = (s3245 >> 1) | (s3245 << 7);-  const SWord8 s3250 = 128 | s3249;-  const SWord8 s3251 = 127 & s3249;-  const SWord8 s3252 = s3248 ? s3250 : s3251;-  const SWord8 s3253 = s3225 ? s3244 : s3252;-  const SWord8 s3254 = s1 + s3236;-  const SBool  s3255 = s3254 < s1;-  const SBool  s3256 = s3254 < s3236;-  const SBool  s3257 = s3255 || s3256;-  const SWord8 s3258 = (s3254 >> 1) | (s3254 << 7);-  const SWord8 s3259 = 128 | s3258;-  const SWord8 s3260 = 127 & s3258;-  const SWord8 s3261 = s3257 ? s3259 : s3260;-  const SWord8 s3262 = (s3261 >> 1) | (s3261 << 7);-  const SWord8 s3263 = 128 | s3262;-  const SWord8 s3264 = 127 & s3262;-  const SWord8 s3265 = s3224 ? s3263 : s3264;-  const SWord8 s3266 = s1 + s3261;-  const SBool  s3267 = s3266 < s1;-  const SBool  s3268 = s3266 < s3261;-  const SBool  s3269 = s3267 || s3268;-  const SWord8 s3270 = (s3266 >> 1) | (s3266 << 7);-  const SWord8 s3271 = 128 | s3270;-  const SWord8 s3272 = 127 & s3270;-  const SWord8 s3273 = s3269 ? s3271 : s3272;-  const SWord8 s3274 = s3225 ? s3265 : s3273;-  const SWord8 s3275 = s3101 ? s3253 : s3274;-  const SWord8 s3276 = s1 + s3232;-  const SBool  s3277 = s3276 < s1;-  const SBool  s3278 = s3276 < s3232;-  const SBool  s3279 = s3277 || s3278;-  const SWord8 s3280 = (s3276 >> 1) | (s3276 << 7);-  const SWord8 s3281 = 128 | s3280;-  const SWord8 s3282 = 127 & s3280;-  const SWord8 s3283 = s3279 ? s3281 : s3282;-  const SWord8 s3284 = (s3283 >> 1) | (s3283 << 7);-  const SWord8 s3285 = 128 | s3284;-  const SWord8 s3286 = 127 & s3284;-  const SWord8 s3287 = s3100 ? s3285 : s3286;-  const SWord8 s3288 = (s3287 >> 1) | (s3287 << 7);-  const SWord8 s3289 = 128 | s3288;-  const SWord8 s3290 = 127 & s3288;-  const SWord8 s3291 = s3224 ? s3289 : s3290;-  const SWord8 s3292 = s1 + s3287;-  const SBool  s3293 = s3292 < s1;-  const SBool  s3294 = s3292 < s3287;-  const SBool  s3295 = s3293 || s3294;-  const SWord8 s3296 = (s3292 >> 1) | (s3292 << 7);-  const SWord8 s3297 = 128 | s3296;-  const SWord8 s3298 = 127 & s3296;-  const SWord8 s3299 = s3295 ? s3297 : s3298;-  const SWord8 s3300 = s3225 ? s3291 : s3299;-  const SWord8 s3301 = s1 + s3283;-  const SBool  s3302 = s3301 < s1;-  const SBool  s3303 = s3301 < s3283;-  const SBool  s3304 = s3302 || s3303;-  const SWord8 s3305 = (s3301 >> 1) | (s3301 << 7);-  const SWord8 s3306 = 128 | s3305;-  const SWord8 s3307 = 127 & s3305;-  const SWord8 s3308 = s3304 ? s3306 : s3307;-  const SWord8 s3309 = (s3308 >> 1) | (s3308 << 7);-  const SWord8 s3310 = 128 | s3309;-  const SWord8 s3311 = 127 & s3309;-  const SWord8 s3312 = s3224 ? s3310 : s3311;-  const SWord8 s3313 = s1 + s3308;-  const SBool  s3314 = s3313 < s1;-  const SBool  s3315 = s3313 < s3308;-  const SBool  s3316 = s3314 || s3315;-  const SWord8 s3317 = (s3313 >> 1) | (s3313 << 7);-  const SWord8 s3318 = 128 | s3317;-  const SWord8 s3319 = 127 & s3317;-  const SWord8 s3320 = s3316 ? s3318 : s3319;-  const SWord8 s3321 = s3225 ? s3312 : s3320;-  const SWord8 s3322 = s3101 ? s3300 : s3321;-  const SWord8 s3323 = s3082 ? s3275 : s3322;-  const SWord8 s3324 = s3060 ? s3215 : s3323;-  const SWord8 s3325 = s1 + s3086;-  const SBool  s3326 = (SBool) ((s3325 >> 0) & 1);-  const SBool  s3327 = false != s3326;-  const SWord8 s3328 = s3327 ? s3090 : s3091;-  const SBool  s3329 = (SBool) ((s3328 >> 0) & 1);-  const SBool  s3330 = false != s3329;-  const SWord8 s3331 = s3330 ? s3096 : s3097;-  const SBool  s3332 = (SBool) ((s3331 >> 0) & 1);-  const SBool  s3333 = false != s3332;-  const SBool  s3334 = false == s3333;-  const SBool  s3335 = s3325 < s1;-  const SBool  s3336 = s3325 < s3086;-  const SBool  s3337 = s3335 || s3336;-  const SWord8 s3338 = (s3325 >> 1) | (s3325 << 7);-  const SWord8 s3339 = 128 | s3338;-  const SWord8 s3340 = 127 & s3338;-  const SWord8 s3341 = s3337 ? s3339 : s3340;-  const SBool  s3342 = (SBool) ((s3341 >> 0) & 1);-  const SBool  s3343 = false != s3342;-  const SWord8 s3344 = (s3328 >> 1) | (s3328 << 7);-  const SWord8 s3345 = 128 | s3344;-  const SWord8 s3346 = 127 & s3344;-  const SWord8 s3347 = s3343 ? s3345 : s3346;-  const SBool  s3348 = (SBool) ((s3347 >> 0) & 1);-  const SBool  s3349 = false != s3348;-  const SWord8 s3350 = (s3331 >> 1) | (s3331 << 7);-  const SWord8 s3351 = 128 | s3350;-  const SWord8 s3352 = 127 & s3350;-  const SWord8 s3353 = s3349 ? s3351 : s3352;-  const SBool  s3354 = (SBool) ((s3353 >> 0) & 1);-  const SBool  s3355 = false != s3354;-  const SBool  s3356 = false == s3355;-  const SWord8 s3357 = (s3341 >> 1) | (s3341 << 7);-  const SWord8 s3358 = 128 | s3357;-  const SWord8 s3359 = 127 & s3357;-  const SWord8 s3360 = s3059 ? s3358 : s3359;-  const SWord8 s3361 = (s3360 >> 1) | (s3360 << 7);-  const SWord8 s3362 = 128 | s3361;-  const SWord8 s3363 = 127 & s3361;-  const SWord8 s3364 = s3081 ? s3362 : s3363;-  const SWord8 s3365 = (s3364 >> 1) | (s3364 << 7);-  const SWord8 s3366 = 128 | s3365;-  const SWord8 s3367 = 127 & s3365;-  const SWord8 s3368 = s3333 ? s3366 : s3367;-  const SWord8 s3369 = (s3368 >> 1) | (s3368 << 7);-  const SWord8 s3370 = 128 | s3369;-  const SWord8 s3371 = 127 & s3369;-  const SWord8 s3372 = s3355 ? s3370 : s3371;-  const SWord8 s3373 = s1 + s3368;-  const SBool  s3374 = s3373 < s1;-  const SBool  s3375 = s3373 < s3368;-  const SBool  s3376 = s3374 || s3375;-  const SWord8 s3377 = (s3373 >> 1) | (s3373 << 7);-  const SWord8 s3378 = 128 | s3377;-  const SWord8 s3379 = 127 & s3377;-  const SWord8 s3380 = s3376 ? s3378 : s3379;-  const SWord8 s3381 = s3356 ? s3372 : s3380;-  const SWord8 s3382 = s1 + s3364;-  const SBool  s3383 = s3382 < s1;-  const SBool  s3384 = s3382 < s3364;-  const SBool  s3385 = s3383 || s3384;-  const SWord8 s3386 = (s3382 >> 1) | (s3382 << 7);-  const SWord8 s3387 = 128 | s3386;-  const SWord8 s3388 = 127 & s3386;-  const SWord8 s3389 = s3385 ? s3387 : s3388;-  const SWord8 s3390 = (s3389 >> 1) | (s3389 << 7);-  const SWord8 s3391 = 128 | s3390;-  const SWord8 s3392 = 127 & s3390;-  const SWord8 s3393 = s3355 ? s3391 : s3392;-  const SWord8 s3394 = s1 + s3389;-  const SBool  s3395 = s3394 < s1;-  const SBool  s3396 = s3394 < s3389;-  const SBool  s3397 = s3395 || s3396;-  const SWord8 s3398 = (s3394 >> 1) | (s3394 << 7);-  const SWord8 s3399 = 128 | s3398;-  const SWord8 s3400 = 127 & s3398;-  const SWord8 s3401 = s3397 ? s3399 : s3400;-  const SWord8 s3402 = s3356 ? s3393 : s3401;-  const SWord8 s3403 = s3334 ? s3381 : s3402;-  const SWord8 s3404 = s1 + s3360;-  const SBool  s3405 = s3404 < s1;-  const SBool  s3406 = s3404 < s3360;-  const SBool  s3407 = s3405 || s3406;-  const SWord8 s3408 = (s3404 >> 1) | (s3404 << 7);-  const SWord8 s3409 = 128 | s3408;-  const SWord8 s3410 = 127 & s3408;-  const SWord8 s3411 = s3407 ? s3409 : s3410;-  const SWord8 s3412 = (s3411 >> 1) | (s3411 << 7);-  const SWord8 s3413 = 128 | s3412;-  const SWord8 s3414 = 127 & s3412;-  const SWord8 s3415 = s3333 ? s3413 : s3414;-  const SWord8 s3416 = (s3415 >> 1) | (s3415 << 7);-  const SWord8 s3417 = 128 | s3416;-  const SWord8 s3418 = 127 & s3416;-  const SWord8 s3419 = s3355 ? s3417 : s3418;-  const SWord8 s3420 = s1 + s3415;-  const SBool  s3421 = s3420 < s1;-  const SBool  s3422 = s3420 < s3415;-  const SBool  s3423 = s3421 || s3422;-  const SWord8 s3424 = (s3420 >> 1) | (s3420 << 7);-  const SWord8 s3425 = 128 | s3424;-  const SWord8 s3426 = 127 & s3424;-  const SWord8 s3427 = s3423 ? s3425 : s3426;-  const SWord8 s3428 = s3356 ? s3419 : s3427;-  const SWord8 s3429 = s1 + s3411;-  const SBool  s3430 = s3429 < s1;-  const SBool  s3431 = s3429 < s3411;-  const SBool  s3432 = s3430 || s3431;-  const SWord8 s3433 = (s3429 >> 1) | (s3429 << 7);-  const SWord8 s3434 = 128 | s3433;-  const SWord8 s3435 = 127 & s3433;-  const SWord8 s3436 = s3432 ? s3434 : s3435;-  const SWord8 s3437 = (s3436 >> 1) | (s3436 << 7);-  const SWord8 s3438 = 128 | s3437;-  const SWord8 s3439 = 127 & s3437;-  const SWord8 s3440 = s3355 ? s3438 : s3439;-  const SWord8 s3441 = s1 + s3436;-  const SBool  s3442 = s3441 < s1;-  const SBool  s3443 = s3441 < s3436;-  const SBool  s3444 = s3442 || s3443;-  const SWord8 s3445 = (s3441 >> 1) | (s3441 << 7);-  const SWord8 s3446 = 128 | s3445;-  const SWord8 s3447 = 127 & s3445;-  const SWord8 s3448 = s3444 ? s3446 : s3447;-  const SWord8 s3449 = s3356 ? s3440 : s3448;-  const SWord8 s3450 = s3334 ? s3428 : s3449;-  const SWord8 s3451 = s3082 ? s3403 : s3450;-  const SWord8 s3452 = s1 + s3341;-  const SBool  s3453 = (SBool) ((s3452 >> 0) & 1);-  const SBool  s3454 = false != s3453;-  const SWord8 s3455 = s3454 ? s3345 : s3346;-  const SBool  s3456 = (SBool) ((s3455 >> 0) & 1);-  const SBool  s3457 = false != s3456;-  const SWord8 s3458 = s3457 ? s3351 : s3352;-  const SBool  s3459 = (SBool) ((s3458 >> 0) & 1);-  const SBool  s3460 = false != s3459;-  const SBool  s3461 = false == s3460;-  const SBool  s3462 = s3452 < s1;-  const SBool  s3463 = s3452 < s3341;-  const SBool  s3464 = s3462 || s3463;-  const SWord8 s3465 = (s3452 >> 1) | (s3452 << 7);-  const SWord8 s3466 = 128 | s3465;-  const SWord8 s3467 = 127 & s3465;-  const SWord8 s3468 = s3464 ? s3466 : s3467;-  const SWord8 s3469 = (s3468 >> 1) | (s3468 << 7);-  const SWord8 s3470 = 128 | s3469;-  const SWord8 s3471 = 127 & s3469;-  const SWord8 s3472 = s3081 ? s3470 : s3471;-  const SWord8 s3473 = (s3472 >> 1) | (s3472 << 7);-  const SWord8 s3474 = 128 | s3473;-  const SWord8 s3475 = 127 & s3473;-  const SWord8 s3476 = s3333 ? s3474 : s3475;-  const SWord8 s3477 = (s3476 >> 1) | (s3476 << 7);-  const SWord8 s3478 = 128 | s3477;-  const SWord8 s3479 = 127 & s3477;-  const SWord8 s3480 = s3460 ? s3478 : s3479;-  const SWord8 s3481 = s1 + s3476;-  const SBool  s3482 = s3481 < s1;-  const SBool  s3483 = s3481 < s3476;-  const SBool  s3484 = s3482 || s3483;-  const SWord8 s3485 = (s3481 >> 1) | (s3481 << 7);-  const SWord8 s3486 = 128 | s3485;-  const SWord8 s3487 = 127 & s3485;-  const SWord8 s3488 = s3484 ? s3486 : s3487;-  const SWord8 s3489 = s3461 ? s3480 : s3488;-  const SWord8 s3490 = s1 + s3472;-  const SBool  s3491 = s3490 < s1;-  const SBool  s3492 = s3490 < s3472;-  const SBool  s3493 = s3491 || s3492;-  const SWord8 s3494 = (s3490 >> 1) | (s3490 << 7);-  const SWord8 s3495 = 128 | s3494;-  const SWord8 s3496 = 127 & s3494;-  const SWord8 s3497 = s3493 ? s3495 : s3496;-  const SWord8 s3498 = (s3497 >> 1) | (s3497 << 7);-  const SWord8 s3499 = 128 | s3498;-  const SWord8 s3500 = 127 & s3498;-  const SWord8 s3501 = s3460 ? s3499 : s3500;-  const SWord8 s3502 = s1 + s3497;-  const SBool  s3503 = s3502 < s1;-  const SBool  s3504 = s3502 < s3497;-  const SBool  s3505 = s3503 || s3504;-  const SWord8 s3506 = (s3502 >> 1) | (s3502 << 7);-  const SWord8 s3507 = 128 | s3506;-  const SWord8 s3508 = 127 & s3506;-  const SWord8 s3509 = s3505 ? s3507 : s3508;-  const SWord8 s3510 = s3461 ? s3501 : s3509;-  const SWord8 s3511 = s3334 ? s3489 : s3510;-  const SWord8 s3512 = s1 + s3468;-  const SBool  s3513 = s3512 < s1;-  const SBool  s3514 = s3512 < s3468;-  const SBool  s3515 = s3513 || s3514;-  const SWord8 s3516 = (s3512 >> 1) | (s3512 << 7);-  const SWord8 s3517 = 128 | s3516;-  const SWord8 s3518 = 127 & s3516;-  const SWord8 s3519 = s3515 ? s3517 : s3518;-  const SWord8 s3520 = (s3519 >> 1) | (s3519 << 7);-  const SWord8 s3521 = 128 | s3520;-  const SWord8 s3522 = 127 & s3520;-  const SWord8 s3523 = s3333 ? s3521 : s3522;-  const SWord8 s3524 = (s3523 >> 1) | (s3523 << 7);-  const SWord8 s3525 = 128 | s3524;-  const SWord8 s3526 = 127 & s3524;-  const SWord8 s3527 = s3460 ? s3525 : s3526;-  const SWord8 s3528 = s1 + s3523;-  const SBool  s3529 = s3528 < s1;-  const SBool  s3530 = s3528 < s3523;-  const SBool  s3531 = s3529 || s3530;-  const SWord8 s3532 = (s3528 >> 1) | (s3528 << 7);-  const SWord8 s3533 = 128 | s3532;-  const SWord8 s3534 = 127 & s3532;-  const SWord8 s3535 = s3531 ? s3533 : s3534;-  const SWord8 s3536 = s3461 ? s3527 : s3535;-  const SWord8 s3537 = s1 + s3519;-  const SBool  s3538 = s3537 < s1;-  const SBool  s3539 = s3537 < s3519;-  const SBool  s3540 = s3538 || s3539;-  const SWord8 s3541 = (s3537 >> 1) | (s3537 << 7);-  const SWord8 s3542 = 128 | s3541;-  const SWord8 s3543 = 127 & s3541;-  const SWord8 s3544 = s3540 ? s3542 : s3543;-  const SWord8 s3545 = (s3544 >> 1) | (s3544 << 7);-  const SWord8 s3546 = 128 | s3545;-  const SWord8 s3547 = 127 & s3545;-  const SWord8 s3548 = s3460 ? s3546 : s3547;-  const SWord8 s3549 = s1 + s3544;-  const SBool  s3550 = s3549 < s1;-  const SBool  s3551 = s3549 < s3544;-  const SBool  s3552 = s3550 || s3551;-  const SWord8 s3553 = (s3549 >> 1) | (s3549 << 7);-  const SWord8 s3554 = 128 | s3553;-  const SWord8 s3555 = 127 & s3553;-  const SWord8 s3556 = s3552 ? s3554 : s3555;-  const SWord8 s3557 = s3461 ? s3548 : s3556;-  const SWord8 s3558 = s3334 ? s3536 : s3557;-  const SWord8 s3559 = s3082 ? s3511 : s3558;-  const SWord8 s3560 = s3060 ? s3451 : s3559;-  const SWord8 s3561 = s2042 ? s3324 : s3560;-  const SWord8 s3562 = s1 + s3067;-  const SBool  s3563 = (SBool) ((s3562 >> 0) & 1);-  const SBool  s3564 = false != s3563;-  const SWord8 s3565 = s3564 ? s3071 : s3072;-  const SBool  s3566 = (SBool) ((s3565 >> 0) & 1);-  const SBool  s3567 = false != s3566;-  const SWord8 s3568 = s3567 ? s3077 : s3078;-  const SBool  s3569 = (SBool) ((s3568 >> 0) & 1);-  const SBool  s3570 = false != s3569;-  const SBool  s3571 = false == s3570;-  const SBool  s3572 = s3562 < s1;-  const SBool  s3573 = s3562 < s3067;-  const SBool  s3574 = s3572 || s3573;-  const SWord8 s3575 = (s3562 >> 1) | (s3562 << 7);-  const SWord8 s3576 = 128 | s3575;-  const SWord8 s3577 = 127 & s3575;-  const SWord8 s3578 = s3574 ? s3576 : s3577;-  const SBool  s3579 = (SBool) ((s3578 >> 0) & 1);-  const SBool  s3580 = false != s3579;-  const SWord8 s3581 = (s3565 >> 1) | (s3565 << 7);-  const SWord8 s3582 = 128 | s3581;-  const SWord8 s3583 = 127 & s3581;-  const SWord8 s3584 = s3580 ? s3582 : s3583;-  const SBool  s3585 = (SBool) ((s3584 >> 0) & 1);-  const SBool  s3586 = false != s3585;-  const SWord8 s3587 = (s3568 >> 1) | (s3568 << 7);-  const SWord8 s3588 = 128 | s3587;-  const SWord8 s3589 = 127 & s3587;-  const SWord8 s3590 = s3586 ? s3588 : s3589;-  const SBool  s3591 = (SBool) ((s3590 >> 0) & 1);-  const SBool  s3592 = false != s3591;-  const SBool  s3593 = false == s3592;-  const SWord8 s3594 = (s3578 >> 1) | (s3578 << 7);-  const SWord8 s3595 = 128 | s3594;-  const SWord8 s3596 = 127 & s3594;-  const SWord8 s3597 = s2041 ? s3595 : s3596;-  const SBool  s3598 = (SBool) ((s3597 >> 0) & 1);-  const SBool  s3599 = false != s3598;-  const SWord8 s3600 = (s3584 >> 1) | (s3584 << 7);-  const SWord8 s3601 = 128 | s3600;-  const SWord8 s3602 = 127 & s3600;-  const SWord8 s3603 = s3599 ? s3601 : s3602;-  const SBool  s3604 = (SBool) ((s3603 >> 0) & 1);-  const SBool  s3605 = false != s3604;-  const SWord8 s3606 = (s3590 >> 1) | (s3590 << 7);-  const SWord8 s3607 = 128 | s3606;-  const SWord8 s3608 = 127 & s3606;-  const SWord8 s3609 = s3605 ? s3607 : s3608;-  const SBool  s3610 = (SBool) ((s3609 >> 0) & 1);-  const SBool  s3611 = false != s3610;-  const SBool  s3612 = false == s3611;-  const SWord8 s3613 = (s3597 >> 1) | (s3597 << 7);-  const SWord8 s3614 = 128 | s3613;-  const SWord8 s3615 = 127 & s3613;-  const SWord8 s3616 = s3059 ? s3614 : s3615;-  const SWord8 s3617 = (s3616 >> 1) | (s3616 << 7);-  const SWord8 s3618 = 128 | s3617;-  const SWord8 s3619 = 127 & s3617;-  const SWord8 s3620 = s3570 ? s3618 : s3619;-  const SWord8 s3621 = (s3620 >> 1) | (s3620 << 7);-  const SWord8 s3622 = 128 | s3621;-  const SWord8 s3623 = 127 & s3621;-  const SWord8 s3624 = s3592 ? s3622 : s3623;-  const SWord8 s3625 = (s3624 >> 1) | (s3624 << 7);-  const SWord8 s3626 = 128 | s3625;-  const SWord8 s3627 = 127 & s3625;-  const SWord8 s3628 = s3611 ? s3626 : s3627;-  const SWord8 s3629 = s1 + s3624;-  const SBool  s3630 = s3629 < s1;-  const SBool  s3631 = s3629 < s3624;-  const SBool  s3632 = s3630 || s3631;-  const SWord8 s3633 = (s3629 >> 1) | (s3629 << 7);-  const SWord8 s3634 = 128 | s3633;-  const SWord8 s3635 = 127 & s3633;-  const SWord8 s3636 = s3632 ? s3634 : s3635;-  const SWord8 s3637 = s3612 ? s3628 : s3636;-  const SWord8 s3638 = s1 + s3620;-  const SBool  s3639 = s3638 < s1;-  const SBool  s3640 = s3638 < s3620;-  const SBool  s3641 = s3639 || s3640;-  const SWord8 s3642 = (s3638 >> 1) | (s3638 << 7);-  const SWord8 s3643 = 128 | s3642;-  const SWord8 s3644 = 127 & s3642;-  const SWord8 s3645 = s3641 ? s3643 : s3644;-  const SWord8 s3646 = (s3645 >> 1) | (s3645 << 7);-  const SWord8 s3647 = 128 | s3646;-  const SWord8 s3648 = 127 & s3646;-  const SWord8 s3649 = s3611 ? s3647 : s3648;-  const SWord8 s3650 = s1 + s3645;-  const SBool  s3651 = s3650 < s1;-  const SBool  s3652 = s3650 < s3645;-  const SBool  s3653 = s3651 || s3652;-  const SWord8 s3654 = (s3650 >> 1) | (s3650 << 7);-  const SWord8 s3655 = 128 | s3654;-  const SWord8 s3656 = 127 & s3654;-  const SWord8 s3657 = s3653 ? s3655 : s3656;-  const SWord8 s3658 = s3612 ? s3649 : s3657;-  const SWord8 s3659 = s3593 ? s3637 : s3658;-  const SWord8 s3660 = s1 + s3616;-  const SBool  s3661 = s3660 < s1;-  const SBool  s3662 = s3660 < s3616;-  const SBool  s3663 = s3661 || s3662;-  const SWord8 s3664 = (s3660 >> 1) | (s3660 << 7);-  const SWord8 s3665 = 128 | s3664;-  const SWord8 s3666 = 127 & s3664;-  const SWord8 s3667 = s3663 ? s3665 : s3666;-  const SWord8 s3668 = (s3667 >> 1) | (s3667 << 7);-  const SWord8 s3669 = 128 | s3668;-  const SWord8 s3670 = 127 & s3668;-  const SWord8 s3671 = s3592 ? s3669 : s3670;-  const SWord8 s3672 = (s3671 >> 1) | (s3671 << 7);-  const SWord8 s3673 = 128 | s3672;-  const SWord8 s3674 = 127 & s3672;-  const SWord8 s3675 = s3611 ? s3673 : s3674;-  const SWord8 s3676 = s1 + s3671;-  const SBool  s3677 = s3676 < s1;-  const SBool  s3678 = s3676 < s3671;-  const SBool  s3679 = s3677 || s3678;-  const SWord8 s3680 = (s3676 >> 1) | (s3676 << 7);-  const SWord8 s3681 = 128 | s3680;-  const SWord8 s3682 = 127 & s3680;-  const SWord8 s3683 = s3679 ? s3681 : s3682;-  const SWord8 s3684 = s3612 ? s3675 : s3683;-  const SWord8 s3685 = s1 + s3667;-  const SBool  s3686 = s3685 < s1;-  const SBool  s3687 = s3685 < s3667;-  const SBool  s3688 = s3686 || s3687;-  const SWord8 s3689 = (s3685 >> 1) | (s3685 << 7);-  const SWord8 s3690 = 128 | s3689;-  const SWord8 s3691 = 127 & s3689;-  const SWord8 s3692 = s3688 ? s3690 : s3691;-  const SWord8 s3693 = (s3692 >> 1) | (s3692 << 7);-  const SWord8 s3694 = 128 | s3693;-  const SWord8 s3695 = 127 & s3693;-  const SWord8 s3696 = s3611 ? s3694 : s3695;-  const SWord8 s3697 = s1 + s3692;-  const SBool  s3698 = s3697 < s1;-  const SBool  s3699 = s3697 < s3692;-  const SBool  s3700 = s3698 || s3699;-  const SWord8 s3701 = (s3697 >> 1) | (s3697 << 7);-  const SWord8 s3702 = 128 | s3701;-  const SWord8 s3703 = 127 & s3701;-  const SWord8 s3704 = s3700 ? s3702 : s3703;-  const SWord8 s3705 = s3612 ? s3696 : s3704;-  const SWord8 s3706 = s3593 ? s3684 : s3705;-  const SWord8 s3707 = s3571 ? s3659 : s3706;-  const SWord8 s3708 = s1 + s3597;-  const SBool  s3709 = (SBool) ((s3708 >> 0) & 1);-  const SBool  s3710 = false != s3709;-  const SWord8 s3711 = s3710 ? s3601 : s3602;-  const SBool  s3712 = (SBool) ((s3711 >> 0) & 1);-  const SBool  s3713 = false != s3712;-  const SWord8 s3714 = s3713 ? s3607 : s3608;-  const SBool  s3715 = (SBool) ((s3714 >> 0) & 1);-  const SBool  s3716 = false != s3715;-  const SBool  s3717 = false == s3716;-  const SBool  s3718 = s3708 < s1;-  const SBool  s3719 = s3708 < s3597;-  const SBool  s3720 = s3718 || s3719;-  const SWord8 s3721 = (s3708 >> 1) | (s3708 << 7);-  const SWord8 s3722 = 128 | s3721;-  const SWord8 s3723 = 127 & s3721;-  const SWord8 s3724 = s3720 ? s3722 : s3723;-  const SWord8 s3725 = (s3724 >> 1) | (s3724 << 7);-  const SWord8 s3726 = 128 | s3725;-  const SWord8 s3727 = 127 & s3725;-  const SWord8 s3728 = s3570 ? s3726 : s3727;-  const SWord8 s3729 = (s3728 >> 1) | (s3728 << 7);-  const SWord8 s3730 = 128 | s3729;-  const SWord8 s3731 = 127 & s3729;-  const SWord8 s3732 = s3592 ? s3730 : s3731;-  const SWord8 s3733 = (s3732 >> 1) | (s3732 << 7);-  const SWord8 s3734 = 128 | s3733;-  const SWord8 s3735 = 127 & s3733;-  const SWord8 s3736 = s3716 ? s3734 : s3735;-  const SWord8 s3737 = s1 + s3732;-  const SBool  s3738 = s3737 < s1;-  const SBool  s3739 = s3737 < s3732;-  const SBool  s3740 = s3738 || s3739;-  const SWord8 s3741 = (s3737 >> 1) | (s3737 << 7);-  const SWord8 s3742 = 128 | s3741;-  const SWord8 s3743 = 127 & s3741;-  const SWord8 s3744 = s3740 ? s3742 : s3743;-  const SWord8 s3745 = s3717 ? s3736 : s3744;-  const SWord8 s3746 = s1 + s3728;-  const SBool  s3747 = s3746 < s1;-  const SBool  s3748 = s3746 < s3728;-  const SBool  s3749 = s3747 || s3748;-  const SWord8 s3750 = (s3746 >> 1) | (s3746 << 7);-  const SWord8 s3751 = 128 | s3750;-  const SWord8 s3752 = 127 & s3750;-  const SWord8 s3753 = s3749 ? s3751 : s3752;-  const SWord8 s3754 = (s3753 >> 1) | (s3753 << 7);-  const SWord8 s3755 = 128 | s3754;-  const SWord8 s3756 = 127 & s3754;-  const SWord8 s3757 = s3716 ? s3755 : s3756;-  const SWord8 s3758 = s1 + s3753;-  const SBool  s3759 = s3758 < s1;-  const SBool  s3760 = s3758 < s3753;-  const SBool  s3761 = s3759 || s3760;-  const SWord8 s3762 = (s3758 >> 1) | (s3758 << 7);-  const SWord8 s3763 = 128 | s3762;-  const SWord8 s3764 = 127 & s3762;-  const SWord8 s3765 = s3761 ? s3763 : s3764;-  const SWord8 s3766 = s3717 ? s3757 : s3765;-  const SWord8 s3767 = s3593 ? s3745 : s3766;-  const SWord8 s3768 = s1 + s3724;-  const SBool  s3769 = s3768 < s1;-  const SBool  s3770 = s3768 < s3724;-  const SBool  s3771 = s3769 || s3770;-  const SWord8 s3772 = (s3768 >> 1) | (s3768 << 7);-  const SWord8 s3773 = 128 | s3772;-  const SWord8 s3774 = 127 & s3772;-  const SWord8 s3775 = s3771 ? s3773 : s3774;-  const SWord8 s3776 = (s3775 >> 1) | (s3775 << 7);-  const SWord8 s3777 = 128 | s3776;-  const SWord8 s3778 = 127 & s3776;-  const SWord8 s3779 = s3592 ? s3777 : s3778;-  const SWord8 s3780 = (s3779 >> 1) | (s3779 << 7);-  const SWord8 s3781 = 128 | s3780;-  const SWord8 s3782 = 127 & s3780;-  const SWord8 s3783 = s3716 ? s3781 : s3782;-  const SWord8 s3784 = s1 + s3779;-  const SBool  s3785 = s3784 < s1;-  const SBool  s3786 = s3784 < s3779;-  const SBool  s3787 = s3785 || s3786;-  const SWord8 s3788 = (s3784 >> 1) | (s3784 << 7);-  const SWord8 s3789 = 128 | s3788;-  const SWord8 s3790 = 127 & s3788;-  const SWord8 s3791 = s3787 ? s3789 : s3790;-  const SWord8 s3792 = s3717 ? s3783 : s3791;-  const SWord8 s3793 = s1 + s3775;-  const SBool  s3794 = s3793 < s1;-  const SBool  s3795 = s3793 < s3775;-  const SBool  s3796 = s3794 || s3795;-  const SWord8 s3797 = (s3793 >> 1) | (s3793 << 7);-  const SWord8 s3798 = 128 | s3797;-  const SWord8 s3799 = 127 & s3797;-  const SWord8 s3800 = s3796 ? s3798 : s3799;-  const SWord8 s3801 = (s3800 >> 1) | (s3800 << 7);-  const SWord8 s3802 = 128 | s3801;-  const SWord8 s3803 = 127 & s3801;-  const SWord8 s3804 = s3716 ? s3802 : s3803;-  const SWord8 s3805 = s1 + s3800;-  const SBool  s3806 = s3805 < s1;-  const SBool  s3807 = s3805 < s3800;-  const SBool  s3808 = s3806 || s3807;-  const SWord8 s3809 = (s3805 >> 1) | (s3805 << 7);-  const SWord8 s3810 = 128 | s3809;-  const SWord8 s3811 = 127 & s3809;-  const SWord8 s3812 = s3808 ? s3810 : s3811;-  const SWord8 s3813 = s3717 ? s3804 : s3812;-  const SWord8 s3814 = s3593 ? s3792 : s3813;-  const SWord8 s3815 = s3571 ? s3767 : s3814;-  const SWord8 s3816 = s3060 ? s3707 : s3815;-  const SWord8 s3817 = s1 + s3578;-  const SBool  s3818 = (SBool) ((s3817 >> 0) & 1);-  const SBool  s3819 = false != s3818;-  const SWord8 s3820 = s3819 ? s3582 : s3583;-  const SBool  s3821 = (SBool) ((s3820 >> 0) & 1);-  const SBool  s3822 = false != s3821;-  const SWord8 s3823 = s3822 ? s3588 : s3589;-  const SBool  s3824 = (SBool) ((s3823 >> 0) & 1);-  const SBool  s3825 = false != s3824;-  const SBool  s3826 = false == s3825;-  const SBool  s3827 = s3817 < s1;-  const SBool  s3828 = s3817 < s3578;-  const SBool  s3829 = s3827 || s3828;-  const SWord8 s3830 = (s3817 >> 1) | (s3817 << 7);-  const SWord8 s3831 = 128 | s3830;-  const SWord8 s3832 = 127 & s3830;-  const SWord8 s3833 = s3829 ? s3831 : s3832;-  const SBool  s3834 = (SBool) ((s3833 >> 0) & 1);-  const SBool  s3835 = false != s3834;-  const SWord8 s3836 = (s3820 >> 1) | (s3820 << 7);-  const SWord8 s3837 = 128 | s3836;-  const SWord8 s3838 = 127 & s3836;-  const SWord8 s3839 = s3835 ? s3837 : s3838;-  const SBool  s3840 = (SBool) ((s3839 >> 0) & 1);-  const SBool  s3841 = false != s3840;-  const SWord8 s3842 = (s3823 >> 1) | (s3823 << 7);-  const SWord8 s3843 = 128 | s3842;-  const SWord8 s3844 = 127 & s3842;-  const SWord8 s3845 = s3841 ? s3843 : s3844;-  const SBool  s3846 = (SBool) ((s3845 >> 0) & 1);-  const SBool  s3847 = false != s3846;-  const SBool  s3848 = false == s3847;-  const SWord8 s3849 = (s3833 >> 1) | (s3833 << 7);-  const SWord8 s3850 = 128 | s3849;-  const SWord8 s3851 = 127 & s3849;-  const SWord8 s3852 = s3059 ? s3850 : s3851;-  const SWord8 s3853 = (s3852 >> 1) | (s3852 << 7);-  const SWord8 s3854 = 128 | s3853;-  const SWord8 s3855 = 127 & s3853;-  const SWord8 s3856 = s3570 ? s3854 : s3855;-  const SWord8 s3857 = (s3856 >> 1) | (s3856 << 7);-  const SWord8 s3858 = 128 | s3857;-  const SWord8 s3859 = 127 & s3857;-  const SWord8 s3860 = s3825 ? s3858 : s3859;-  const SWord8 s3861 = (s3860 >> 1) | (s3860 << 7);-  const SWord8 s3862 = 128 | s3861;-  const SWord8 s3863 = 127 & s3861;-  const SWord8 s3864 = s3847 ? s3862 : s3863;-  const SWord8 s3865 = s1 + s3860;-  const SBool  s3866 = s3865 < s1;-  const SBool  s3867 = s3865 < s3860;-  const SBool  s3868 = s3866 || s3867;-  const SWord8 s3869 = (s3865 >> 1) | (s3865 << 7);-  const SWord8 s3870 = 128 | s3869;-  const SWord8 s3871 = 127 & s3869;-  const SWord8 s3872 = s3868 ? s3870 : s3871;-  const SWord8 s3873 = s3848 ? s3864 : s3872;-  const SWord8 s3874 = s1 + s3856;-  const SBool  s3875 = s3874 < s1;-  const SBool  s3876 = s3874 < s3856;-  const SBool  s3877 = s3875 || s3876;-  const SWord8 s3878 = (s3874 >> 1) | (s3874 << 7);-  const SWord8 s3879 = 128 | s3878;-  const SWord8 s3880 = 127 & s3878;-  const SWord8 s3881 = s3877 ? s3879 : s3880;-  const SWord8 s3882 = (s3881 >> 1) | (s3881 << 7);-  const SWord8 s3883 = 128 | s3882;-  const SWord8 s3884 = 127 & s3882;-  const SWord8 s3885 = s3847 ? s3883 : s3884;-  const SWord8 s3886 = s1 + s3881;-  const SBool  s3887 = s3886 < s1;-  const SBool  s3888 = s3886 < s3881;-  const SBool  s3889 = s3887 || s3888;-  const SWord8 s3890 = (s3886 >> 1) | (s3886 << 7);-  const SWord8 s3891 = 128 | s3890;-  const SWord8 s3892 = 127 & s3890;-  const SWord8 s3893 = s3889 ? s3891 : s3892;-  const SWord8 s3894 = s3848 ? s3885 : s3893;-  const SWord8 s3895 = s3826 ? s3873 : s3894;-  const SWord8 s3896 = s1 + s3852;-  const SBool  s3897 = s3896 < s1;-  const SBool  s3898 = s3896 < s3852;-  const SBool  s3899 = s3897 || s3898;-  const SWord8 s3900 = (s3896 >> 1) | (s3896 << 7);-  const SWord8 s3901 = 128 | s3900;-  const SWord8 s3902 = 127 & s3900;-  const SWord8 s3903 = s3899 ? s3901 : s3902;-  const SWord8 s3904 = (s3903 >> 1) | (s3903 << 7);-  const SWord8 s3905 = 128 | s3904;-  const SWord8 s3906 = 127 & s3904;-  const SWord8 s3907 = s3825 ? s3905 : s3906;-  const SWord8 s3908 = (s3907 >> 1) | (s3907 << 7);-  const SWord8 s3909 = 128 | s3908;-  const SWord8 s3910 = 127 & s3908;-  const SWord8 s3911 = s3847 ? s3909 : s3910;-  const SWord8 s3912 = s1 + s3907;-  const SBool  s3913 = s3912 < s1;-  const SBool  s3914 = s3912 < s3907;-  const SBool  s3915 = s3913 || s3914;-  const SWord8 s3916 = (s3912 >> 1) | (s3912 << 7);-  const SWord8 s3917 = 128 | s3916;-  const SWord8 s3918 = 127 & s3916;-  const SWord8 s3919 = s3915 ? s3917 : s3918;-  const SWord8 s3920 = s3848 ? s3911 : s3919;-  const SWord8 s3921 = s1 + s3903;-  const SBool  s3922 = s3921 < s1;-  const SBool  s3923 = s3921 < s3903;-  const SBool  s3924 = s3922 || s3923;-  const SWord8 s3925 = (s3921 >> 1) | (s3921 << 7);-  const SWord8 s3926 = 128 | s3925;-  const SWord8 s3927 = 127 & s3925;-  const SWord8 s3928 = s3924 ? s3926 : s3927;-  const SWord8 s3929 = (s3928 >> 1) | (s3928 << 7);-  const SWord8 s3930 = 128 | s3929;-  const SWord8 s3931 = 127 & s3929;-  const SWord8 s3932 = s3847 ? s3930 : s3931;-  const SWord8 s3933 = s1 + s3928;-  const SBool  s3934 = s3933 < s1;-  const SBool  s3935 = s3933 < s3928;-  const SBool  s3936 = s3934 || s3935;-  const SWord8 s3937 = (s3933 >> 1) | (s3933 << 7);-  const SWord8 s3938 = 128 | s3937;-  const SWord8 s3939 = 127 & s3937;-  const SWord8 s3940 = s3936 ? s3938 : s3939;-  const SWord8 s3941 = s3848 ? s3932 : s3940;-  const SWord8 s3942 = s3826 ? s3920 : s3941;-  const SWord8 s3943 = s3571 ? s3895 : s3942;-  const SWord8 s3944 = s1 + s3833;-  const SBool  s3945 = (SBool) ((s3944 >> 0) & 1);-  const SBool  s3946 = false != s3945;-  const SWord8 s3947 = s3946 ? s3837 : s3838;-  const SBool  s3948 = (SBool) ((s3947 >> 0) & 1);-  const SBool  s3949 = false != s3948;-  const SWord8 s3950 = s3949 ? s3843 : s3844;-  const SBool  s3951 = (SBool) ((s3950 >> 0) & 1);-  const SBool  s3952 = false != s3951;-  const SBool  s3953 = false == s3952;-  const SBool  s3954 = s3944 < s1;-  const SBool  s3955 = s3944 < s3833;-  const SBool  s3956 = s3954 || s3955;-  const SWord8 s3957 = (s3944 >> 1) | (s3944 << 7);-  const SWord8 s3958 = 128 | s3957;-  const SWord8 s3959 = 127 & s3957;-  const SWord8 s3960 = s3956 ? s3958 : s3959;-  const SWord8 s3961 = (s3960 >> 1) | (s3960 << 7);-  const SWord8 s3962 = 128 | s3961;-  const SWord8 s3963 = 127 & s3961;-  const SWord8 s3964 = s3570 ? s3962 : s3963;-  const SWord8 s3965 = (s3964 >> 1) | (s3964 << 7);-  const SWord8 s3966 = 128 | s3965;-  const SWord8 s3967 = 127 & s3965;-  const SWord8 s3968 = s3825 ? s3966 : s3967;-  const SWord8 s3969 = (s3968 >> 1) | (s3968 << 7);-  const SWord8 s3970 = 128 | s3969;-  const SWord8 s3971 = 127 & s3969;-  const SWord8 s3972 = s3952 ? s3970 : s3971;-  const SWord8 s3973 = s1 + s3968;-  const SBool  s3974 = s3973 < s1;-  const SBool  s3975 = s3973 < s3968;-  const SBool  s3976 = s3974 || s3975;-  const SWord8 s3977 = (s3973 >> 1) | (s3973 << 7);-  const SWord8 s3978 = 128 | s3977;-  const SWord8 s3979 = 127 & s3977;-  const SWord8 s3980 = s3976 ? s3978 : s3979;-  const SWord8 s3981 = s3953 ? s3972 : s3980;-  const SWord8 s3982 = s1 + s3964;-  const SBool  s3983 = s3982 < s1;-  const SBool  s3984 = s3982 < s3964;-  const SBool  s3985 = s3983 || s3984;-  const SWord8 s3986 = (s3982 >> 1) | (s3982 << 7);-  const SWord8 s3987 = 128 | s3986;-  const SWord8 s3988 = 127 & s3986;-  const SWord8 s3989 = s3985 ? s3987 : s3988;-  const SWord8 s3990 = (s3989 >> 1) | (s3989 << 7);-  const SWord8 s3991 = 128 | s3990;-  const SWord8 s3992 = 127 & s3990;-  const SWord8 s3993 = s3952 ? s3991 : s3992;-  const SWord8 s3994 = s1 + s3989;-  const SBool  s3995 = s3994 < s1;-  const SBool  s3996 = s3994 < s3989;-  const SBool  s3997 = s3995 || s3996;-  const SWord8 s3998 = (s3994 >> 1) | (s3994 << 7);-  const SWord8 s3999 = 128 | s3998;-  const SWord8 s4000 = 127 & s3998;-  const SWord8 s4001 = s3997 ? s3999 : s4000;-  const SWord8 s4002 = s3953 ? s3993 : s4001;-  const SWord8 s4003 = s3826 ? s3981 : s4002;-  const SWord8 s4004 = s1 + s3960;-  const SBool  s4005 = s4004 < s1;-  const SBool  s4006 = s4004 < s3960;-  const SBool  s4007 = s4005 || s4006;-  const SWord8 s4008 = (s4004 >> 1) | (s4004 << 7);-  const SWord8 s4009 = 128 | s4008;-  const SWord8 s4010 = 127 & s4008;-  const SWord8 s4011 = s4007 ? s4009 : s4010;-  const SWord8 s4012 = (s4011 >> 1) | (s4011 << 7);-  const SWord8 s4013 = 128 | s4012;-  const SWord8 s4014 = 127 & s4012;-  const SWord8 s4015 = s3825 ? s4013 : s4014;-  const SWord8 s4016 = (s4015 >> 1) | (s4015 << 7);-  const SWord8 s4017 = 128 | s4016;-  const SWord8 s4018 = 127 & s4016;-  const SWord8 s4019 = s3952 ? s4017 : s4018;-  const SWord8 s4020 = s1 + s4015;-  const SBool  s4021 = s4020 < s1;-  const SBool  s4022 = s4020 < s4015;-  const SBool  s4023 = s4021 || s4022;-  const SWord8 s4024 = (s4020 >> 1) | (s4020 << 7);-  const SWord8 s4025 = 128 | s4024;-  const SWord8 s4026 = 127 & s4024;-  const SWord8 s4027 = s4023 ? s4025 : s4026;-  const SWord8 s4028 = s3953 ? s4019 : s4027;-  const SWord8 s4029 = s1 + s4011;-  const SBool  s4030 = s4029 < s1;-  const SBool  s4031 = s4029 < s4011;-  const SBool  s4032 = s4030 || s4031;-  const SWord8 s4033 = (s4029 >> 1) | (s4029 << 7);-  const SWord8 s4034 = 128 | s4033;-  const SWord8 s4035 = 127 & s4033;-  const SWord8 s4036 = s4032 ? s4034 : s4035;-  const SWord8 s4037 = (s4036 >> 1) | (s4036 << 7);-  const SWord8 s4038 = 128 | s4037;-  const SWord8 s4039 = 127 & s4037;-  const SWord8 s4040 = s3952 ? s4038 : s4039;-  const SWord8 s4041 = s1 + s4036;-  const SBool  s4042 = s4041 < s1;-  const SBool  s4043 = s4041 < s4036;-  const SBool  s4044 = s4042 || s4043;-  const SWord8 s4045 = (s4041 >> 1) | (s4041 << 7);-  const SWord8 s4046 = 128 | s4045;-  const SWord8 s4047 = 127 & s4045;-  const SWord8 s4048 = s4044 ? s4046 : s4047;-  const SWord8 s4049 = s3953 ? s4040 : s4048;-  const SWord8 s4050 = s3826 ? s4028 : s4049;-  const SWord8 s4051 = s3571 ? s4003 : s4050;-  const SWord8 s4052 = s3060 ? s3943 : s4051;-  const SWord8 s4053 = s2042 ? s3816 : s4052;-  const SWord8 s4054 = s16 ? s3561 : s4053;-  const SWord8 s4055 = s11 ? s3050 : s4054;-  const SWord8 s4056 = s5 ? s2032 : s4055;-  const SBool  s4057 = (SBool) ((s105 >> 0) & 1);-  const SBool  s4058 = false != s4057;-  const SBool  s4059 = (SBool) ((s101 >> 0) & 1);-  const SBool  s4060 = false != s4059;-  const SBool  s4061 = (SBool) ((s97 >> 0) & 1);-  const SBool  s4062 = false != s4061;-  const SWord8 s4063 = (s84 >> 1) | (s84 << 7);-  const SWord8 s4064 = 128 | s4063;-  const SWord8 s4065 = 127 & s4063;-  const SWord8 s4066 = s4062 ? s4064 : s4065;-  const SWord8 s4067 = (s4066 >> 1) | (s4066 << 7);-  const SWord8 s4068 = 128 | s4067;-  const SWord8 s4069 = 127 & s4067;-  const SWord8 s4070 = s4060 ? s4068 : s4069;-  const SWord8 s4071 = (s4070 >> 1) | (s4070 << 7);-  const SWord8 s4072 = 128 | s4071;-  const SWord8 s4073 = 127 & s4071;-  const SWord8 s4074 = s4058 ? s4072 : s4073;-  const SBool  s4075 = (SBool) ((s110 >> 0) & 1);-  const SBool  s4076 = false != s4075;-  const SWord8 s4077 = s4076 ? s4072 : s4073;-  const SWord8 s4078 = s93 ? s4074 : s4077;-  const SBool  s4079 = (SBool) ((s126 >> 0) & 1);-  const SBool  s4080 = false != s4079;-  const SBool  s4081 = (SBool) ((s119 >> 0) & 1);-  const SBool  s4082 = false != s4081;-  const SWord8 s4083 = s4082 ? s4068 : s4069;-  const SWord8 s4084 = (s4083 >> 1) | (s4083 << 7);-  const SWord8 s4085 = 128 | s4084;-  const SWord8 s4086 = 127 & s4084;-  const SWord8 s4087 = s4080 ? s4085 : s4086;-  const SBool  s4088 = (SBool) ((s131 >> 0) & 1);-  const SBool  s4089 = false != s4088;-  const SWord8 s4090 = s4089 ? s4085 : s4086;-  const SWord8 s4091 = s93 ? s4087 : s4090;-  const SWord8 s4092 = s74 ? s4078 : s4091;-  const SBool  s4093 = (SBool) ((s152 >> 0) & 1);-  const SBool  s4094 = false != s4093;-  const SBool  s4095 = (SBool) ((s148 >> 0) & 1);-  const SBool  s4096 = false != s4095;-  const SBool  s4097 = (SBool) ((s141 >> 0) & 1);-  const SBool  s4098 = false != s4097;-  const SWord8 s4099 = s4098 ? s4064 : s4065;-  const SWord8 s4100 = (s4099 >> 1) | (s4099 << 7);-  const SWord8 s4101 = 128 | s4100;-  const SWord8 s4102 = 127 & s4100;-  const SWord8 s4103 = s4096 ? s4101 : s4102;-  const SWord8 s4104 = (s4103 >> 1) | (s4103 << 7);-  const SWord8 s4105 = 128 | s4104;-  const SWord8 s4106 = 127 & s4104;-  const SWord8 s4107 = s4094 ? s4105 : s4106;-  const SBool  s4108 = (SBool) ((s157 >> 0) & 1);-  const SBool  s4109 = false != s4108;-  const SWord8 s4110 = s4109 ? s4105 : s4106;-  const SWord8 s4111 = s93 ? s4107 : s4110;-  const SBool  s4112 = (SBool) ((s173 >> 0) & 1);-  const SBool  s4113 = false != s4112;-  const SBool  s4114 = (SBool) ((s166 >> 0) & 1);-  const SBool  s4115 = false != s4114;-  const SWord8 s4116 = s4115 ? s4101 : s4102;-  const SWord8 s4117 = (s4116 >> 1) | (s4116 << 7);-  const SWord8 s4118 = 128 | s4117;-  const SWord8 s4119 = 127 & s4117;-  const SWord8 s4120 = s4113 ? s4118 : s4119;-  const SBool  s4121 = (SBool) ((s178 >> 0) & 1);-  const SBool  s4122 = false != s4121;-  const SWord8 s4123 = s4122 ? s4118 : s4119;-  const SWord8 s4124 = s93 ? s4120 : s4123;-  const SWord8 s4125 = s74 ? s4111 : s4124;-  const SWord8 s4126 = s55 ? s4092 : s4125;-  const SBool  s4127 = (SBool) ((s213 >> 0) & 1);-  const SBool  s4128 = false != s4127;-  const SBool  s4129 = (SBool) ((s209 >> 0) & 1);-  const SBool  s4130 = false != s4129;-  const SBool  s4131 = (SBool) ((s205 >> 0) & 1);-  const SBool  s4132 = false != s4131;-  const SWord8 s4133 = (s192 >> 1) | (s192 << 7);-  const SWord8 s4134 = 128 | s4133;-  const SWord8 s4135 = 127 & s4133;-  const SWord8 s4136 = s4132 ? s4134 : s4135;-  const SWord8 s4137 = (s4136 >> 1) | (s4136 << 7);-  const SWord8 s4138 = 128 | s4137;-  const SWord8 s4139 = 127 & s4137;-  const SWord8 s4140 = s4130 ? s4138 : s4139;-  const SWord8 s4141 = (s4140 >> 1) | (s4140 << 7);-  const SWord8 s4142 = 128 | s4141;-  const SWord8 s4143 = 127 & s4141;-  const SWord8 s4144 = s4128 ? s4142 : s4143;-  const SBool  s4145 = (SBool) ((s218 >> 0) & 1);-  const SBool  s4146 = false != s4145;-  const SWord8 s4147 = s4146 ? s4142 : s4143;-  const SWord8 s4148 = s198 ? s4144 : s4147;-  const SBool  s4149 = (SBool) ((s234 >> 0) & 1);-  const SBool  s4150 = false != s4149;-  const SBool  s4151 = (SBool) ((s227 >> 0) & 1);-  const SBool  s4152 = false != s4151;-  const SWord8 s4153 = s4152 ? s4138 : s4139;-  const SWord8 s4154 = (s4153 >> 1) | (s4153 << 7);-  const SWord8 s4155 = 128 | s4154;-  const SWord8 s4156 = 127 & s4154;-  const SWord8 s4157 = s4150 ? s4155 : s4156;-  const SBool  s4158 = (SBool) ((s239 >> 0) & 1);-  const SBool  s4159 = false != s4158;-  const SWord8 s4160 = s4159 ? s4155 : s4156;-  const SWord8 s4161 = s198 ? s4157 : s4160;-  const SWord8 s4162 = s74 ? s4148 : s4161;-  const SBool  s4163 = (SBool) ((s260 >> 0) & 1);-  const SBool  s4164 = false != s4163;-  const SBool  s4165 = (SBool) ((s256 >> 0) & 1);-  const SBool  s4166 = false != s4165;-  const SBool  s4167 = (SBool) ((s249 >> 0) & 1);-  const SBool  s4168 = false != s4167;-  const SWord8 s4169 = s4168 ? s4134 : s4135;-  const SWord8 s4170 = (s4169 >> 1) | (s4169 << 7);-  const SWord8 s4171 = 128 | s4170;-  const SWord8 s4172 = 127 & s4170;-  const SWord8 s4173 = s4166 ? s4171 : s4172;-  const SWord8 s4174 = (s4173 >> 1) | (s4173 << 7);-  const SWord8 s4175 = 128 | s4174;-  const SWord8 s4176 = 127 & s4174;-  const SWord8 s4177 = s4164 ? s4175 : s4176;-  const SBool  s4178 = (SBool) ((s265 >> 0) & 1);-  const SBool  s4179 = false != s4178;-  const SWord8 s4180 = s4179 ? s4175 : s4176;-  const SWord8 s4181 = s198 ? s4177 : s4180;-  const SBool  s4182 = (SBool) ((s281 >> 0) & 1);-  const SBool  s4183 = false != s4182;-  const SBool  s4184 = (SBool) ((s274 >> 0) & 1);-  const SBool  s4185 = false != s4184;-  const SWord8 s4186 = s4185 ? s4171 : s4172;-  const SWord8 s4187 = (s4186 >> 1) | (s4186 << 7);-  const SWord8 s4188 = 128 | s4187;-  const SWord8 s4189 = 127 & s4187;-  const SWord8 s4190 = s4183 ? s4188 : s4189;-  const SBool  s4191 = (SBool) ((s286 >> 0) & 1);-  const SBool  s4192 = false != s4191;-  const SWord8 s4193 = s4192 ? s4188 : s4189;-  const SWord8 s4194 = s198 ? s4190 : s4193;-  const SWord8 s4195 = s74 ? s4181 : s4194;-  const SWord8 s4196 = s55 ? s4162 : s4195;-  const SWord8 s4197 = s36 ? s4126 : s4196;-  const SBool  s4198 = (SBool) ((s341 >> 0) & 1);-  const SBool  s4199 = false != s4198;-  const SBool  s4200 = (SBool) ((s337 >> 0) & 1);-  const SBool  s4201 = false != s4200;-  const SBool  s4202 = (SBool) ((s333 >> 0) & 1);-  const SBool  s4203 = false != s4202;-  const SWord8 s4204 = (s320 >> 1) | (s320 << 7);-  const SWord8 s4205 = 128 | s4204;-  const SWord8 s4206 = 127 & s4204;-  const SWord8 s4207 = s4203 ? s4205 : s4206;-  const SWord8 s4208 = (s4207 >> 1) | (s4207 << 7);-  const SWord8 s4209 = 128 | s4208;-  const SWord8 s4210 = 127 & s4208;-  const SWord8 s4211 = s4201 ? s4209 : s4210;-  const SWord8 s4212 = (s4211 >> 1) | (s4211 << 7);-  const SWord8 s4213 = 128 | s4212;-  const SWord8 s4214 = 127 & s4212;-  const SWord8 s4215 = s4199 ? s4213 : s4214;-  const SBool  s4216 = (SBool) ((s346 >> 0) & 1);-  const SBool  s4217 = false != s4216;-  const SWord8 s4218 = s4217 ? s4213 : s4214;-  const SWord8 s4219 = s329 ? s4215 : s4218;-  const SBool  s4220 = (SBool) ((s362 >> 0) & 1);-  const SBool  s4221 = false != s4220;-  const SBool  s4222 = (SBool) ((s355 >> 0) & 1);-  const SBool  s4223 = false != s4222;-  const SWord8 s4224 = s4223 ? s4209 : s4210;-  const SWord8 s4225 = (s4224 >> 1) | (s4224 << 7);-  const SWord8 s4226 = 128 | s4225;-  const SWord8 s4227 = 127 & s4225;-  const SWord8 s4228 = s4221 ? s4226 : s4227;-  const SBool  s4229 = (SBool) ((s367 >> 0) & 1);-  const SBool  s4230 = false != s4229;-  const SWord8 s4231 = s4230 ? s4226 : s4227;-  const SWord8 s4232 = s329 ? s4228 : s4231;-  const SWord8 s4233 = s307 ? s4219 : s4232;-  const SBool  s4234 = (SBool) ((s388 >> 0) & 1);-  const SBool  s4235 = false != s4234;-  const SBool  s4236 = (SBool) ((s384 >> 0) & 1);-  const SBool  s4237 = false != s4236;-  const SBool  s4238 = (SBool) ((s377 >> 0) & 1);-  const SBool  s4239 = false != s4238;-  const SWord8 s4240 = s4239 ? s4205 : s4206;-  const SWord8 s4241 = (s4240 >> 1) | (s4240 << 7);-  const SWord8 s4242 = 128 | s4241;-  const SWord8 s4243 = 127 & s4241;-  const SWord8 s4244 = s4237 ? s4242 : s4243;-  const SWord8 s4245 = (s4244 >> 1) | (s4244 << 7);-  const SWord8 s4246 = 128 | s4245;-  const SWord8 s4247 = 127 & s4245;-  const SWord8 s4248 = s4235 ? s4246 : s4247;-  const SBool  s4249 = (SBool) ((s393 >> 0) & 1);-  const SBool  s4250 = false != s4249;-  const SWord8 s4251 = s4250 ? s4246 : s4247;-  const SWord8 s4252 = s329 ? s4248 : s4251;-  const SBool  s4253 = (SBool) ((s409 >> 0) & 1);-  const SBool  s4254 = false != s4253;-  const SBool  s4255 = (SBool) ((s402 >> 0) & 1);-  const SBool  s4256 = false != s4255;-  const SWord8 s4257 = s4256 ? s4242 : s4243;-  const SWord8 s4258 = (s4257 >> 1) | (s4257 << 7);-  const SWord8 s4259 = 128 | s4258;-  const SWord8 s4260 = 127 & s4258;-  const SWord8 s4261 = s4254 ? s4259 : s4260;-  const SBool  s4262 = (SBool) ((s414 >> 0) & 1);-  const SBool  s4263 = false != s4262;-  const SWord8 s4264 = s4263 ? s4259 : s4260;-  const SWord8 s4265 = s329 ? s4261 : s4264;-  const SWord8 s4266 = s307 ? s4252 : s4265;-  const SWord8 s4267 = s55 ? s4233 : s4266;-  const SBool  s4268 = (SBool) ((s449 >> 0) & 1);-  const SBool  s4269 = false != s4268;-  const SBool  s4270 = (SBool) ((s445 >> 0) & 1);-  const SBool  s4271 = false != s4270;-  const SBool  s4272 = (SBool) ((s441 >> 0) & 1);-  const SBool  s4273 = false != s4272;-  const SWord8 s4274 = (s428 >> 1) | (s428 << 7);-  const SWord8 s4275 = 128 | s4274;-  const SWord8 s4276 = 127 & s4274;-  const SWord8 s4277 = s4273 ? s4275 : s4276;-  const SWord8 s4278 = (s4277 >> 1) | (s4277 << 7);-  const SWord8 s4279 = 128 | s4278;-  const SWord8 s4280 = 127 & s4278;-  const SWord8 s4281 = s4271 ? s4279 : s4280;-  const SWord8 s4282 = (s4281 >> 1) | (s4281 << 7);-  const SWord8 s4283 = 128 | s4282;-  const SWord8 s4284 = 127 & s4282;-  const SWord8 s4285 = s4269 ? s4283 : s4284;-  const SBool  s4286 = (SBool) ((s454 >> 0) & 1);-  const SBool  s4287 = false != s4286;-  const SWord8 s4288 = s4287 ? s4283 : s4284;-  const SWord8 s4289 = s434 ? s4285 : s4288;-  const SBool  s4290 = (SBool) ((s470 >> 0) & 1);-  const SBool  s4291 = false != s4290;-  const SBool  s4292 = (SBool) ((s463 >> 0) & 1);-  const SBool  s4293 = false != s4292;-  const SWord8 s4294 = s4293 ? s4279 : s4280;-  const SWord8 s4295 = (s4294 >> 1) | (s4294 << 7);-  const SWord8 s4296 = 128 | s4295;-  const SWord8 s4297 = 127 & s4295;-  const SWord8 s4298 = s4291 ? s4296 : s4297;-  const SBool  s4299 = (SBool) ((s475 >> 0) & 1);-  const SBool  s4300 = false != s4299;-  const SWord8 s4301 = s4300 ? s4296 : s4297;-  const SWord8 s4302 = s434 ? s4298 : s4301;-  const SWord8 s4303 = s307 ? s4289 : s4302;-  const SBool  s4304 = (SBool) ((s496 >> 0) & 1);-  const SBool  s4305 = false != s4304;-  const SBool  s4306 = (SBool) ((s492 >> 0) & 1);-  const SBool  s4307 = false != s4306;-  const SBool  s4308 = (SBool) ((s485 >> 0) & 1);-  const SBool  s4309 = false != s4308;-  const SWord8 s4310 = s4309 ? s4275 : s4276;-  const SWord8 s4311 = (s4310 >> 1) | (s4310 << 7);-  const SWord8 s4312 = 128 | s4311;-  const SWord8 s4313 = 127 & s4311;-  const SWord8 s4314 = s4307 ? s4312 : s4313;-  const SWord8 s4315 = (s4314 >> 1) | (s4314 << 7);-  const SWord8 s4316 = 128 | s4315;-  const SWord8 s4317 = 127 & s4315;-  const SWord8 s4318 = s4305 ? s4316 : s4317;-  const SBool  s4319 = (SBool) ((s501 >> 0) & 1);-  const SBool  s4320 = false != s4319;-  const SWord8 s4321 = s4320 ? s4316 : s4317;-  const SWord8 s4322 = s434 ? s4318 : s4321;-  const SBool  s4323 = (SBool) ((s517 >> 0) & 1);-  const SBool  s4324 = false != s4323;-  const SBool  s4325 = (SBool) ((s510 >> 0) & 1);-  const SBool  s4326 = false != s4325;-  const SWord8 s4327 = s4326 ? s4312 : s4313;-  const SWord8 s4328 = (s4327 >> 1) | (s4327 << 7);-  const SWord8 s4329 = 128 | s4328;-  const SWord8 s4330 = 127 & s4328;-  const SWord8 s4331 = s4324 ? s4329 : s4330;-  const SBool  s4332 = (SBool) ((s522 >> 0) & 1);-  const SBool  s4333 = false != s4332;-  const SWord8 s4334 = s4333 ? s4329 : s4330;-  const SWord8 s4335 = s434 ? s4331 : s4334;-  const SWord8 s4336 = s307 ? s4322 : s4335;-  const SWord8 s4337 = s55 ? s4303 : s4336;-  const SWord8 s4338 = s36 ? s4267 : s4337;-  const SWord8 s4339 = s21 ? s4197 : s4338;-  const SBool  s4340 = (SBool) ((s597 >> 0) & 1);-  const SBool  s4341 = false != s4340;-  const SBool  s4342 = (SBool) ((s593 >> 0) & 1);-  const SBool  s4343 = false != s4342;-  const SBool  s4344 = (SBool) ((s589 >> 0) & 1);-  const SBool  s4345 = false != s4344;-  const SWord8 s4346 = (s576 >> 1) | (s576 << 7);-  const SWord8 s4347 = 128 | s4346;-  const SWord8 s4348 = 127 & s4346;-  const SWord8 s4349 = s4345 ? s4347 : s4348;-  const SWord8 s4350 = (s4349 >> 1) | (s4349 << 7);-  const SWord8 s4351 = 128 | s4350;-  const SWord8 s4352 = 127 & s4350;-  const SWord8 s4353 = s4343 ? s4351 : s4352;-  const SWord8 s4354 = (s4353 >> 1) | (s4353 << 7);-  const SWord8 s4355 = 128 | s4354;-  const SWord8 s4356 = 127 & s4354;-  const SWord8 s4357 = s4341 ? s4355 : s4356;-  const SBool  s4358 = (SBool) ((s602 >> 0) & 1);-  const SBool  s4359 = false != s4358;-  const SWord8 s4360 = s4359 ? s4355 : s4356;-  const SWord8 s4361 = s585 ? s4357 : s4360;-  const SBool  s4362 = (SBool) ((s618 >> 0) & 1);-  const SBool  s4363 = false != s4362;-  const SBool  s4364 = (SBool) ((s611 >> 0) & 1);-  const SBool  s4365 = false != s4364;-  const SWord8 s4366 = s4365 ? s4351 : s4352;-  const SWord8 s4367 = (s4366 >> 1) | (s4366 << 7);-  const SWord8 s4368 = 128 | s4367;-  const SWord8 s4369 = 127 & s4367;-  const SWord8 s4370 = s4363 ? s4368 : s4369;-  const SBool  s4371 = (SBool) ((s623 >> 0) & 1);-  const SBool  s4372 = false != s4371;-  const SWord8 s4373 = s4372 ? s4368 : s4369;-  const SWord8 s4374 = s585 ? s4370 : s4373;-  const SWord8 s4375 = s566 ? s4361 : s4374;-  const SBool  s4376 = (SBool) ((s644 >> 0) & 1);-  const SBool  s4377 = false != s4376;-  const SBool  s4378 = (SBool) ((s640 >> 0) & 1);-  const SBool  s4379 = false != s4378;-  const SBool  s4380 = (SBool) ((s633 >> 0) & 1);-  const SBool  s4381 = false != s4380;-  const SWord8 s4382 = s4381 ? s4347 : s4348;-  const SWord8 s4383 = (s4382 >> 1) | (s4382 << 7);-  const SWord8 s4384 = 128 | s4383;-  const SWord8 s4385 = 127 & s4383;-  const SWord8 s4386 = s4379 ? s4384 : s4385;-  const SWord8 s4387 = (s4386 >> 1) | (s4386 << 7);-  const SWord8 s4388 = 128 | s4387;-  const SWord8 s4389 = 127 & s4387;-  const SWord8 s4390 = s4377 ? s4388 : s4389;-  const SBool  s4391 = (SBool) ((s649 >> 0) & 1);-  const SBool  s4392 = false != s4391;-  const SWord8 s4393 = s4392 ? s4388 : s4389;-  const SWord8 s4394 = s585 ? s4390 : s4393;-  const SBool  s4395 = (SBool) ((s665 >> 0) & 1);-  const SBool  s4396 = false != s4395;-  const SBool  s4397 = (SBool) ((s658 >> 0) & 1);-  const SBool  s4398 = false != s4397;-  const SWord8 s4399 = s4398 ? s4384 : s4385;-  const SWord8 s4400 = (s4399 >> 1) | (s4399 << 7);-  const SWord8 s4401 = 128 | s4400;-  const SWord8 s4402 = 127 & s4400;-  const SWord8 s4403 = s4396 ? s4401 : s4402;-  const SBool  s4404 = (SBool) ((s670 >> 0) & 1);-  const SBool  s4405 = false != s4404;-  const SWord8 s4406 = s4405 ? s4401 : s4402;-  const SWord8 s4407 = s585 ? s4403 : s4406;-  const SWord8 s4408 = s566 ? s4394 : s4407;-  const SWord8 s4409 = s544 ? s4375 : s4408;-  const SBool  s4410 = (SBool) ((s705 >> 0) & 1);-  const SBool  s4411 = false != s4410;-  const SBool  s4412 = (SBool) ((s701 >> 0) & 1);-  const SBool  s4413 = false != s4412;-  const SBool  s4414 = (SBool) ((s697 >> 0) & 1);-  const SBool  s4415 = false != s4414;-  const SWord8 s4416 = (s684 >> 1) | (s684 << 7);-  const SWord8 s4417 = 128 | s4416;-  const SWord8 s4418 = 127 & s4416;-  const SWord8 s4419 = s4415 ? s4417 : s4418;-  const SWord8 s4420 = (s4419 >> 1) | (s4419 << 7);-  const SWord8 s4421 = 128 | s4420;-  const SWord8 s4422 = 127 & s4420;-  const SWord8 s4423 = s4413 ? s4421 : s4422;-  const SWord8 s4424 = (s4423 >> 1) | (s4423 << 7);-  const SWord8 s4425 = 128 | s4424;-  const SWord8 s4426 = 127 & s4424;-  const SWord8 s4427 = s4411 ? s4425 : s4426;-  const SBool  s4428 = (SBool) ((s710 >> 0) & 1);-  const SBool  s4429 = false != s4428;-  const SWord8 s4430 = s4429 ? s4425 : s4426;-  const SWord8 s4431 = s690 ? s4427 : s4430;-  const SBool  s4432 = (SBool) ((s726 >> 0) & 1);-  const SBool  s4433 = false != s4432;-  const SBool  s4434 = (SBool) ((s719 >> 0) & 1);-  const SBool  s4435 = false != s4434;-  const SWord8 s4436 = s4435 ? s4421 : s4422;-  const SWord8 s4437 = (s4436 >> 1) | (s4436 << 7);-  const SWord8 s4438 = 128 | s4437;-  const SWord8 s4439 = 127 & s4437;-  const SWord8 s4440 = s4433 ? s4438 : s4439;-  const SBool  s4441 = (SBool) ((s731 >> 0) & 1);-  const SBool  s4442 = false != s4441;-  const SWord8 s4443 = s4442 ? s4438 : s4439;-  const SWord8 s4444 = s690 ? s4440 : s4443;-  const SWord8 s4445 = s566 ? s4431 : s4444;-  const SBool  s4446 = (SBool) ((s752 >> 0) & 1);-  const SBool  s4447 = false != s4446;-  const SBool  s4448 = (SBool) ((s748 >> 0) & 1);-  const SBool  s4449 = false != s4448;-  const SBool  s4450 = (SBool) ((s741 >> 0) & 1);-  const SBool  s4451 = false != s4450;-  const SWord8 s4452 = s4451 ? s4417 : s4418;-  const SWord8 s4453 = (s4452 >> 1) | (s4452 << 7);-  const SWord8 s4454 = 128 | s4453;-  const SWord8 s4455 = 127 & s4453;-  const SWord8 s4456 = s4449 ? s4454 : s4455;-  const SWord8 s4457 = (s4456 >> 1) | (s4456 << 7);-  const SWord8 s4458 = 128 | s4457;-  const SWord8 s4459 = 127 & s4457;-  const SWord8 s4460 = s4447 ? s4458 : s4459;-  const SBool  s4461 = (SBool) ((s757 >> 0) & 1);-  const SBool  s4462 = false != s4461;-  const SWord8 s4463 = s4462 ? s4458 : s4459;-  const SWord8 s4464 = s690 ? s4460 : s4463;-  const SBool  s4465 = (SBool) ((s773 >> 0) & 1);-  const SBool  s4466 = false != s4465;-  const SBool  s4467 = (SBool) ((s766 >> 0) & 1);-  const SBool  s4468 = false != s4467;-  const SWord8 s4469 = s4468 ? s4454 : s4455;-  const SWord8 s4470 = (s4469 >> 1) | (s4469 << 7);-  const SWord8 s4471 = 128 | s4470;-  const SWord8 s4472 = 127 & s4470;-  const SWord8 s4473 = s4466 ? s4471 : s4472;-  const SBool  s4474 = (SBool) ((s778 >> 0) & 1);-  const SBool  s4475 = false != s4474;-  const SWord8 s4476 = s4475 ? s4471 : s4472;-  const SWord8 s4477 = s690 ? s4473 : s4476;-  const SWord8 s4478 = s566 ? s4464 : s4477;-  const SWord8 s4479 = s544 ? s4445 : s4478;-  const SWord8 s4480 = s36 ? s4409 : s4479;-  const SBool  s4481 = (SBool) ((s833 >> 0) & 1);-  const SBool  s4482 = false != s4481;-  const SBool  s4483 = (SBool) ((s829 >> 0) & 1);-  const SBool  s4484 = false != s4483;-  const SBool  s4485 = (SBool) ((s825 >> 0) & 1);-  const SBool  s4486 = false != s4485;-  const SWord8 s4487 = (s812 >> 1) | (s812 << 7);-  const SWord8 s4488 = 128 | s4487;-  const SWord8 s4489 = 127 & s4487;-  const SWord8 s4490 = s4486 ? s4488 : s4489;-  const SWord8 s4491 = (s4490 >> 1) | (s4490 << 7);-  const SWord8 s4492 = 128 | s4491;-  const SWord8 s4493 = 127 & s4491;-  const SWord8 s4494 = s4484 ? s4492 : s4493;-  const SWord8 s4495 = (s4494 >> 1) | (s4494 << 7);-  const SWord8 s4496 = 128 | s4495;-  const SWord8 s4497 = 127 & s4495;-  const SWord8 s4498 = s4482 ? s4496 : s4497;-  const SBool  s4499 = (SBool) ((s838 >> 0) & 1);-  const SBool  s4500 = false != s4499;-  const SWord8 s4501 = s4500 ? s4496 : s4497;-  const SWord8 s4502 = s821 ? s4498 : s4501;-  const SBool  s4503 = (SBool) ((s854 >> 0) & 1);-  const SBool  s4504 = false != s4503;-  const SBool  s4505 = (SBool) ((s847 >> 0) & 1);-  const SBool  s4506 = false != s4505;-  const SWord8 s4507 = s4506 ? s4492 : s4493;-  const SWord8 s4508 = (s4507 >> 1) | (s4507 << 7);-  const SWord8 s4509 = 128 | s4508;-  const SWord8 s4510 = 127 & s4508;-  const SWord8 s4511 = s4504 ? s4509 : s4510;-  const SBool  s4512 = (SBool) ((s859 >> 0) & 1);-  const SBool  s4513 = false != s4512;-  const SWord8 s4514 = s4513 ? s4509 : s4510;-  const SWord8 s4515 = s821 ? s4511 : s4514;-  const SWord8 s4516 = s799 ? s4502 : s4515;-  const SBool  s4517 = (SBool) ((s880 >> 0) & 1);-  const SBool  s4518 = false != s4517;-  const SBool  s4519 = (SBool) ((s876 >> 0) & 1);-  const SBool  s4520 = false != s4519;-  const SBool  s4521 = (SBool) ((s869 >> 0) & 1);-  const SBool  s4522 = false != s4521;-  const SWord8 s4523 = s4522 ? s4488 : s4489;-  const SWord8 s4524 = (s4523 >> 1) | (s4523 << 7);-  const SWord8 s4525 = 128 | s4524;-  const SWord8 s4526 = 127 & s4524;-  const SWord8 s4527 = s4520 ? s4525 : s4526;-  const SWord8 s4528 = (s4527 >> 1) | (s4527 << 7);-  const SWord8 s4529 = 128 | s4528;-  const SWord8 s4530 = 127 & s4528;-  const SWord8 s4531 = s4518 ? s4529 : s4530;-  const SBool  s4532 = (SBool) ((s885 >> 0) & 1);-  const SBool  s4533 = false != s4532;-  const SWord8 s4534 = s4533 ? s4529 : s4530;-  const SWord8 s4535 = s821 ? s4531 : s4534;-  const SBool  s4536 = (SBool) ((s901 >> 0) & 1);-  const SBool  s4537 = false != s4536;-  const SBool  s4538 = (SBool) ((s894 >> 0) & 1);-  const SBool  s4539 = false != s4538;-  const SWord8 s4540 = s4539 ? s4525 : s4526;-  const SWord8 s4541 = (s4540 >> 1) | (s4540 << 7);-  const SWord8 s4542 = 128 | s4541;-  const SWord8 s4543 = 127 & s4541;-  const SWord8 s4544 = s4537 ? s4542 : s4543;-  const SBool  s4545 = (SBool) ((s906 >> 0) & 1);-  const SBool  s4546 = false != s4545;-  const SWord8 s4547 = s4546 ? s4542 : s4543;-  const SWord8 s4548 = s821 ? s4544 : s4547;-  const SWord8 s4549 = s799 ? s4535 : s4548;-  const SWord8 s4550 = s544 ? s4516 : s4549;-  const SBool  s4551 = (SBool) ((s941 >> 0) & 1);-  const SBool  s4552 = false != s4551;-  const SBool  s4553 = (SBool) ((s937 >> 0) & 1);-  const SBool  s4554 = false != s4553;-  const SBool  s4555 = (SBool) ((s933 >> 0) & 1);-  const SBool  s4556 = false != s4555;-  const SWord8 s4557 = (s920 >> 1) | (s920 << 7);-  const SWord8 s4558 = 128 | s4557;-  const SWord8 s4559 = 127 & s4557;-  const SWord8 s4560 = s4556 ? s4558 : s4559;-  const SWord8 s4561 = (s4560 >> 1) | (s4560 << 7);-  const SWord8 s4562 = 128 | s4561;-  const SWord8 s4563 = 127 & s4561;-  const SWord8 s4564 = s4554 ? s4562 : s4563;-  const SWord8 s4565 = (s4564 >> 1) | (s4564 << 7);-  const SWord8 s4566 = 128 | s4565;-  const SWord8 s4567 = 127 & s4565;-  const SWord8 s4568 = s4552 ? s4566 : s4567;-  const SBool  s4569 = (SBool) ((s946 >> 0) & 1);-  const SBool  s4570 = false != s4569;-  const SWord8 s4571 = s4570 ? s4566 : s4567;-  const SWord8 s4572 = s926 ? s4568 : s4571;-  const SBool  s4573 = (SBool) ((s962 >> 0) & 1);-  const SBool  s4574 = false != s4573;-  const SBool  s4575 = (SBool) ((s955 >> 0) & 1);-  const SBool  s4576 = false != s4575;-  const SWord8 s4577 = s4576 ? s4562 : s4563;-  const SWord8 s4578 = (s4577 >> 1) | (s4577 << 7);-  const SWord8 s4579 = 128 | s4578;-  const SWord8 s4580 = 127 & s4578;-  const SWord8 s4581 = s4574 ? s4579 : s4580;-  const SBool  s4582 = (SBool) ((s967 >> 0) & 1);-  const SBool  s4583 = false != s4582;-  const SWord8 s4584 = s4583 ? s4579 : s4580;-  const SWord8 s4585 = s926 ? s4581 : s4584;-  const SWord8 s4586 = s799 ? s4572 : s4585;-  const SBool  s4587 = (SBool) ((s988 >> 0) & 1);-  const SBool  s4588 = false != s4587;-  const SBool  s4589 = (SBool) ((s984 >> 0) & 1);-  const SBool  s4590 = false != s4589;-  const SBool  s4591 = (SBool) ((s977 >> 0) & 1);-  const SBool  s4592 = false != s4591;-  const SWord8 s4593 = s4592 ? s4558 : s4559;-  const SWord8 s4594 = (s4593 >> 1) | (s4593 << 7);-  const SWord8 s4595 = 128 | s4594;-  const SWord8 s4596 = 127 & s4594;-  const SWord8 s4597 = s4590 ? s4595 : s4596;-  const SWord8 s4598 = (s4597 >> 1) | (s4597 << 7);-  const SWord8 s4599 = 128 | s4598;-  const SWord8 s4600 = 127 & s4598;-  const SWord8 s4601 = s4588 ? s4599 : s4600;-  const SBool  s4602 = (SBool) ((s993 >> 0) & 1);-  const SBool  s4603 = false != s4602;-  const SWord8 s4604 = s4603 ? s4599 : s4600;-  const SWord8 s4605 = s926 ? s4601 : s4604;-  const SBool  s4606 = (SBool) ((s1009 >> 0) & 1);-  const SBool  s4607 = false != s4606;-  const SBool  s4608 = (SBool) ((s1002 >> 0) & 1);-  const SBool  s4609 = false != s4608;-  const SWord8 s4610 = s4609 ? s4595 : s4596;-  const SWord8 s4611 = (s4610 >> 1) | (s4610 << 7);-  const SWord8 s4612 = 128 | s4611;-  const SWord8 s4613 = 127 & s4611;-  const SWord8 s4614 = s4607 ? s4612 : s4613;-  const SBool  s4615 = (SBool) ((s1014 >> 0) & 1);-  const SBool  s4616 = false != s4615;-  const SWord8 s4617 = s4616 ? s4612 : s4613;-  const SWord8 s4618 = s926 ? s4614 : s4617;-  const SWord8 s4619 = s799 ? s4605 : s4618;-  const SWord8 s4620 = s544 ? s4586 : s4619;-  const SWord8 s4621 = s36 ? s4550 : s4620;-  const SWord8 s4622 = s21 ? s4480 : s4621;-  const SWord8 s4623 = s16 ? s4339 : s4622;-  const SBool  s4624 = (SBool) ((s1109 >> 0) & 1);-  const SBool  s4625 = false != s4624;-  const SBool  s4626 = (SBool) ((s1105 >> 0) & 1);-  const SBool  s4627 = false != s4626;-  const SBool  s4628 = (SBool) ((s1101 >> 0) & 1);-  const SBool  s4629 = false != s4628;-  const SWord8 s4630 = (s1088 >> 1) | (s1088 << 7);-  const SWord8 s4631 = 128 | s4630;-  const SWord8 s4632 = 127 & s4630;-  const SWord8 s4633 = s4629 ? s4631 : s4632;-  const SWord8 s4634 = (s4633 >> 1) | (s4633 << 7);-  const SWord8 s4635 = 128 | s4634;-  const SWord8 s4636 = 127 & s4634;-  const SWord8 s4637 = s4627 ? s4635 : s4636;-  const SWord8 s4638 = (s4637 >> 1) | (s4637 << 7);-  const SWord8 s4639 = 128 | s4638;-  const SWord8 s4640 = 127 & s4638;-  const SWord8 s4641 = s4625 ? s4639 : s4640;-  const SBool  s4642 = (SBool) ((s1114 >> 0) & 1);-  const SBool  s4643 = false != s4642;-  const SWord8 s4644 = s4643 ? s4639 : s4640;-  const SWord8 s4645 = s1097 ? s4641 : s4644;-  const SBool  s4646 = (SBool) ((s1130 >> 0) & 1);-  const SBool  s4647 = false != s4646;-  const SBool  s4648 = (SBool) ((s1123 >> 0) & 1);-  const SBool  s4649 = false != s4648;-  const SWord8 s4650 = s4649 ? s4635 : s4636;-  const SWord8 s4651 = (s4650 >> 1) | (s4650 << 7);-  const SWord8 s4652 = 128 | s4651;-  const SWord8 s4653 = 127 & s4651;-  const SWord8 s4654 = s4647 ? s4652 : s4653;-  const SBool  s4655 = (SBool) ((s1135 >> 0) & 1);-  const SBool  s4656 = false != s4655;-  const SWord8 s4657 = s4656 ? s4652 : s4653;-  const SWord8 s4658 = s1097 ? s4654 : s4657;-  const SWord8 s4659 = s1078 ? s4645 : s4658;-  const SBool  s4660 = (SBool) ((s1156 >> 0) & 1);-  const SBool  s4661 = false != s4660;-  const SBool  s4662 = (SBool) ((s1152 >> 0) & 1);-  const SBool  s4663 = false != s4662;-  const SBool  s4664 = (SBool) ((s1145 >> 0) & 1);-  const SBool  s4665 = false != s4664;-  const SWord8 s4666 = s4665 ? s4631 : s4632;-  const SWord8 s4667 = (s4666 >> 1) | (s4666 << 7);-  const SWord8 s4668 = 128 | s4667;-  const SWord8 s4669 = 127 & s4667;-  const SWord8 s4670 = s4663 ? s4668 : s4669;-  const SWord8 s4671 = (s4670 >> 1) | (s4670 << 7);-  const SWord8 s4672 = 128 | s4671;-  const SWord8 s4673 = 127 & s4671;-  const SWord8 s4674 = s4661 ? s4672 : s4673;-  const SBool  s4675 = (SBool) ((s1161 >> 0) & 1);-  const SBool  s4676 = false != s4675;-  const SWord8 s4677 = s4676 ? s4672 : s4673;-  const SWord8 s4678 = s1097 ? s4674 : s4677;-  const SBool  s4679 = (SBool) ((s1177 >> 0) & 1);-  const SBool  s4680 = false != s4679;-  const SBool  s4681 = (SBool) ((s1170 >> 0) & 1);-  const SBool  s4682 = false != s4681;-  const SWord8 s4683 = s4682 ? s4668 : s4669;-  const SWord8 s4684 = (s4683 >> 1) | (s4683 << 7);-  const SWord8 s4685 = 128 | s4684;-  const SWord8 s4686 = 127 & s4684;-  const SWord8 s4687 = s4680 ? s4685 : s4686;-  const SBool  s4688 = (SBool) ((s1182 >> 0) & 1);-  const SBool  s4689 = false != s4688;-  const SWord8 s4690 = s4689 ? s4685 : s4686;-  const SWord8 s4691 = s1097 ? s4687 : s4690;-  const SWord8 s4692 = s1078 ? s4678 : s4691;-  const SWord8 s4693 = s1059 ? s4659 : s4692;-  const SBool  s4694 = (SBool) ((s1217 >> 0) & 1);-  const SBool  s4695 = false != s4694;-  const SBool  s4696 = (SBool) ((s1213 >> 0) & 1);-  const SBool  s4697 = false != s4696;-  const SBool  s4698 = (SBool) ((s1209 >> 0) & 1);-  const SBool  s4699 = false != s4698;-  const SWord8 s4700 = (s1196 >> 1) | (s1196 << 7);-  const SWord8 s4701 = 128 | s4700;-  const SWord8 s4702 = 127 & s4700;-  const SWord8 s4703 = s4699 ? s4701 : s4702;-  const SWord8 s4704 = (s4703 >> 1) | (s4703 << 7);-  const SWord8 s4705 = 128 | s4704;-  const SWord8 s4706 = 127 & s4704;-  const SWord8 s4707 = s4697 ? s4705 : s4706;-  const SWord8 s4708 = (s4707 >> 1) | (s4707 << 7);-  const SWord8 s4709 = 128 | s4708;-  const SWord8 s4710 = 127 & s4708;-  const SWord8 s4711 = s4695 ? s4709 : s4710;-  const SBool  s4712 = (SBool) ((s1222 >> 0) & 1);-  const SBool  s4713 = false != s4712;-  const SWord8 s4714 = s4713 ? s4709 : s4710;-  const SWord8 s4715 = s1202 ? s4711 : s4714;-  const SBool  s4716 = (SBool) ((s1238 >> 0) & 1);-  const SBool  s4717 = false != s4716;-  const SBool  s4718 = (SBool) ((s1231 >> 0) & 1);-  const SBool  s4719 = false != s4718;-  const SWord8 s4720 = s4719 ? s4705 : s4706;-  const SWord8 s4721 = (s4720 >> 1) | (s4720 << 7);-  const SWord8 s4722 = 128 | s4721;-  const SWord8 s4723 = 127 & s4721;-  const SWord8 s4724 = s4717 ? s4722 : s4723;-  const SBool  s4725 = (SBool) ((s1243 >> 0) & 1);-  const SBool  s4726 = false != s4725;-  const SWord8 s4727 = s4726 ? s4722 : s4723;-  const SWord8 s4728 = s1202 ? s4724 : s4727;-  const SWord8 s4729 = s1078 ? s4715 : s4728;-  const SBool  s4730 = (SBool) ((s1264 >> 0) & 1);-  const SBool  s4731 = false != s4730;-  const SBool  s4732 = (SBool) ((s1260 >> 0) & 1);-  const SBool  s4733 = false != s4732;-  const SBool  s4734 = (SBool) ((s1253 >> 0) & 1);-  const SBool  s4735 = false != s4734;-  const SWord8 s4736 = s4735 ? s4701 : s4702;-  const SWord8 s4737 = (s4736 >> 1) | (s4736 << 7);-  const SWord8 s4738 = 128 | s4737;-  const SWord8 s4739 = 127 & s4737;-  const SWord8 s4740 = s4733 ? s4738 : s4739;-  const SWord8 s4741 = (s4740 >> 1) | (s4740 << 7);-  const SWord8 s4742 = 128 | s4741;-  const SWord8 s4743 = 127 & s4741;-  const SWord8 s4744 = s4731 ? s4742 : s4743;-  const SBool  s4745 = (SBool) ((s1269 >> 0) & 1);-  const SBool  s4746 = false != s4745;-  const SWord8 s4747 = s4746 ? s4742 : s4743;-  const SWord8 s4748 = s1202 ? s4744 : s4747;-  const SBool  s4749 = (SBool) ((s1285 >> 0) & 1);-  const SBool  s4750 = false != s4749;-  const SBool  s4751 = (SBool) ((s1278 >> 0) & 1);-  const SBool  s4752 = false != s4751;-  const SWord8 s4753 = s4752 ? s4738 : s4739;-  const SWord8 s4754 = (s4753 >> 1) | (s4753 << 7);-  const SWord8 s4755 = 128 | s4754;-  const SWord8 s4756 = 127 & s4754;-  const SWord8 s4757 = s4750 ? s4755 : s4756;-  const SBool  s4758 = (SBool) ((s1290 >> 0) & 1);-  const SBool  s4759 = false != s4758;-  const SWord8 s4760 = s4759 ? s4755 : s4756;-  const SWord8 s4761 = s1202 ? s4757 : s4760;-  const SWord8 s4762 = s1078 ? s4748 : s4761;-  const SWord8 s4763 = s1059 ? s4729 : s4762;-  const SWord8 s4764 = s1037 ? s4693 : s4763;-  const SBool  s4765 = (SBool) ((s1345 >> 0) & 1);-  const SBool  s4766 = false != s4765;-  const SBool  s4767 = (SBool) ((s1341 >> 0) & 1);-  const SBool  s4768 = false != s4767;-  const SBool  s4769 = (SBool) ((s1337 >> 0) & 1);-  const SBool  s4770 = false != s4769;-  const SWord8 s4771 = (s1324 >> 1) | (s1324 << 7);-  const SWord8 s4772 = 128 | s4771;-  const SWord8 s4773 = 127 & s4771;-  const SWord8 s4774 = s4770 ? s4772 : s4773;-  const SWord8 s4775 = (s4774 >> 1) | (s4774 << 7);-  const SWord8 s4776 = 128 | s4775;-  const SWord8 s4777 = 127 & s4775;-  const SWord8 s4778 = s4768 ? s4776 : s4777;-  const SWord8 s4779 = (s4778 >> 1) | (s4778 << 7);-  const SWord8 s4780 = 128 | s4779;-  const SWord8 s4781 = 127 & s4779;-  const SWord8 s4782 = s4766 ? s4780 : s4781;-  const SBool  s4783 = (SBool) ((s1350 >> 0) & 1);-  const SBool  s4784 = false != s4783;-  const SWord8 s4785 = s4784 ? s4780 : s4781;-  const SWord8 s4786 = s1333 ? s4782 : s4785;-  const SBool  s4787 = (SBool) ((s1366 >> 0) & 1);-  const SBool  s4788 = false != s4787;-  const SBool  s4789 = (SBool) ((s1359 >> 0) & 1);-  const SBool  s4790 = false != s4789;-  const SWord8 s4791 = s4790 ? s4776 : s4777;-  const SWord8 s4792 = (s4791 >> 1) | (s4791 << 7);-  const SWord8 s4793 = 128 | s4792;-  const SWord8 s4794 = 127 & s4792;-  const SWord8 s4795 = s4788 ? s4793 : s4794;-  const SBool  s4796 = (SBool) ((s1371 >> 0) & 1);-  const SBool  s4797 = false != s4796;-  const SWord8 s4798 = s4797 ? s4793 : s4794;-  const SWord8 s4799 = s1333 ? s4795 : s4798;-  const SWord8 s4800 = s1311 ? s4786 : s4799;-  const SBool  s4801 = (SBool) ((s1392 >> 0) & 1);-  const SBool  s4802 = false != s4801;-  const SBool  s4803 = (SBool) ((s1388 >> 0) & 1);-  const SBool  s4804 = false != s4803;-  const SBool  s4805 = (SBool) ((s1381 >> 0) & 1);-  const SBool  s4806 = false != s4805;-  const SWord8 s4807 = s4806 ? s4772 : s4773;-  const SWord8 s4808 = (s4807 >> 1) | (s4807 << 7);-  const SWord8 s4809 = 128 | s4808;-  const SWord8 s4810 = 127 & s4808;-  const SWord8 s4811 = s4804 ? s4809 : s4810;-  const SWord8 s4812 = (s4811 >> 1) | (s4811 << 7);-  const SWord8 s4813 = 128 | s4812;-  const SWord8 s4814 = 127 & s4812;-  const SWord8 s4815 = s4802 ? s4813 : s4814;-  const SBool  s4816 = (SBool) ((s1397 >> 0) & 1);-  const SBool  s4817 = false != s4816;-  const SWord8 s4818 = s4817 ? s4813 : s4814;-  const SWord8 s4819 = s1333 ? s4815 : s4818;-  const SBool  s4820 = (SBool) ((s1413 >> 0) & 1);-  const SBool  s4821 = false != s4820;-  const SBool  s4822 = (SBool) ((s1406 >> 0) & 1);-  const SBool  s4823 = false != s4822;-  const SWord8 s4824 = s4823 ? s4809 : s4810;-  const SWord8 s4825 = (s4824 >> 1) | (s4824 << 7);-  const SWord8 s4826 = 128 | s4825;-  const SWord8 s4827 = 127 & s4825;-  const SWord8 s4828 = s4821 ? s4826 : s4827;-  const SBool  s4829 = (SBool) ((s1418 >> 0) & 1);-  const SBool  s4830 = false != s4829;-  const SWord8 s4831 = s4830 ? s4826 : s4827;-  const SWord8 s4832 = s1333 ? s4828 : s4831;-  const SWord8 s4833 = s1311 ? s4819 : s4832;-  const SWord8 s4834 = s1059 ? s4800 : s4833;-  const SBool  s4835 = (SBool) ((s1453 >> 0) & 1);-  const SBool  s4836 = false != s4835;-  const SBool  s4837 = (SBool) ((s1449 >> 0) & 1);-  const SBool  s4838 = false != s4837;-  const SBool  s4839 = (SBool) ((s1445 >> 0) & 1);-  const SBool  s4840 = false != s4839;-  const SWord8 s4841 = (s1432 >> 1) | (s1432 << 7);-  const SWord8 s4842 = 128 | s4841;-  const SWord8 s4843 = 127 & s4841;-  const SWord8 s4844 = s4840 ? s4842 : s4843;-  const SWord8 s4845 = (s4844 >> 1) | (s4844 << 7);-  const SWord8 s4846 = 128 | s4845;-  const SWord8 s4847 = 127 & s4845;-  const SWord8 s4848 = s4838 ? s4846 : s4847;-  const SWord8 s4849 = (s4848 >> 1) | (s4848 << 7);-  const SWord8 s4850 = 128 | s4849;-  const SWord8 s4851 = 127 & s4849;-  const SWord8 s4852 = s4836 ? s4850 : s4851;-  const SBool  s4853 = (SBool) ((s1458 >> 0) & 1);-  const SBool  s4854 = false != s4853;-  const SWord8 s4855 = s4854 ? s4850 : s4851;-  const SWord8 s4856 = s1438 ? s4852 : s4855;-  const SBool  s4857 = (SBool) ((s1474 >> 0) & 1);-  const SBool  s4858 = false != s4857;-  const SBool  s4859 = (SBool) ((s1467 >> 0) & 1);-  const SBool  s4860 = false != s4859;-  const SWord8 s4861 = s4860 ? s4846 : s4847;-  const SWord8 s4862 = (s4861 >> 1) | (s4861 << 7);-  const SWord8 s4863 = 128 | s4862;-  const SWord8 s4864 = 127 & s4862;-  const SWord8 s4865 = s4858 ? s4863 : s4864;-  const SBool  s4866 = (SBool) ((s1479 >> 0) & 1);-  const SBool  s4867 = false != s4866;-  const SWord8 s4868 = s4867 ? s4863 : s4864;-  const SWord8 s4869 = s1438 ? s4865 : s4868;-  const SWord8 s4870 = s1311 ? s4856 : s4869;-  const SBool  s4871 = (SBool) ((s1500 >> 0) & 1);-  const SBool  s4872 = false != s4871;-  const SBool  s4873 = (SBool) ((s1496 >> 0) & 1);-  const SBool  s4874 = false != s4873;-  const SBool  s4875 = (SBool) ((s1489 >> 0) & 1);-  const SBool  s4876 = false != s4875;-  const SWord8 s4877 = s4876 ? s4842 : s4843;-  const SWord8 s4878 = (s4877 >> 1) | (s4877 << 7);-  const SWord8 s4879 = 128 | s4878;-  const SWord8 s4880 = 127 & s4878;-  const SWord8 s4881 = s4874 ? s4879 : s4880;-  const SWord8 s4882 = (s4881 >> 1) | (s4881 << 7);-  const SWord8 s4883 = 128 | s4882;-  const SWord8 s4884 = 127 & s4882;-  const SWord8 s4885 = s4872 ? s4883 : s4884;-  const SBool  s4886 = (SBool) ((s1505 >> 0) & 1);-  const SBool  s4887 = false != s4886;-  const SWord8 s4888 = s4887 ? s4883 : s4884;-  const SWord8 s4889 = s1438 ? s4885 : s4888;-  const SBool  s4890 = (SBool) ((s1521 >> 0) & 1);-  const SBool  s4891 = false != s4890;-  const SBool  s4892 = (SBool) ((s1514 >> 0) & 1);-  const SBool  s4893 = false != s4892;-  const SWord8 s4894 = s4893 ? s4879 : s4880;-  const SWord8 s4895 = (s4894 >> 1) | (s4894 << 7);-  const SWord8 s4896 = 128 | s4895;-  const SWord8 s4897 = 127 & s4895;-  const SWord8 s4898 = s4891 ? s4896 : s4897;-  const SBool  s4899 = (SBool) ((s1526 >> 0) & 1);-  const SBool  s4900 = false != s4899;-  const SWord8 s4901 = s4900 ? s4896 : s4897;-  const SWord8 s4902 = s1438 ? s4898 : s4901;-  const SWord8 s4903 = s1311 ? s4889 : s4902;-  const SWord8 s4904 = s1059 ? s4870 : s4903;-  const SWord8 s4905 = s1037 ? s4834 : s4904;-  const SWord8 s4906 = s21 ? s4764 : s4905;-  const SBool  s4907 = (SBool) ((s1601 >> 0) & 1);-  const SBool  s4908 = false != s4907;-  const SBool  s4909 = (SBool) ((s1597 >> 0) & 1);-  const SBool  s4910 = false != s4909;-  const SBool  s4911 = (SBool) ((s1593 >> 0) & 1);-  const SBool  s4912 = false != s4911;-  const SWord8 s4913 = (s1580 >> 1) | (s1580 << 7);-  const SWord8 s4914 = 128 | s4913;-  const SWord8 s4915 = 127 & s4913;-  const SWord8 s4916 = s4912 ? s4914 : s4915;-  const SWord8 s4917 = (s4916 >> 1) | (s4916 << 7);-  const SWord8 s4918 = 128 | s4917;-  const SWord8 s4919 = 127 & s4917;-  const SWord8 s4920 = s4910 ? s4918 : s4919;-  const SWord8 s4921 = (s4920 >> 1) | (s4920 << 7);-  const SWord8 s4922 = 128 | s4921;-  const SWord8 s4923 = 127 & s4921;-  const SWord8 s4924 = s4908 ? s4922 : s4923;-  const SBool  s4925 = (SBool) ((s1606 >> 0) & 1);-  const SBool  s4926 = false != s4925;-  const SWord8 s4927 = s4926 ? s4922 : s4923;-  const SWord8 s4928 = s1589 ? s4924 : s4927;-  const SBool  s4929 = (SBool) ((s1622 >> 0) & 1);-  const SBool  s4930 = false != s4929;-  const SBool  s4931 = (SBool) ((s1615 >> 0) & 1);-  const SBool  s4932 = false != s4931;-  const SWord8 s4933 = s4932 ? s4918 : s4919;-  const SWord8 s4934 = (s4933 >> 1) | (s4933 << 7);-  const SWord8 s4935 = 128 | s4934;-  const SWord8 s4936 = 127 & s4934;-  const SWord8 s4937 = s4930 ? s4935 : s4936;-  const SBool  s4938 = (SBool) ((s1627 >> 0) & 1);-  const SBool  s4939 = false != s4938;-  const SWord8 s4940 = s4939 ? s4935 : s4936;-  const SWord8 s4941 = s1589 ? s4937 : s4940;-  const SWord8 s4942 = s1570 ? s4928 : s4941;-  const SBool  s4943 = (SBool) ((s1648 >> 0) & 1);-  const SBool  s4944 = false != s4943;-  const SBool  s4945 = (SBool) ((s1644 >> 0) & 1);-  const SBool  s4946 = false != s4945;-  const SBool  s4947 = (SBool) ((s1637 >> 0) & 1);-  const SBool  s4948 = false != s4947;-  const SWord8 s4949 = s4948 ? s4914 : s4915;-  const SWord8 s4950 = (s4949 >> 1) | (s4949 << 7);-  const SWord8 s4951 = 128 | s4950;-  const SWord8 s4952 = 127 & s4950;-  const SWord8 s4953 = s4946 ? s4951 : s4952;-  const SWord8 s4954 = (s4953 >> 1) | (s4953 << 7);-  const SWord8 s4955 = 128 | s4954;-  const SWord8 s4956 = 127 & s4954;-  const SWord8 s4957 = s4944 ? s4955 : s4956;-  const SBool  s4958 = (SBool) ((s1653 >> 0) & 1);-  const SBool  s4959 = false != s4958;-  const SWord8 s4960 = s4959 ? s4955 : s4956;-  const SWord8 s4961 = s1589 ? s4957 : s4960;-  const SBool  s4962 = (SBool) ((s1669 >> 0) & 1);-  const SBool  s4963 = false != s4962;-  const SBool  s4964 = (SBool) ((s1662 >> 0) & 1);-  const SBool  s4965 = false != s4964;-  const SWord8 s4966 = s4965 ? s4951 : s4952;-  const SWord8 s4967 = (s4966 >> 1) | (s4966 << 7);-  const SWord8 s4968 = 128 | s4967;-  const SWord8 s4969 = 127 & s4967;-  const SWord8 s4970 = s4963 ? s4968 : s4969;-  const SBool  s4971 = (SBool) ((s1674 >> 0) & 1);-  const SBool  s4972 = false != s4971;-  const SWord8 s4973 = s4972 ? s4968 : s4969;-  const SWord8 s4974 = s1589 ? s4970 : s4973;-  const SWord8 s4975 = s1570 ? s4961 : s4974;-  const SWord8 s4976 = s1548 ? s4942 : s4975;-  const SBool  s4977 = (SBool) ((s1709 >> 0) & 1);-  const SBool  s4978 = false != s4977;-  const SBool  s4979 = (SBool) ((s1705 >> 0) & 1);-  const SBool  s4980 = false != s4979;-  const SBool  s4981 = (SBool) ((s1701 >> 0) & 1);-  const SBool  s4982 = false != s4981;-  const SWord8 s4983 = (s1688 >> 1) | (s1688 << 7);-  const SWord8 s4984 = 128 | s4983;-  const SWord8 s4985 = 127 & s4983;-  const SWord8 s4986 = s4982 ? s4984 : s4985;-  const SWord8 s4987 = (s4986 >> 1) | (s4986 << 7);-  const SWord8 s4988 = 128 | s4987;-  const SWord8 s4989 = 127 & s4987;-  const SWord8 s4990 = s4980 ? s4988 : s4989;-  const SWord8 s4991 = (s4990 >> 1) | (s4990 << 7);-  const SWord8 s4992 = 128 | s4991;-  const SWord8 s4993 = 127 & s4991;-  const SWord8 s4994 = s4978 ? s4992 : s4993;-  const SBool  s4995 = (SBool) ((s1714 >> 0) & 1);-  const SBool  s4996 = false != s4995;-  const SWord8 s4997 = s4996 ? s4992 : s4993;-  const SWord8 s4998 = s1694 ? s4994 : s4997;-  const SBool  s4999 = (SBool) ((s1730 >> 0) & 1);-  const SBool  s5000 = false != s4999;-  const SBool  s5001 = (SBool) ((s1723 >> 0) & 1);-  const SBool  s5002 = false != s5001;-  const SWord8 s5003 = s5002 ? s4988 : s4989;-  const SWord8 s5004 = (s5003 >> 1) | (s5003 << 7);-  const SWord8 s5005 = 128 | s5004;-  const SWord8 s5006 = 127 & s5004;-  const SWord8 s5007 = s5000 ? s5005 : s5006;-  const SBool  s5008 = (SBool) ((s1735 >> 0) & 1);-  const SBool  s5009 = false != s5008;-  const SWord8 s5010 = s5009 ? s5005 : s5006;-  const SWord8 s5011 = s1694 ? s5007 : s5010;-  const SWord8 s5012 = s1570 ? s4998 : s5011;-  const SBool  s5013 = (SBool) ((s1756 >> 0) & 1);-  const SBool  s5014 = false != s5013;-  const SBool  s5015 = (SBool) ((s1752 >> 0) & 1);-  const SBool  s5016 = false != s5015;-  const SBool  s5017 = (SBool) ((s1745 >> 0) & 1);-  const SBool  s5018 = false != s5017;-  const SWord8 s5019 = s5018 ? s4984 : s4985;-  const SWord8 s5020 = (s5019 >> 1) | (s5019 << 7);-  const SWord8 s5021 = 128 | s5020;-  const SWord8 s5022 = 127 & s5020;-  const SWord8 s5023 = s5016 ? s5021 : s5022;-  const SWord8 s5024 = (s5023 >> 1) | (s5023 << 7);-  const SWord8 s5025 = 128 | s5024;-  const SWord8 s5026 = 127 & s5024;-  const SWord8 s5027 = s5014 ? s5025 : s5026;-  const SBool  s5028 = (SBool) ((s1761 >> 0) & 1);-  const SBool  s5029 = false != s5028;-  const SWord8 s5030 = s5029 ? s5025 : s5026;-  const SWord8 s5031 = s1694 ? s5027 : s5030;-  const SBool  s5032 = (SBool) ((s1777 >> 0) & 1);-  const SBool  s5033 = false != s5032;-  const SBool  s5034 = (SBool) ((s1770 >> 0) & 1);-  const SBool  s5035 = false != s5034;-  const SWord8 s5036 = s5035 ? s5021 : s5022;-  const SWord8 s5037 = (s5036 >> 1) | (s5036 << 7);-  const SWord8 s5038 = 128 | s5037;-  const SWord8 s5039 = 127 & s5037;-  const SWord8 s5040 = s5033 ? s5038 : s5039;-  const SBool  s5041 = (SBool) ((s1782 >> 0) & 1);-  const SBool  s5042 = false != s5041;-  const SWord8 s5043 = s5042 ? s5038 : s5039;-  const SWord8 s5044 = s1694 ? s5040 : s5043;-  const SWord8 s5045 = s1570 ? s5031 : s5044;-  const SWord8 s5046 = s1548 ? s5012 : s5045;-  const SWord8 s5047 = s1037 ? s4976 : s5046;-  const SBool  s5048 = (SBool) ((s1837 >> 0) & 1);-  const SBool  s5049 = false != s5048;-  const SBool  s5050 = (SBool) ((s1833 >> 0) & 1);-  const SBool  s5051 = false != s5050;-  const SBool  s5052 = (SBool) ((s1829 >> 0) & 1);-  const SBool  s5053 = false != s5052;-  const SWord8 s5054 = (s1816 >> 1) | (s1816 << 7);-  const SWord8 s5055 = 128 | s5054;-  const SWord8 s5056 = 127 & s5054;-  const SWord8 s5057 = s5053 ? s5055 : s5056;-  const SWord8 s5058 = (s5057 >> 1) | (s5057 << 7);-  const SWord8 s5059 = 128 | s5058;-  const SWord8 s5060 = 127 & s5058;-  const SWord8 s5061 = s5051 ? s5059 : s5060;-  const SWord8 s5062 = (s5061 >> 1) | (s5061 << 7);-  const SWord8 s5063 = 128 | s5062;-  const SWord8 s5064 = 127 & s5062;-  const SWord8 s5065 = s5049 ? s5063 : s5064;-  const SBool  s5066 = (SBool) ((s1842 >> 0) & 1);-  const SBool  s5067 = false != s5066;-  const SWord8 s5068 = s5067 ? s5063 : s5064;-  const SWord8 s5069 = s1825 ? s5065 : s5068;-  const SBool  s5070 = (SBool) ((s1858 >> 0) & 1);-  const SBool  s5071 = false != s5070;-  const SBool  s5072 = (SBool) ((s1851 >> 0) & 1);-  const SBool  s5073 = false != s5072;-  const SWord8 s5074 = s5073 ? s5059 : s5060;-  const SWord8 s5075 = (s5074 >> 1) | (s5074 << 7);-  const SWord8 s5076 = 128 | s5075;-  const SWord8 s5077 = 127 & s5075;-  const SWord8 s5078 = s5071 ? s5076 : s5077;-  const SBool  s5079 = (SBool) ((s1863 >> 0) & 1);-  const SBool  s5080 = false != s5079;-  const SWord8 s5081 = s5080 ? s5076 : s5077;-  const SWord8 s5082 = s1825 ? s5078 : s5081;-  const SWord8 s5083 = s1803 ? s5069 : s5082;-  const SBool  s5084 = (SBool) ((s1884 >> 0) & 1);-  const SBool  s5085 = false != s5084;-  const SBool  s5086 = (SBool) ((s1880 >> 0) & 1);-  const SBool  s5087 = false != s5086;-  const SBool  s5088 = (SBool) ((s1873 >> 0) & 1);-  const SBool  s5089 = false != s5088;-  const SWord8 s5090 = s5089 ? s5055 : s5056;-  const SWord8 s5091 = (s5090 >> 1) | (s5090 << 7);-  const SWord8 s5092 = 128 | s5091;-  const SWord8 s5093 = 127 & s5091;-  const SWord8 s5094 = s5087 ? s5092 : s5093;-  const SWord8 s5095 = (s5094 >> 1) | (s5094 << 7);-  const SWord8 s5096 = 128 | s5095;-  const SWord8 s5097 = 127 & s5095;-  const SWord8 s5098 = s5085 ? s5096 : s5097;-  const SBool  s5099 = (SBool) ((s1889 >> 0) & 1);-  const SBool  s5100 = false != s5099;-  const SWord8 s5101 = s5100 ? s5096 : s5097;-  const SWord8 s5102 = s1825 ? s5098 : s5101;-  const SBool  s5103 = (SBool) ((s1905 >> 0) & 1);-  const SBool  s5104 = false != s5103;-  const SBool  s5105 = (SBool) ((s1898 >> 0) & 1);-  const SBool  s5106 = false != s5105;-  const SWord8 s5107 = s5106 ? s5092 : s5093;-  const SWord8 s5108 = (s5107 >> 1) | (s5107 << 7);-  const SWord8 s5109 = 128 | s5108;-  const SWord8 s5110 = 127 & s5108;-  const SWord8 s5111 = s5104 ? s5109 : s5110;-  const SBool  s5112 = (SBool) ((s1910 >> 0) & 1);-  const SBool  s5113 = false != s5112;-  const SWord8 s5114 = s5113 ? s5109 : s5110;-  const SWord8 s5115 = s1825 ? s5111 : s5114;-  const SWord8 s5116 = s1803 ? s5102 : s5115;-  const SWord8 s5117 = s1548 ? s5083 : s5116;-  const SBool  s5118 = (SBool) ((s1945 >> 0) & 1);-  const SBool  s5119 = false != s5118;-  const SBool  s5120 = (SBool) ((s1941 >> 0) & 1);-  const SBool  s5121 = false != s5120;-  const SBool  s5122 = (SBool) ((s1937 >> 0) & 1);-  const SBool  s5123 = false != s5122;-  const SWord8 s5124 = (s1924 >> 1) | (s1924 << 7);-  const SWord8 s5125 = 128 | s5124;-  const SWord8 s5126 = 127 & s5124;-  const SWord8 s5127 = s5123 ? s5125 : s5126;-  const SWord8 s5128 = (s5127 >> 1) | (s5127 << 7);-  const SWord8 s5129 = 128 | s5128;-  const SWord8 s5130 = 127 & s5128;-  const SWord8 s5131 = s5121 ? s5129 : s5130;-  const SWord8 s5132 = (s5131 >> 1) | (s5131 << 7);-  const SWord8 s5133 = 128 | s5132;-  const SWord8 s5134 = 127 & s5132;-  const SWord8 s5135 = s5119 ? s5133 : s5134;-  const SBool  s5136 = (SBool) ((s1950 >> 0) & 1);-  const SBool  s5137 = false != s5136;-  const SWord8 s5138 = s5137 ? s5133 : s5134;-  const SWord8 s5139 = s1930 ? s5135 : s5138;-  const SBool  s5140 = (SBool) ((s1966 >> 0) & 1);-  const SBool  s5141 = false != s5140;-  const SBool  s5142 = (SBool) ((s1959 >> 0) & 1);-  const SBool  s5143 = false != s5142;-  const SWord8 s5144 = s5143 ? s5129 : s5130;-  const SWord8 s5145 = (s5144 >> 1) | (s5144 << 7);-  const SWord8 s5146 = 128 | s5145;-  const SWord8 s5147 = 127 & s5145;-  const SWord8 s5148 = s5141 ? s5146 : s5147;-  const SBool  s5149 = (SBool) ((s1971 >> 0) & 1);-  const SBool  s5150 = false != s5149;-  const SWord8 s5151 = s5150 ? s5146 : s5147;-  const SWord8 s5152 = s1930 ? s5148 : s5151;-  const SWord8 s5153 = s1803 ? s5139 : s5152;-  const SBool  s5154 = (SBool) ((s1992 >> 0) & 1);-  const SBool  s5155 = false != s5154;-  const SBool  s5156 = (SBool) ((s1988 >> 0) & 1);-  const SBool  s5157 = false != s5156;-  const SBool  s5158 = (SBool) ((s1981 >> 0) & 1);-  const SBool  s5159 = false != s5158;-  const SWord8 s5160 = s5159 ? s5125 : s5126;-  const SWord8 s5161 = (s5160 >> 1) | (s5160 << 7);-  const SWord8 s5162 = 128 | s5161;-  const SWord8 s5163 = 127 & s5161;-  const SWord8 s5164 = s5157 ? s5162 : s5163;-  const SWord8 s5165 = (s5164 >> 1) | (s5164 << 7);-  const SWord8 s5166 = 128 | s5165;-  const SWord8 s5167 = 127 & s5165;-  const SWord8 s5168 = s5155 ? s5166 : s5167;-  const SBool  s5169 = (SBool) ((s1997 >> 0) & 1);-  const SBool  s5170 = false != s5169;-  const SWord8 s5171 = s5170 ? s5166 : s5167;-  const SWord8 s5172 = s1930 ? s5168 : s5171;-  const SBool  s5173 = (SBool) ((s2013 >> 0) & 1);-  const SBool  s5174 = false != s5173;-  const SBool  s5175 = (SBool) ((s2006 >> 0) & 1);-  const SBool  s5176 = false != s5175;-  const SWord8 s5177 = s5176 ? s5162 : s5163;-  const SWord8 s5178 = (s5177 >> 1) | (s5177 << 7);-  const SWord8 s5179 = 128 | s5178;-  const SWord8 s5180 = 127 & s5178;-  const SWord8 s5181 = s5174 ? s5179 : s5180;-  const SBool  s5182 = (SBool) ((s2018 >> 0) & 1);-  const SBool  s5183 = false != s5182;-  const SWord8 s5184 = s5183 ? s5179 : s5180;-  const SWord8 s5185 = s1930 ? s5181 : s5184;-  const SWord8 s5186 = s1803 ? s5172 : s5185;-  const SWord8 s5187 = s1548 ? s5153 : s5186;-  const SWord8 s5188 = s1037 ? s5117 : s5187;-  const SWord8 s5189 = s21 ? s5047 : s5188;-  const SWord8 s5190 = s16 ? s4906 : s5189;-  const SWord8 s5191 = s11 ? s4623 : s5190;-  const SBool  s5192 = (SBool) ((s2128 >> 0) & 1);-  const SBool  s5193 = false != s5192;-  const SBool  s5194 = (SBool) ((s2124 >> 0) & 1);-  const SBool  s5195 = false != s5194;-  const SBool  s5196 = (SBool) ((s2120 >> 0) & 1);-  const SBool  s5197 = false != s5196;-  const SWord8 s5198 = (s2107 >> 1) | (s2107 << 7);-  const SWord8 s5199 = 128 | s5198;-  const SWord8 s5200 = 127 & s5198;-  const SWord8 s5201 = s5197 ? s5199 : s5200;-  const SWord8 s5202 = (s5201 >> 1) | (s5201 << 7);-  const SWord8 s5203 = 128 | s5202;-  const SWord8 s5204 = 127 & s5202;-  const SWord8 s5205 = s5195 ? s5203 : s5204;-  const SWord8 s5206 = (s5205 >> 1) | (s5205 << 7);-  const SWord8 s5207 = 128 | s5206;-  const SWord8 s5208 = 127 & s5206;-  const SWord8 s5209 = s5193 ? s5207 : s5208;-  const SBool  s5210 = (SBool) ((s2133 >> 0) & 1);-  const SBool  s5211 = false != s5210;-  const SWord8 s5212 = s5211 ? s5207 : s5208;-  const SWord8 s5213 = s2116 ? s5209 : s5212;-  const SBool  s5214 = (SBool) ((s2149 >> 0) & 1);-  const SBool  s5215 = false != s5214;-  const SBool  s5216 = (SBool) ((s2142 >> 0) & 1);-  const SBool  s5217 = false != s5216;-  const SWord8 s5218 = s5217 ? s5203 : s5204;-  const SWord8 s5219 = (s5218 >> 1) | (s5218 << 7);-  const SWord8 s5220 = 128 | s5219;-  const SWord8 s5221 = 127 & s5219;-  const SWord8 s5222 = s5215 ? s5220 : s5221;-  const SBool  s5223 = (SBool) ((s2154 >> 0) & 1);-  const SBool  s5224 = false != s5223;-  const SWord8 s5225 = s5224 ? s5220 : s5221;-  const SWord8 s5226 = s2116 ? s5222 : s5225;-  const SWord8 s5227 = s2097 ? s5213 : s5226;-  const SBool  s5228 = (SBool) ((s2175 >> 0) & 1);-  const SBool  s5229 = false != s5228;-  const SBool  s5230 = (SBool) ((s2171 >> 0) & 1);-  const SBool  s5231 = false != s5230;-  const SBool  s5232 = (SBool) ((s2164 >> 0) & 1);-  const SBool  s5233 = false != s5232;-  const SWord8 s5234 = s5233 ? s5199 : s5200;-  const SWord8 s5235 = (s5234 >> 1) | (s5234 << 7);-  const SWord8 s5236 = 128 | s5235;-  const SWord8 s5237 = 127 & s5235;-  const SWord8 s5238 = s5231 ? s5236 : s5237;-  const SWord8 s5239 = (s5238 >> 1) | (s5238 << 7);-  const SWord8 s5240 = 128 | s5239;-  const SWord8 s5241 = 127 & s5239;-  const SWord8 s5242 = s5229 ? s5240 : s5241;-  const SBool  s5243 = (SBool) ((s2180 >> 0) & 1);-  const SBool  s5244 = false != s5243;-  const SWord8 s5245 = s5244 ? s5240 : s5241;-  const SWord8 s5246 = s2116 ? s5242 : s5245;-  const SBool  s5247 = (SBool) ((s2196 >> 0) & 1);-  const SBool  s5248 = false != s5247;-  const SBool  s5249 = (SBool) ((s2189 >> 0) & 1);-  const SBool  s5250 = false != s5249;-  const SWord8 s5251 = s5250 ? s5236 : s5237;-  const SWord8 s5252 = (s5251 >> 1) | (s5251 << 7);-  const SWord8 s5253 = 128 | s5252;-  const SWord8 s5254 = 127 & s5252;-  const SWord8 s5255 = s5248 ? s5253 : s5254;-  const SBool  s5256 = (SBool) ((s2201 >> 0) & 1);-  const SBool  s5257 = false != s5256;-  const SWord8 s5258 = s5257 ? s5253 : s5254;-  const SWord8 s5259 = s2116 ? s5255 : s5258;-  const SWord8 s5260 = s2097 ? s5246 : s5259;-  const SWord8 s5261 = s2078 ? s5227 : s5260;-  const SBool  s5262 = (SBool) ((s2236 >> 0) & 1);-  const SBool  s5263 = false != s5262;-  const SBool  s5264 = (SBool) ((s2232 >> 0) & 1);-  const SBool  s5265 = false != s5264;-  const SBool  s5266 = (SBool) ((s2228 >> 0) & 1);-  const SBool  s5267 = false != s5266;-  const SWord8 s5268 = (s2215 >> 1) | (s2215 << 7);-  const SWord8 s5269 = 128 | s5268;-  const SWord8 s5270 = 127 & s5268;-  const SWord8 s5271 = s5267 ? s5269 : s5270;-  const SWord8 s5272 = (s5271 >> 1) | (s5271 << 7);-  const SWord8 s5273 = 128 | s5272;-  const SWord8 s5274 = 127 & s5272;-  const SWord8 s5275 = s5265 ? s5273 : s5274;-  const SWord8 s5276 = (s5275 >> 1) | (s5275 << 7);-  const SWord8 s5277 = 128 | s5276;-  const SWord8 s5278 = 127 & s5276;-  const SWord8 s5279 = s5263 ? s5277 : s5278;-  const SBool  s5280 = (SBool) ((s2241 >> 0) & 1);-  const SBool  s5281 = false != s5280;-  const SWord8 s5282 = s5281 ? s5277 : s5278;-  const SWord8 s5283 = s2221 ? s5279 : s5282;-  const SBool  s5284 = (SBool) ((s2257 >> 0) & 1);-  const SBool  s5285 = false != s5284;-  const SBool  s5286 = (SBool) ((s2250 >> 0) & 1);-  const SBool  s5287 = false != s5286;-  const SWord8 s5288 = s5287 ? s5273 : s5274;-  const SWord8 s5289 = (s5288 >> 1) | (s5288 << 7);-  const SWord8 s5290 = 128 | s5289;-  const SWord8 s5291 = 127 & s5289;-  const SWord8 s5292 = s5285 ? s5290 : s5291;-  const SBool  s5293 = (SBool) ((s2262 >> 0) & 1);-  const SBool  s5294 = false != s5293;-  const SWord8 s5295 = s5294 ? s5290 : s5291;-  const SWord8 s5296 = s2221 ? s5292 : s5295;-  const SWord8 s5297 = s2097 ? s5283 : s5296;-  const SBool  s5298 = (SBool) ((s2283 >> 0) & 1);-  const SBool  s5299 = false != s5298;-  const SBool  s5300 = (SBool) ((s2279 >> 0) & 1);-  const SBool  s5301 = false != s5300;-  const SBool  s5302 = (SBool) ((s2272 >> 0) & 1);-  const SBool  s5303 = false != s5302;-  const SWord8 s5304 = s5303 ? s5269 : s5270;-  const SWord8 s5305 = (s5304 >> 1) | (s5304 << 7);-  const SWord8 s5306 = 128 | s5305;-  const SWord8 s5307 = 127 & s5305;-  const SWord8 s5308 = s5301 ? s5306 : s5307;-  const SWord8 s5309 = (s5308 >> 1) | (s5308 << 7);-  const SWord8 s5310 = 128 | s5309;-  const SWord8 s5311 = 127 & s5309;-  const SWord8 s5312 = s5299 ? s5310 : s5311;-  const SBool  s5313 = (SBool) ((s2288 >> 0) & 1);-  const SBool  s5314 = false != s5313;-  const SWord8 s5315 = s5314 ? s5310 : s5311;-  const SWord8 s5316 = s2221 ? s5312 : s5315;-  const SBool  s5317 = (SBool) ((s2304 >> 0) & 1);-  const SBool  s5318 = false != s5317;-  const SBool  s5319 = (SBool) ((s2297 >> 0) & 1);-  const SBool  s5320 = false != s5319;-  const SWord8 s5321 = s5320 ? s5306 : s5307;-  const SWord8 s5322 = (s5321 >> 1) | (s5321 << 7);-  const SWord8 s5323 = 128 | s5322;-  const SWord8 s5324 = 127 & s5322;-  const SWord8 s5325 = s5318 ? s5323 : s5324;-  const SBool  s5326 = (SBool) ((s2309 >> 0) & 1);-  const SBool  s5327 = false != s5326;-  const SWord8 s5328 = s5327 ? s5323 : s5324;-  const SWord8 s5329 = s2221 ? s5325 : s5328;-  const SWord8 s5330 = s2097 ? s5316 : s5329;-  const SWord8 s5331 = s2078 ? s5297 : s5330;-  const SWord8 s5332 = s2059 ? s5261 : s5331;-  const SBool  s5333 = (SBool) ((s2364 >> 0) & 1);-  const SBool  s5334 = false != s5333;-  const SBool  s5335 = (SBool) ((s2360 >> 0) & 1);-  const SBool  s5336 = false != s5335;-  const SBool  s5337 = (SBool) ((s2356 >> 0) & 1);-  const SBool  s5338 = false != s5337;-  const SWord8 s5339 = (s2343 >> 1) | (s2343 << 7);-  const SWord8 s5340 = 128 | s5339;-  const SWord8 s5341 = 127 & s5339;-  const SWord8 s5342 = s5338 ? s5340 : s5341;-  const SWord8 s5343 = (s5342 >> 1) | (s5342 << 7);-  const SWord8 s5344 = 128 | s5343;-  const SWord8 s5345 = 127 & s5343;-  const SWord8 s5346 = s5336 ? s5344 : s5345;-  const SWord8 s5347 = (s5346 >> 1) | (s5346 << 7);-  const SWord8 s5348 = 128 | s5347;-  const SWord8 s5349 = 127 & s5347;-  const SWord8 s5350 = s5334 ? s5348 : s5349;-  const SBool  s5351 = (SBool) ((s2369 >> 0) & 1);-  const SBool  s5352 = false != s5351;-  const SWord8 s5353 = s5352 ? s5348 : s5349;-  const SWord8 s5354 = s2352 ? s5350 : s5353;-  const SBool  s5355 = (SBool) ((s2385 >> 0) & 1);-  const SBool  s5356 = false != s5355;-  const SBool  s5357 = (SBool) ((s2378 >> 0) & 1);-  const SBool  s5358 = false != s5357;-  const SWord8 s5359 = s5358 ? s5344 : s5345;-  const SWord8 s5360 = (s5359 >> 1) | (s5359 << 7);-  const SWord8 s5361 = 128 | s5360;-  const SWord8 s5362 = 127 & s5360;-  const SWord8 s5363 = s5356 ? s5361 : s5362;-  const SBool  s5364 = (SBool) ((s2390 >> 0) & 1);-  const SBool  s5365 = false != s5364;-  const SWord8 s5366 = s5365 ? s5361 : s5362;-  const SWord8 s5367 = s2352 ? s5363 : s5366;-  const SWord8 s5368 = s2330 ? s5354 : s5367;-  const SBool  s5369 = (SBool) ((s2411 >> 0) & 1);-  const SBool  s5370 = false != s5369;-  const SBool  s5371 = (SBool) ((s2407 >> 0) & 1);-  const SBool  s5372 = false != s5371;-  const SBool  s5373 = (SBool) ((s2400 >> 0) & 1);-  const SBool  s5374 = false != s5373;-  const SWord8 s5375 = s5374 ? s5340 : s5341;-  const SWord8 s5376 = (s5375 >> 1) | (s5375 << 7);-  const SWord8 s5377 = 128 | s5376;-  const SWord8 s5378 = 127 & s5376;-  const SWord8 s5379 = s5372 ? s5377 : s5378;-  const SWord8 s5380 = (s5379 >> 1) | (s5379 << 7);-  const SWord8 s5381 = 128 | s5380;-  const SWord8 s5382 = 127 & s5380;-  const SWord8 s5383 = s5370 ? s5381 : s5382;-  const SBool  s5384 = (SBool) ((s2416 >> 0) & 1);-  const SBool  s5385 = false != s5384;-  const SWord8 s5386 = s5385 ? s5381 : s5382;-  const SWord8 s5387 = s2352 ? s5383 : s5386;-  const SBool  s5388 = (SBool) ((s2432 >> 0) & 1);-  const SBool  s5389 = false != s5388;-  const SBool  s5390 = (SBool) ((s2425 >> 0) & 1);-  const SBool  s5391 = false != s5390;-  const SWord8 s5392 = s5391 ? s5377 : s5378;-  const SWord8 s5393 = (s5392 >> 1) | (s5392 << 7);-  const SWord8 s5394 = 128 | s5393;-  const SWord8 s5395 = 127 & s5393;-  const SWord8 s5396 = s5389 ? s5394 : s5395;-  const SBool  s5397 = (SBool) ((s2437 >> 0) & 1);-  const SBool  s5398 = false != s5397;-  const SWord8 s5399 = s5398 ? s5394 : s5395;-  const SWord8 s5400 = s2352 ? s5396 : s5399;-  const SWord8 s5401 = s2330 ? s5387 : s5400;-  const SWord8 s5402 = s2078 ? s5368 : s5401;-  const SBool  s5403 = (SBool) ((s2472 >> 0) & 1);-  const SBool  s5404 = false != s5403;-  const SBool  s5405 = (SBool) ((s2468 >> 0) & 1);-  const SBool  s5406 = false != s5405;-  const SBool  s5407 = (SBool) ((s2464 >> 0) & 1);-  const SBool  s5408 = false != s5407;-  const SWord8 s5409 = (s2451 >> 1) | (s2451 << 7);-  const SWord8 s5410 = 128 | s5409;-  const SWord8 s5411 = 127 & s5409;-  const SWord8 s5412 = s5408 ? s5410 : s5411;-  const SWord8 s5413 = (s5412 >> 1) | (s5412 << 7);-  const SWord8 s5414 = 128 | s5413;-  const SWord8 s5415 = 127 & s5413;-  const SWord8 s5416 = s5406 ? s5414 : s5415;-  const SWord8 s5417 = (s5416 >> 1) | (s5416 << 7);-  const SWord8 s5418 = 128 | s5417;-  const SWord8 s5419 = 127 & s5417;-  const SWord8 s5420 = s5404 ? s5418 : s5419;-  const SBool  s5421 = (SBool) ((s2477 >> 0) & 1);-  const SBool  s5422 = false != s5421;-  const SWord8 s5423 = s5422 ? s5418 : s5419;-  const SWord8 s5424 = s2457 ? s5420 : s5423;-  const SBool  s5425 = (SBool) ((s2493 >> 0) & 1);-  const SBool  s5426 = false != s5425;-  const SBool  s5427 = (SBool) ((s2486 >> 0) & 1);-  const SBool  s5428 = false != s5427;-  const SWord8 s5429 = s5428 ? s5414 : s5415;-  const SWord8 s5430 = (s5429 >> 1) | (s5429 << 7);-  const SWord8 s5431 = 128 | s5430;-  const SWord8 s5432 = 127 & s5430;-  const SWord8 s5433 = s5426 ? s5431 : s5432;-  const SBool  s5434 = (SBool) ((s2498 >> 0) & 1);-  const SBool  s5435 = false != s5434;-  const SWord8 s5436 = s5435 ? s5431 : s5432;-  const SWord8 s5437 = s2457 ? s5433 : s5436;-  const SWord8 s5438 = s2330 ? s5424 : s5437;-  const SBool  s5439 = (SBool) ((s2519 >> 0) & 1);-  const SBool  s5440 = false != s5439;-  const SBool  s5441 = (SBool) ((s2515 >> 0) & 1);-  const SBool  s5442 = false != s5441;-  const SBool  s5443 = (SBool) ((s2508 >> 0) & 1);-  const SBool  s5444 = false != s5443;-  const SWord8 s5445 = s5444 ? s5410 : s5411;-  const SWord8 s5446 = (s5445 >> 1) | (s5445 << 7);-  const SWord8 s5447 = 128 | s5446;-  const SWord8 s5448 = 127 & s5446;-  const SWord8 s5449 = s5442 ? s5447 : s5448;-  const SWord8 s5450 = (s5449 >> 1) | (s5449 << 7);-  const SWord8 s5451 = 128 | s5450;-  const SWord8 s5452 = 127 & s5450;-  const SWord8 s5453 = s5440 ? s5451 : s5452;-  const SBool  s5454 = (SBool) ((s2524 >> 0) & 1);-  const SBool  s5455 = false != s5454;-  const SWord8 s5456 = s5455 ? s5451 : s5452;-  const SWord8 s5457 = s2457 ? s5453 : s5456;-  const SBool  s5458 = (SBool) ((s2540 >> 0) & 1);-  const SBool  s5459 = false != s5458;-  const SBool  s5460 = (SBool) ((s2533 >> 0) & 1);-  const SBool  s5461 = false != s5460;-  const SWord8 s5462 = s5461 ? s5447 : s5448;-  const SWord8 s5463 = (s5462 >> 1) | (s5462 << 7);-  const SWord8 s5464 = 128 | s5463;-  const SWord8 s5465 = 127 & s5463;-  const SWord8 s5466 = s5459 ? s5464 : s5465;-  const SBool  s5467 = (SBool) ((s2545 >> 0) & 1);-  const SBool  s5468 = false != s5467;-  const SWord8 s5469 = s5468 ? s5464 : s5465;-  const SWord8 s5470 = s2457 ? s5466 : s5469;-  const SWord8 s5471 = s2330 ? s5457 : s5470;-  const SWord8 s5472 = s2078 ? s5438 : s5471;-  const SWord8 s5473 = s2059 ? s5402 : s5472;-  const SWord8 s5474 = s2042 ? s5332 : s5473;-  const SBool  s5475 = (SBool) ((s2620 >> 0) & 1);-  const SBool  s5476 = false != s5475;-  const SBool  s5477 = (SBool) ((s2616 >> 0) & 1);-  const SBool  s5478 = false != s5477;-  const SBool  s5479 = (SBool) ((s2612 >> 0) & 1);-  const SBool  s5480 = false != s5479;-  const SWord8 s5481 = (s2599 >> 1) | (s2599 << 7);-  const SWord8 s5482 = 128 | s5481;-  const SWord8 s5483 = 127 & s5481;-  const SWord8 s5484 = s5480 ? s5482 : s5483;-  const SWord8 s5485 = (s5484 >> 1) | (s5484 << 7);-  const SWord8 s5486 = 128 | s5485;-  const SWord8 s5487 = 127 & s5485;-  const SWord8 s5488 = s5478 ? s5486 : s5487;-  const SWord8 s5489 = (s5488 >> 1) | (s5488 << 7);-  const SWord8 s5490 = 128 | s5489;-  const SWord8 s5491 = 127 & s5489;-  const SWord8 s5492 = s5476 ? s5490 : s5491;-  const SBool  s5493 = (SBool) ((s2625 >> 0) & 1);-  const SBool  s5494 = false != s5493;-  const SWord8 s5495 = s5494 ? s5490 : s5491;-  const SWord8 s5496 = s2608 ? s5492 : s5495;-  const SBool  s5497 = (SBool) ((s2641 >> 0) & 1);-  const SBool  s5498 = false != s5497;-  const SBool  s5499 = (SBool) ((s2634 >> 0) & 1);-  const SBool  s5500 = false != s5499;-  const SWord8 s5501 = s5500 ? s5486 : s5487;-  const SWord8 s5502 = (s5501 >> 1) | (s5501 << 7);-  const SWord8 s5503 = 128 | s5502;-  const SWord8 s5504 = 127 & s5502;-  const SWord8 s5505 = s5498 ? s5503 : s5504;-  const SBool  s5506 = (SBool) ((s2646 >> 0) & 1);-  const SBool  s5507 = false != s5506;-  const SWord8 s5508 = s5507 ? s5503 : s5504;-  const SWord8 s5509 = s2608 ? s5505 : s5508;-  const SWord8 s5510 = s2589 ? s5496 : s5509;-  const SBool  s5511 = (SBool) ((s2667 >> 0) & 1);-  const SBool  s5512 = false != s5511;-  const SBool  s5513 = (SBool) ((s2663 >> 0) & 1);-  const SBool  s5514 = false != s5513;-  const SBool  s5515 = (SBool) ((s2656 >> 0) & 1);-  const SBool  s5516 = false != s5515;-  const SWord8 s5517 = s5516 ? s5482 : s5483;-  const SWord8 s5518 = (s5517 >> 1) | (s5517 << 7);-  const SWord8 s5519 = 128 | s5518;-  const SWord8 s5520 = 127 & s5518;-  const SWord8 s5521 = s5514 ? s5519 : s5520;-  const SWord8 s5522 = (s5521 >> 1) | (s5521 << 7);-  const SWord8 s5523 = 128 | s5522;-  const SWord8 s5524 = 127 & s5522;-  const SWord8 s5525 = s5512 ? s5523 : s5524;-  const SBool  s5526 = (SBool) ((s2672 >> 0) & 1);-  const SBool  s5527 = false != s5526;-  const SWord8 s5528 = s5527 ? s5523 : s5524;-  const SWord8 s5529 = s2608 ? s5525 : s5528;-  const SBool  s5530 = (SBool) ((s2688 >> 0) & 1);-  const SBool  s5531 = false != s5530;-  const SBool  s5532 = (SBool) ((s2681 >> 0) & 1);-  const SBool  s5533 = false != s5532;-  const SWord8 s5534 = s5533 ? s5519 : s5520;-  const SWord8 s5535 = (s5534 >> 1) | (s5534 << 7);-  const SWord8 s5536 = 128 | s5535;-  const SWord8 s5537 = 127 & s5535;-  const SWord8 s5538 = s5531 ? s5536 : s5537;-  const SBool  s5539 = (SBool) ((s2693 >> 0) & 1);-  const SBool  s5540 = false != s5539;-  const SWord8 s5541 = s5540 ? s5536 : s5537;-  const SWord8 s5542 = s2608 ? s5538 : s5541;-  const SWord8 s5543 = s2589 ? s5529 : s5542;-  const SWord8 s5544 = s2567 ? s5510 : s5543;-  const SBool  s5545 = (SBool) ((s2728 >> 0) & 1);-  const SBool  s5546 = false != s5545;-  const SBool  s5547 = (SBool) ((s2724 >> 0) & 1);-  const SBool  s5548 = false != s5547;-  const SBool  s5549 = (SBool) ((s2720 >> 0) & 1);-  const SBool  s5550 = false != s5549;-  const SWord8 s5551 = (s2707 >> 1) | (s2707 << 7);-  const SWord8 s5552 = 128 | s5551;-  const SWord8 s5553 = 127 & s5551;-  const SWord8 s5554 = s5550 ? s5552 : s5553;-  const SWord8 s5555 = (s5554 >> 1) | (s5554 << 7);-  const SWord8 s5556 = 128 | s5555;-  const SWord8 s5557 = 127 & s5555;-  const SWord8 s5558 = s5548 ? s5556 : s5557;-  const SWord8 s5559 = (s5558 >> 1) | (s5558 << 7);-  const SWord8 s5560 = 128 | s5559;-  const SWord8 s5561 = 127 & s5559;-  const SWord8 s5562 = s5546 ? s5560 : s5561;-  const SBool  s5563 = (SBool) ((s2733 >> 0) & 1);-  const SBool  s5564 = false != s5563;-  const SWord8 s5565 = s5564 ? s5560 : s5561;-  const SWord8 s5566 = s2713 ? s5562 : s5565;-  const SBool  s5567 = (SBool) ((s2749 >> 0) & 1);-  const SBool  s5568 = false != s5567;-  const SBool  s5569 = (SBool) ((s2742 >> 0) & 1);-  const SBool  s5570 = false != s5569;-  const SWord8 s5571 = s5570 ? s5556 : s5557;-  const SWord8 s5572 = (s5571 >> 1) | (s5571 << 7);-  const SWord8 s5573 = 128 | s5572;-  const SWord8 s5574 = 127 & s5572;-  const SWord8 s5575 = s5568 ? s5573 : s5574;-  const SBool  s5576 = (SBool) ((s2754 >> 0) & 1);-  const SBool  s5577 = false != s5576;-  const SWord8 s5578 = s5577 ? s5573 : s5574;-  const SWord8 s5579 = s2713 ? s5575 : s5578;-  const SWord8 s5580 = s2589 ? s5566 : s5579;-  const SBool  s5581 = (SBool) ((s2775 >> 0) & 1);-  const SBool  s5582 = false != s5581;-  const SBool  s5583 = (SBool) ((s2771 >> 0) & 1);-  const SBool  s5584 = false != s5583;-  const SBool  s5585 = (SBool) ((s2764 >> 0) & 1);-  const SBool  s5586 = false != s5585;-  const SWord8 s5587 = s5586 ? s5552 : s5553;-  const SWord8 s5588 = (s5587 >> 1) | (s5587 << 7);-  const SWord8 s5589 = 128 | s5588;-  const SWord8 s5590 = 127 & s5588;-  const SWord8 s5591 = s5584 ? s5589 : s5590;-  const SWord8 s5592 = (s5591 >> 1) | (s5591 << 7);-  const SWord8 s5593 = 128 | s5592;-  const SWord8 s5594 = 127 & s5592;-  const SWord8 s5595 = s5582 ? s5593 : s5594;-  const SBool  s5596 = (SBool) ((s2780 >> 0) & 1);-  const SBool  s5597 = false != s5596;-  const SWord8 s5598 = s5597 ? s5593 : s5594;-  const SWord8 s5599 = s2713 ? s5595 : s5598;-  const SBool  s5600 = (SBool) ((s2796 >> 0) & 1);-  const SBool  s5601 = false != s5600;-  const SBool  s5602 = (SBool) ((s2789 >> 0) & 1);-  const SBool  s5603 = false != s5602;-  const SWord8 s5604 = s5603 ? s5589 : s5590;-  const SWord8 s5605 = (s5604 >> 1) | (s5604 << 7);-  const SWord8 s5606 = 128 | s5605;-  const SWord8 s5607 = 127 & s5605;-  const SWord8 s5608 = s5601 ? s5606 : s5607;-  const SBool  s5609 = (SBool) ((s2801 >> 0) & 1);-  const SBool  s5610 = false != s5609;-  const SWord8 s5611 = s5610 ? s5606 : s5607;-  const SWord8 s5612 = s2713 ? s5608 : s5611;-  const SWord8 s5613 = s2589 ? s5599 : s5612;-  const SWord8 s5614 = s2567 ? s5580 : s5613;-  const SWord8 s5615 = s2059 ? s5544 : s5614;-  const SBool  s5616 = (SBool) ((s2856 >> 0) & 1);-  const SBool  s5617 = false != s5616;-  const SBool  s5618 = (SBool) ((s2852 >> 0) & 1);-  const SBool  s5619 = false != s5618;-  const SBool  s5620 = (SBool) ((s2848 >> 0) & 1);-  const SBool  s5621 = false != s5620;-  const SWord8 s5622 = (s2835 >> 1) | (s2835 << 7);-  const SWord8 s5623 = 128 | s5622;-  const SWord8 s5624 = 127 & s5622;-  const SWord8 s5625 = s5621 ? s5623 : s5624;-  const SWord8 s5626 = (s5625 >> 1) | (s5625 << 7);-  const SWord8 s5627 = 128 | s5626;-  const SWord8 s5628 = 127 & s5626;-  const SWord8 s5629 = s5619 ? s5627 : s5628;-  const SWord8 s5630 = (s5629 >> 1) | (s5629 << 7);-  const SWord8 s5631 = 128 | s5630;-  const SWord8 s5632 = 127 & s5630;-  const SWord8 s5633 = s5617 ? s5631 : s5632;-  const SBool  s5634 = (SBool) ((s2861 >> 0) & 1);-  const SBool  s5635 = false != s5634;-  const SWord8 s5636 = s5635 ? s5631 : s5632;-  const SWord8 s5637 = s2844 ? s5633 : s5636;-  const SBool  s5638 = (SBool) ((s2877 >> 0) & 1);-  const SBool  s5639 = false != s5638;-  const SBool  s5640 = (SBool) ((s2870 >> 0) & 1);-  const SBool  s5641 = false != s5640;-  const SWord8 s5642 = s5641 ? s5627 : s5628;-  const SWord8 s5643 = (s5642 >> 1) | (s5642 << 7);-  const SWord8 s5644 = 128 | s5643;-  const SWord8 s5645 = 127 & s5643;-  const SWord8 s5646 = s5639 ? s5644 : s5645;-  const SBool  s5647 = (SBool) ((s2882 >> 0) & 1);-  const SBool  s5648 = false != s5647;-  const SWord8 s5649 = s5648 ? s5644 : s5645;-  const SWord8 s5650 = s2844 ? s5646 : s5649;-  const SWord8 s5651 = s2822 ? s5637 : s5650;-  const SBool  s5652 = (SBool) ((s2903 >> 0) & 1);-  const SBool  s5653 = false != s5652;-  const SBool  s5654 = (SBool) ((s2899 >> 0) & 1);-  const SBool  s5655 = false != s5654;-  const SBool  s5656 = (SBool) ((s2892 >> 0) & 1);-  const SBool  s5657 = false != s5656;-  const SWord8 s5658 = s5657 ? s5623 : s5624;-  const SWord8 s5659 = (s5658 >> 1) | (s5658 << 7);-  const SWord8 s5660 = 128 | s5659;-  const SWord8 s5661 = 127 & s5659;-  const SWord8 s5662 = s5655 ? s5660 : s5661;-  const SWord8 s5663 = (s5662 >> 1) | (s5662 << 7);-  const SWord8 s5664 = 128 | s5663;-  const SWord8 s5665 = 127 & s5663;-  const SWord8 s5666 = s5653 ? s5664 : s5665;-  const SBool  s5667 = (SBool) ((s2908 >> 0) & 1);-  const SBool  s5668 = false != s5667;-  const SWord8 s5669 = s5668 ? s5664 : s5665;-  const SWord8 s5670 = s2844 ? s5666 : s5669;-  const SBool  s5671 = (SBool) ((s2924 >> 0) & 1);-  const SBool  s5672 = false != s5671;-  const SBool  s5673 = (SBool) ((s2917 >> 0) & 1);-  const SBool  s5674 = false != s5673;-  const SWord8 s5675 = s5674 ? s5660 : s5661;-  const SWord8 s5676 = (s5675 >> 1) | (s5675 << 7);-  const SWord8 s5677 = 128 | s5676;-  const SWord8 s5678 = 127 & s5676;-  const SWord8 s5679 = s5672 ? s5677 : s5678;-  const SBool  s5680 = (SBool) ((s2929 >> 0) & 1);-  const SBool  s5681 = false != s5680;-  const SWord8 s5682 = s5681 ? s5677 : s5678;-  const SWord8 s5683 = s2844 ? s5679 : s5682;-  const SWord8 s5684 = s2822 ? s5670 : s5683;-  const SWord8 s5685 = s2567 ? s5651 : s5684;-  const SBool  s5686 = (SBool) ((s2964 >> 0) & 1);-  const SBool  s5687 = false != s5686;-  const SBool  s5688 = (SBool) ((s2960 >> 0) & 1);-  const SBool  s5689 = false != s5688;-  const SBool  s5690 = (SBool) ((s2956 >> 0) & 1);-  const SBool  s5691 = false != s5690;-  const SWord8 s5692 = (s2943 >> 1) | (s2943 << 7);-  const SWord8 s5693 = 128 | s5692;-  const SWord8 s5694 = 127 & s5692;-  const SWord8 s5695 = s5691 ? s5693 : s5694;-  const SWord8 s5696 = (s5695 >> 1) | (s5695 << 7);-  const SWord8 s5697 = 128 | s5696;-  const SWord8 s5698 = 127 & s5696;-  const SWord8 s5699 = s5689 ? s5697 : s5698;-  const SWord8 s5700 = (s5699 >> 1) | (s5699 << 7);-  const SWord8 s5701 = 128 | s5700;-  const SWord8 s5702 = 127 & s5700;-  const SWord8 s5703 = s5687 ? s5701 : s5702;-  const SBool  s5704 = (SBool) ((s2969 >> 0) & 1);-  const SBool  s5705 = false != s5704;-  const SWord8 s5706 = s5705 ? s5701 : s5702;-  const SWord8 s5707 = s2949 ? s5703 : s5706;-  const SBool  s5708 = (SBool) ((s2985 >> 0) & 1);-  const SBool  s5709 = false != s5708;-  const SBool  s5710 = (SBool) ((s2978 >> 0) & 1);-  const SBool  s5711 = false != s5710;-  const SWord8 s5712 = s5711 ? s5697 : s5698;-  const SWord8 s5713 = (s5712 >> 1) | (s5712 << 7);-  const SWord8 s5714 = 128 | s5713;-  const SWord8 s5715 = 127 & s5713;-  const SWord8 s5716 = s5709 ? s5714 : s5715;-  const SBool  s5717 = (SBool) ((s2990 >> 0) & 1);-  const SBool  s5718 = false != s5717;-  const SWord8 s5719 = s5718 ? s5714 : s5715;-  const SWord8 s5720 = s2949 ? s5716 : s5719;-  const SWord8 s5721 = s2822 ? s5707 : s5720;-  const SBool  s5722 = (SBool) ((s3011 >> 0) & 1);-  const SBool  s5723 = false != s5722;-  const SBool  s5724 = (SBool) ((s3007 >> 0) & 1);-  const SBool  s5725 = false != s5724;-  const SBool  s5726 = (SBool) ((s3000 >> 0) & 1);-  const SBool  s5727 = false != s5726;-  const SWord8 s5728 = s5727 ? s5693 : s5694;-  const SWord8 s5729 = (s5728 >> 1) | (s5728 << 7);-  const SWord8 s5730 = 128 | s5729;-  const SWord8 s5731 = 127 & s5729;-  const SWord8 s5732 = s5725 ? s5730 : s5731;-  const SWord8 s5733 = (s5732 >> 1) | (s5732 << 7);-  const SWord8 s5734 = 128 | s5733;-  const SWord8 s5735 = 127 & s5733;-  const SWord8 s5736 = s5723 ? s5734 : s5735;-  const SBool  s5737 = (SBool) ((s3016 >> 0) & 1);-  const SBool  s5738 = false != s5737;-  const SWord8 s5739 = s5738 ? s5734 : s5735;-  const SWord8 s5740 = s2949 ? s5736 : s5739;-  const SBool  s5741 = (SBool) ((s3032 >> 0) & 1);-  const SBool  s5742 = false != s5741;-  const SBool  s5743 = (SBool) ((s3025 >> 0) & 1);-  const SBool  s5744 = false != s5743;-  const SWord8 s5745 = s5744 ? s5730 : s5731;-  const SWord8 s5746 = (s5745 >> 1) | (s5745 << 7);-  const SWord8 s5747 = 128 | s5746;-  const SWord8 s5748 = 127 & s5746;-  const SWord8 s5749 = s5742 ? s5747 : s5748;-  const SBool  s5750 = (SBool) ((s3037 >> 0) & 1);-  const SBool  s5751 = false != s5750;-  const SWord8 s5752 = s5751 ? s5747 : s5748;-  const SWord8 s5753 = s2949 ? s5749 : s5752;-  const SWord8 s5754 = s2822 ? s5740 : s5753;-  const SWord8 s5755 = s2567 ? s5721 : s5754;-  const SWord8 s5756 = s2059 ? s5685 : s5755;-  const SWord8 s5757 = s2042 ? s5615 : s5756;-  const SWord8 s5758 = s16 ? s5474 : s5757;-  const SBool  s5759 = (SBool) ((s3132 >> 0) & 1);-  const SBool  s5760 = false != s5759;-  const SBool  s5761 = (SBool) ((s3128 >> 0) & 1);-  const SBool  s5762 = false != s5761;-  const SBool  s5763 = (SBool) ((s3124 >> 0) & 1);-  const SBool  s5764 = false != s5763;-  const SWord8 s5765 = (s3111 >> 1) | (s3111 << 7);-  const SWord8 s5766 = 128 | s5765;-  const SWord8 s5767 = 127 & s5765;-  const SWord8 s5768 = s5764 ? s5766 : s5767;-  const SWord8 s5769 = (s5768 >> 1) | (s5768 << 7);-  const SWord8 s5770 = 128 | s5769;-  const SWord8 s5771 = 127 & s5769;-  const SWord8 s5772 = s5762 ? s5770 : s5771;-  const SWord8 s5773 = (s5772 >> 1) | (s5772 << 7);-  const SWord8 s5774 = 128 | s5773;-  const SWord8 s5775 = 127 & s5773;-  const SWord8 s5776 = s5760 ? s5774 : s5775;-  const SBool  s5777 = (SBool) ((s3137 >> 0) & 1);-  const SBool  s5778 = false != s5777;-  const SWord8 s5779 = s5778 ? s5774 : s5775;-  const SWord8 s5780 = s3120 ? s5776 : s5779;-  const SBool  s5781 = (SBool) ((s3153 >> 0) & 1);-  const SBool  s5782 = false != s5781;-  const SBool  s5783 = (SBool) ((s3146 >> 0) & 1);-  const SBool  s5784 = false != s5783;-  const SWord8 s5785 = s5784 ? s5770 : s5771;-  const SWord8 s5786 = (s5785 >> 1) | (s5785 << 7);-  const SWord8 s5787 = 128 | s5786;-  const SWord8 s5788 = 127 & s5786;-  const SWord8 s5789 = s5782 ? s5787 : s5788;-  const SBool  s5790 = (SBool) ((s3158 >> 0) & 1);-  const SBool  s5791 = false != s5790;-  const SWord8 s5792 = s5791 ? s5787 : s5788;-  const SWord8 s5793 = s3120 ? s5789 : s5792;-  const SWord8 s5794 = s3101 ? s5780 : s5793;-  const SBool  s5795 = (SBool) ((s3179 >> 0) & 1);-  const SBool  s5796 = false != s5795;-  const SBool  s5797 = (SBool) ((s3175 >> 0) & 1);-  const SBool  s5798 = false != s5797;-  const SBool  s5799 = (SBool) ((s3168 >> 0) & 1);-  const SBool  s5800 = false != s5799;-  const SWord8 s5801 = s5800 ? s5766 : s5767;-  const SWord8 s5802 = (s5801 >> 1) | (s5801 << 7);-  const SWord8 s5803 = 128 | s5802;-  const SWord8 s5804 = 127 & s5802;-  const SWord8 s5805 = s5798 ? s5803 : s5804;-  const SWord8 s5806 = (s5805 >> 1) | (s5805 << 7);-  const SWord8 s5807 = 128 | s5806;-  const SWord8 s5808 = 127 & s5806;-  const SWord8 s5809 = s5796 ? s5807 : s5808;-  const SBool  s5810 = (SBool) ((s3184 >> 0) & 1);-  const SBool  s5811 = false != s5810;-  const SWord8 s5812 = s5811 ? s5807 : s5808;-  const SWord8 s5813 = s3120 ? s5809 : s5812;-  const SBool  s5814 = (SBool) ((s3200 >> 0) & 1);-  const SBool  s5815 = false != s5814;-  const SBool  s5816 = (SBool) ((s3193 >> 0) & 1);-  const SBool  s5817 = false != s5816;-  const SWord8 s5818 = s5817 ? s5803 : s5804;-  const SWord8 s5819 = (s5818 >> 1) | (s5818 << 7);-  const SWord8 s5820 = 128 | s5819;-  const SWord8 s5821 = 127 & s5819;-  const SWord8 s5822 = s5815 ? s5820 : s5821;-  const SBool  s5823 = (SBool) ((s3205 >> 0) & 1);-  const SBool  s5824 = false != s5823;-  const SWord8 s5825 = s5824 ? s5820 : s5821;-  const SWord8 s5826 = s3120 ? s5822 : s5825;-  const SWord8 s5827 = s3101 ? s5813 : s5826;-  const SWord8 s5828 = s3082 ? s5794 : s5827;-  const SBool  s5829 = (SBool) ((s3240 >> 0) & 1);-  const SBool  s5830 = false != s5829;-  const SBool  s5831 = (SBool) ((s3236 >> 0) & 1);-  const SBool  s5832 = false != s5831;-  const SBool  s5833 = (SBool) ((s3232 >> 0) & 1);-  const SBool  s5834 = false != s5833;-  const SWord8 s5835 = (s3219 >> 1) | (s3219 << 7);-  const SWord8 s5836 = 128 | s5835;-  const SWord8 s5837 = 127 & s5835;-  const SWord8 s5838 = s5834 ? s5836 : s5837;-  const SWord8 s5839 = (s5838 >> 1) | (s5838 << 7);-  const SWord8 s5840 = 128 | s5839;-  const SWord8 s5841 = 127 & s5839;-  const SWord8 s5842 = s5832 ? s5840 : s5841;-  const SWord8 s5843 = (s5842 >> 1) | (s5842 << 7);-  const SWord8 s5844 = 128 | s5843;-  const SWord8 s5845 = 127 & s5843;-  const SWord8 s5846 = s5830 ? s5844 : s5845;-  const SBool  s5847 = (SBool) ((s3245 >> 0) & 1);-  const SBool  s5848 = false != s5847;-  const SWord8 s5849 = s5848 ? s5844 : s5845;-  const SWord8 s5850 = s3225 ? s5846 : s5849;-  const SBool  s5851 = (SBool) ((s3261 >> 0) & 1);-  const SBool  s5852 = false != s5851;-  const SBool  s5853 = (SBool) ((s3254 >> 0) & 1);-  const SBool  s5854 = false != s5853;-  const SWord8 s5855 = s5854 ? s5840 : s5841;-  const SWord8 s5856 = (s5855 >> 1) | (s5855 << 7);-  const SWord8 s5857 = 128 | s5856;-  const SWord8 s5858 = 127 & s5856;-  const SWord8 s5859 = s5852 ? s5857 : s5858;-  const SBool  s5860 = (SBool) ((s3266 >> 0) & 1);-  const SBool  s5861 = false != s5860;-  const SWord8 s5862 = s5861 ? s5857 : s5858;-  const SWord8 s5863 = s3225 ? s5859 : s5862;-  const SWord8 s5864 = s3101 ? s5850 : s5863;-  const SBool  s5865 = (SBool) ((s3287 >> 0) & 1);-  const SBool  s5866 = false != s5865;-  const SBool  s5867 = (SBool) ((s3283 >> 0) & 1);-  const SBool  s5868 = false != s5867;-  const SBool  s5869 = (SBool) ((s3276 >> 0) & 1);-  const SBool  s5870 = false != s5869;-  const SWord8 s5871 = s5870 ? s5836 : s5837;-  const SWord8 s5872 = (s5871 >> 1) | (s5871 << 7);-  const SWord8 s5873 = 128 | s5872;-  const SWord8 s5874 = 127 & s5872;-  const SWord8 s5875 = s5868 ? s5873 : s5874;-  const SWord8 s5876 = (s5875 >> 1) | (s5875 << 7);-  const SWord8 s5877 = 128 | s5876;-  const SWord8 s5878 = 127 & s5876;-  const SWord8 s5879 = s5866 ? s5877 : s5878;-  const SBool  s5880 = (SBool) ((s3292 >> 0) & 1);-  const SBool  s5881 = false != s5880;-  const SWord8 s5882 = s5881 ? s5877 : s5878;-  const SWord8 s5883 = s3225 ? s5879 : s5882;-  const SBool  s5884 = (SBool) ((s3308 >> 0) & 1);-  const SBool  s5885 = false != s5884;-  const SBool  s5886 = (SBool) ((s3301 >> 0) & 1);-  const SBool  s5887 = false != s5886;-  const SWord8 s5888 = s5887 ? s5873 : s5874;-  const SWord8 s5889 = (s5888 >> 1) | (s5888 << 7);-  const SWord8 s5890 = 128 | s5889;-  const SWord8 s5891 = 127 & s5889;-  const SWord8 s5892 = s5885 ? s5890 : s5891;-  const SBool  s5893 = (SBool) ((s3313 >> 0) & 1);-  const SBool  s5894 = false != s5893;-  const SWord8 s5895 = s5894 ? s5890 : s5891;-  const SWord8 s5896 = s3225 ? s5892 : s5895;-  const SWord8 s5897 = s3101 ? s5883 : s5896;-  const SWord8 s5898 = s3082 ? s5864 : s5897;-  const SWord8 s5899 = s3060 ? s5828 : s5898;-  const SBool  s5900 = (SBool) ((s3368 >> 0) & 1);-  const SBool  s5901 = false != s5900;-  const SBool  s5902 = (SBool) ((s3364 >> 0) & 1);-  const SBool  s5903 = false != s5902;-  const SBool  s5904 = (SBool) ((s3360 >> 0) & 1);-  const SBool  s5905 = false != s5904;-  const SWord8 s5906 = (s3347 >> 1) | (s3347 << 7);-  const SWord8 s5907 = 128 | s5906;-  const SWord8 s5908 = 127 & s5906;-  const SWord8 s5909 = s5905 ? s5907 : s5908;-  const SWord8 s5910 = (s5909 >> 1) | (s5909 << 7);-  const SWord8 s5911 = 128 | s5910;-  const SWord8 s5912 = 127 & s5910;-  const SWord8 s5913 = s5903 ? s5911 : s5912;-  const SWord8 s5914 = (s5913 >> 1) | (s5913 << 7);-  const SWord8 s5915 = 128 | s5914;-  const SWord8 s5916 = 127 & s5914;-  const SWord8 s5917 = s5901 ? s5915 : s5916;-  const SBool  s5918 = (SBool) ((s3373 >> 0) & 1);-  const SBool  s5919 = false != s5918;-  const SWord8 s5920 = s5919 ? s5915 : s5916;-  const SWord8 s5921 = s3356 ? s5917 : s5920;-  const SBool  s5922 = (SBool) ((s3389 >> 0) & 1);-  const SBool  s5923 = false != s5922;-  const SBool  s5924 = (SBool) ((s3382 >> 0) & 1);-  const SBool  s5925 = false != s5924;-  const SWord8 s5926 = s5925 ? s5911 : s5912;-  const SWord8 s5927 = (s5926 >> 1) | (s5926 << 7);-  const SWord8 s5928 = 128 | s5927;-  const SWord8 s5929 = 127 & s5927;-  const SWord8 s5930 = s5923 ? s5928 : s5929;-  const SBool  s5931 = (SBool) ((s3394 >> 0) & 1);-  const SBool  s5932 = false != s5931;-  const SWord8 s5933 = s5932 ? s5928 : s5929;-  const SWord8 s5934 = s3356 ? s5930 : s5933;-  const SWord8 s5935 = s3334 ? s5921 : s5934;-  const SBool  s5936 = (SBool) ((s3415 >> 0) & 1);-  const SBool  s5937 = false != s5936;-  const SBool  s5938 = (SBool) ((s3411 >> 0) & 1);-  const SBool  s5939 = false != s5938;-  const SBool  s5940 = (SBool) ((s3404 >> 0) & 1);-  const SBool  s5941 = false != s5940;-  const SWord8 s5942 = s5941 ? s5907 : s5908;-  const SWord8 s5943 = (s5942 >> 1) | (s5942 << 7);-  const SWord8 s5944 = 128 | s5943;-  const SWord8 s5945 = 127 & s5943;-  const SWord8 s5946 = s5939 ? s5944 : s5945;-  const SWord8 s5947 = (s5946 >> 1) | (s5946 << 7);-  const SWord8 s5948 = 128 | s5947;-  const SWord8 s5949 = 127 & s5947;-  const SWord8 s5950 = s5937 ? s5948 : s5949;-  const SBool  s5951 = (SBool) ((s3420 >> 0) & 1);-  const SBool  s5952 = false != s5951;-  const SWord8 s5953 = s5952 ? s5948 : s5949;-  const SWord8 s5954 = s3356 ? s5950 : s5953;-  const SBool  s5955 = (SBool) ((s3436 >> 0) & 1);-  const SBool  s5956 = false != s5955;-  const SBool  s5957 = (SBool) ((s3429 >> 0) & 1);-  const SBool  s5958 = false != s5957;-  const SWord8 s5959 = s5958 ? s5944 : s5945;-  const SWord8 s5960 = (s5959 >> 1) | (s5959 << 7);-  const SWord8 s5961 = 128 | s5960;-  const SWord8 s5962 = 127 & s5960;-  const SWord8 s5963 = s5956 ? s5961 : s5962;-  const SBool  s5964 = (SBool) ((s3441 >> 0) & 1);-  const SBool  s5965 = false != s5964;-  const SWord8 s5966 = s5965 ? s5961 : s5962;-  const SWord8 s5967 = s3356 ? s5963 : s5966;-  const SWord8 s5968 = s3334 ? s5954 : s5967;-  const SWord8 s5969 = s3082 ? s5935 : s5968;-  const SBool  s5970 = (SBool) ((s3476 >> 0) & 1);-  const SBool  s5971 = false != s5970;-  const SBool  s5972 = (SBool) ((s3472 >> 0) & 1);-  const SBool  s5973 = false != s5972;-  const SBool  s5974 = (SBool) ((s3468 >> 0) & 1);-  const SBool  s5975 = false != s5974;-  const SWord8 s5976 = (s3455 >> 1) | (s3455 << 7);-  const SWord8 s5977 = 128 | s5976;-  const SWord8 s5978 = 127 & s5976;-  const SWord8 s5979 = s5975 ? s5977 : s5978;-  const SWord8 s5980 = (s5979 >> 1) | (s5979 << 7);-  const SWord8 s5981 = 128 | s5980;-  const SWord8 s5982 = 127 & s5980;-  const SWord8 s5983 = s5973 ? s5981 : s5982;-  const SWord8 s5984 = (s5983 >> 1) | (s5983 << 7);-  const SWord8 s5985 = 128 | s5984;-  const SWord8 s5986 = 127 & s5984;-  const SWord8 s5987 = s5971 ? s5985 : s5986;-  const SBool  s5988 = (SBool) ((s3481 >> 0) & 1);-  const SBool  s5989 = false != s5988;-  const SWord8 s5990 = s5989 ? s5985 : s5986;-  const SWord8 s5991 = s3461 ? s5987 : s5990;-  const SBool  s5992 = (SBool) ((s3497 >> 0) & 1);-  const SBool  s5993 = false != s5992;-  const SBool  s5994 = (SBool) ((s3490 >> 0) & 1);-  const SBool  s5995 = false != s5994;-  const SWord8 s5996 = s5995 ? s5981 : s5982;-  const SWord8 s5997 = (s5996 >> 1) | (s5996 << 7);-  const SWord8 s5998 = 128 | s5997;-  const SWord8 s5999 = 127 & s5997;-  const SWord8 s6000 = s5993 ? s5998 : s5999;-  const SBool  s6001 = (SBool) ((s3502 >> 0) & 1);-  const SBool  s6002 = false != s6001;-  const SWord8 s6003 = s6002 ? s5998 : s5999;-  const SWord8 s6004 = s3461 ? s6000 : s6003;-  const SWord8 s6005 = s3334 ? s5991 : s6004;-  const SBool  s6006 = (SBool) ((s3523 >> 0) & 1);-  const SBool  s6007 = false != s6006;-  const SBool  s6008 = (SBool) ((s3519 >> 0) & 1);-  const SBool  s6009 = false != s6008;-  const SBool  s6010 = (SBool) ((s3512 >> 0) & 1);-  const SBool  s6011 = false != s6010;-  const SWord8 s6012 = s6011 ? s5977 : s5978;-  const SWord8 s6013 = (s6012 >> 1) | (s6012 << 7);-  const SWord8 s6014 = 128 | s6013;-  const SWord8 s6015 = 127 & s6013;-  const SWord8 s6016 = s6009 ? s6014 : s6015;-  const SWord8 s6017 = (s6016 >> 1) | (s6016 << 7);-  const SWord8 s6018 = 128 | s6017;-  const SWord8 s6019 = 127 & s6017;-  const SWord8 s6020 = s6007 ? s6018 : s6019;-  const SBool  s6021 = (SBool) ((s3528 >> 0) & 1);-  const SBool  s6022 = false != s6021;-  const SWord8 s6023 = s6022 ? s6018 : s6019;-  const SWord8 s6024 = s3461 ? s6020 : s6023;-  const SBool  s6025 = (SBool) ((s3544 >> 0) & 1);-  const SBool  s6026 = false != s6025;-  const SBool  s6027 = (SBool) ((s3537 >> 0) & 1);-  const SBool  s6028 = false != s6027;-  const SWord8 s6029 = s6028 ? s6014 : s6015;-  const SWord8 s6030 = (s6029 >> 1) | (s6029 << 7);-  const SWord8 s6031 = 128 | s6030;-  const SWord8 s6032 = 127 & s6030;-  const SWord8 s6033 = s6026 ? s6031 : s6032;-  const SBool  s6034 = (SBool) ((s3549 >> 0) & 1);-  const SBool  s6035 = false != s6034;-  const SWord8 s6036 = s6035 ? s6031 : s6032;-  const SWord8 s6037 = s3461 ? s6033 : s6036;-  const SWord8 s6038 = s3334 ? s6024 : s6037;-  const SWord8 s6039 = s3082 ? s6005 : s6038;-  const SWord8 s6040 = s3060 ? s5969 : s6039;-  const SWord8 s6041 = s2042 ? s5899 : s6040;-  const SBool  s6042 = (SBool) ((s3624 >> 0) & 1);-  const SBool  s6043 = false != s6042;-  const SBool  s6044 = (SBool) ((s3620 >> 0) & 1);-  const SBool  s6045 = false != s6044;-  const SBool  s6046 = (SBool) ((s3616 >> 0) & 1);-  const SBool  s6047 = false != s6046;-  const SWord8 s6048 = (s3603 >> 1) | (s3603 << 7);-  const SWord8 s6049 = 128 | s6048;-  const SWord8 s6050 = 127 & s6048;-  const SWord8 s6051 = s6047 ? s6049 : s6050;-  const SWord8 s6052 = (s6051 >> 1) | (s6051 << 7);-  const SWord8 s6053 = 128 | s6052;-  const SWord8 s6054 = 127 & s6052;-  const SWord8 s6055 = s6045 ? s6053 : s6054;-  const SWord8 s6056 = (s6055 >> 1) | (s6055 << 7);-  const SWord8 s6057 = 128 | s6056;-  const SWord8 s6058 = 127 & s6056;-  const SWord8 s6059 = s6043 ? s6057 : s6058;-  const SBool  s6060 = (SBool) ((s3629 >> 0) & 1);-  const SBool  s6061 = false != s6060;-  const SWord8 s6062 = s6061 ? s6057 : s6058;-  const SWord8 s6063 = s3612 ? s6059 : s6062;-  const SBool  s6064 = (SBool) ((s3645 >> 0) & 1);-  const SBool  s6065 = false != s6064;-  const SBool  s6066 = (SBool) ((s3638 >> 0) & 1);-  const SBool  s6067 = false != s6066;-  const SWord8 s6068 = s6067 ? s6053 : s6054;-  const SWord8 s6069 = (s6068 >> 1) | (s6068 << 7);-  const SWord8 s6070 = 128 | s6069;-  const SWord8 s6071 = 127 & s6069;-  const SWord8 s6072 = s6065 ? s6070 : s6071;-  const SBool  s6073 = (SBool) ((s3650 >> 0) & 1);-  const SBool  s6074 = false != s6073;-  const SWord8 s6075 = s6074 ? s6070 : s6071;-  const SWord8 s6076 = s3612 ? s6072 : s6075;-  const SWord8 s6077 = s3593 ? s6063 : s6076;-  const SBool  s6078 = (SBool) ((s3671 >> 0) & 1);-  const SBool  s6079 = false != s6078;-  const SBool  s6080 = (SBool) ((s3667 >> 0) & 1);-  const SBool  s6081 = false != s6080;-  const SBool  s6082 = (SBool) ((s3660 >> 0) & 1);-  const SBool  s6083 = false != s6082;-  const SWord8 s6084 = s6083 ? s6049 : s6050;-  const SWord8 s6085 = (s6084 >> 1) | (s6084 << 7);-  const SWord8 s6086 = 128 | s6085;-  const SWord8 s6087 = 127 & s6085;-  const SWord8 s6088 = s6081 ? s6086 : s6087;-  const SWord8 s6089 = (s6088 >> 1) | (s6088 << 7);-  const SWord8 s6090 = 128 | s6089;-  const SWord8 s6091 = 127 & s6089;-  const SWord8 s6092 = s6079 ? s6090 : s6091;-  const SBool  s6093 = (SBool) ((s3676 >> 0) & 1);-  const SBool  s6094 = false != s6093;-  const SWord8 s6095 = s6094 ? s6090 : s6091;-  const SWord8 s6096 = s3612 ? s6092 : s6095;-  const SBool  s6097 = (SBool) ((s3692 >> 0) & 1);-  const SBool  s6098 = false != s6097;-  const SBool  s6099 = (SBool) ((s3685 >> 0) & 1);-  const SBool  s6100 = false != s6099;-  const SWord8 s6101 = s6100 ? s6086 : s6087;-  const SWord8 s6102 = (s6101 >> 1) | (s6101 << 7);-  const SWord8 s6103 = 128 | s6102;-  const SWord8 s6104 = 127 & s6102;-  const SWord8 s6105 = s6098 ? s6103 : s6104;-  const SBool  s6106 = (SBool) ((s3697 >> 0) & 1);-  const SBool  s6107 = false != s6106;-  const SWord8 s6108 = s6107 ? s6103 : s6104;-  const SWord8 s6109 = s3612 ? s6105 : s6108;-  const SWord8 s6110 = s3593 ? s6096 : s6109;-  const SWord8 s6111 = s3571 ? s6077 : s6110;-  const SBool  s6112 = (SBool) ((s3732 >> 0) & 1);-  const SBool  s6113 = false != s6112;-  const SBool  s6114 = (SBool) ((s3728 >> 0) & 1);-  const SBool  s6115 = false != s6114;-  const SBool  s6116 = (SBool) ((s3724 >> 0) & 1);-  const SBool  s6117 = false != s6116;-  const SWord8 s6118 = (s3711 >> 1) | (s3711 << 7);-  const SWord8 s6119 = 128 | s6118;-  const SWord8 s6120 = 127 & s6118;-  const SWord8 s6121 = s6117 ? s6119 : s6120;-  const SWord8 s6122 = (s6121 >> 1) | (s6121 << 7);-  const SWord8 s6123 = 128 | s6122;-  const SWord8 s6124 = 127 & s6122;-  const SWord8 s6125 = s6115 ? s6123 : s6124;-  const SWord8 s6126 = (s6125 >> 1) | (s6125 << 7);-  const SWord8 s6127 = 128 | s6126;-  const SWord8 s6128 = 127 & s6126;-  const SWord8 s6129 = s6113 ? s6127 : s6128;-  const SBool  s6130 = (SBool) ((s3737 >> 0) & 1);-  const SBool  s6131 = false != s6130;-  const SWord8 s6132 = s6131 ? s6127 : s6128;-  const SWord8 s6133 = s3717 ? s6129 : s6132;-  const SBool  s6134 = (SBool) ((s3753 >> 0) & 1);-  const SBool  s6135 = false != s6134;-  const SBool  s6136 = (SBool) ((s3746 >> 0) & 1);-  const SBool  s6137 = false != s6136;-  const SWord8 s6138 = s6137 ? s6123 : s6124;-  const SWord8 s6139 = (s6138 >> 1) | (s6138 << 7);-  const SWord8 s6140 = 128 | s6139;-  const SWord8 s6141 = 127 & s6139;-  const SWord8 s6142 = s6135 ? s6140 : s6141;-  const SBool  s6143 = (SBool) ((s3758 >> 0) & 1);-  const SBool  s6144 = false != s6143;-  const SWord8 s6145 = s6144 ? s6140 : s6141;-  const SWord8 s6146 = s3717 ? s6142 : s6145;-  const SWord8 s6147 = s3593 ? s6133 : s6146;-  const SBool  s6148 = (SBool) ((s3779 >> 0) & 1);-  const SBool  s6149 = false != s6148;-  const SBool  s6150 = (SBool) ((s3775 >> 0) & 1);-  const SBool  s6151 = false != s6150;-  const SBool  s6152 = (SBool) ((s3768 >> 0) & 1);-  const SBool  s6153 = false != s6152;-  const SWord8 s6154 = s6153 ? s6119 : s6120;-  const SWord8 s6155 = (s6154 >> 1) | (s6154 << 7);-  const SWord8 s6156 = 128 | s6155;-  const SWord8 s6157 = 127 & s6155;-  const SWord8 s6158 = s6151 ? s6156 : s6157;-  const SWord8 s6159 = (s6158 >> 1) | (s6158 << 7);-  const SWord8 s6160 = 128 | s6159;-  const SWord8 s6161 = 127 & s6159;-  const SWord8 s6162 = s6149 ? s6160 : s6161;-  const SBool  s6163 = (SBool) ((s3784 >> 0) & 1);-  const SBool  s6164 = false != s6163;-  const SWord8 s6165 = s6164 ? s6160 : s6161;-  const SWord8 s6166 = s3717 ? s6162 : s6165;-  const SBool  s6167 = (SBool) ((s3800 >> 0) & 1);-  const SBool  s6168 = false != s6167;-  const SBool  s6169 = (SBool) ((s3793 >> 0) & 1);-  const SBool  s6170 = false != s6169;-  const SWord8 s6171 = s6170 ? s6156 : s6157;-  const SWord8 s6172 = (s6171 >> 1) | (s6171 << 7);-  const SWord8 s6173 = 128 | s6172;-  const SWord8 s6174 = 127 & s6172;-  const SWord8 s6175 = s6168 ? s6173 : s6174;-  const SBool  s6176 = (SBool) ((s3805 >> 0) & 1);-  const SBool  s6177 = false != s6176;-  const SWord8 s6178 = s6177 ? s6173 : s6174;-  const SWord8 s6179 = s3717 ? s6175 : s6178;-  const SWord8 s6180 = s3593 ? s6166 : s6179;-  const SWord8 s6181 = s3571 ? s6147 : s6180;-  const SWord8 s6182 = s3060 ? s6111 : s6181;-  const SBool  s6183 = (SBool) ((s3860 >> 0) & 1);-  const SBool  s6184 = false != s6183;-  const SBool  s6185 = (SBool) ((s3856 >> 0) & 1);-  const SBool  s6186 = false != s6185;-  const SBool  s6187 = (SBool) ((s3852 >> 0) & 1);-  const SBool  s6188 = false != s6187;-  const SWord8 s6189 = (s3839 >> 1) | (s3839 << 7);-  const SWord8 s6190 = 128 | s6189;-  const SWord8 s6191 = 127 & s6189;-  const SWord8 s6192 = s6188 ? s6190 : s6191;-  const SWord8 s6193 = (s6192 >> 1) | (s6192 << 7);-  const SWord8 s6194 = 128 | s6193;-  const SWord8 s6195 = 127 & s6193;-  const SWord8 s6196 = s6186 ? s6194 : s6195;-  const SWord8 s6197 = (s6196 >> 1) | (s6196 << 7);-  const SWord8 s6198 = 128 | s6197;-  const SWord8 s6199 = 127 & s6197;-  const SWord8 s6200 = s6184 ? s6198 : s6199;-  const SBool  s6201 = (SBool) ((s3865 >> 0) & 1);-  const SBool  s6202 = false != s6201;-  const SWord8 s6203 = s6202 ? s6198 : s6199;-  const SWord8 s6204 = s3848 ? s6200 : s6203;-  const SBool  s6205 = (SBool) ((s3881 >> 0) & 1);-  const SBool  s6206 = false != s6205;-  const SBool  s6207 = (SBool) ((s3874 >> 0) & 1);-  const SBool  s6208 = false != s6207;-  const SWord8 s6209 = s6208 ? s6194 : s6195;-  const SWord8 s6210 = (s6209 >> 1) | (s6209 << 7);-  const SWord8 s6211 = 128 | s6210;-  const SWord8 s6212 = 127 & s6210;-  const SWord8 s6213 = s6206 ? s6211 : s6212;-  const SBool  s6214 = (SBool) ((s3886 >> 0) & 1);-  const SBool  s6215 = false != s6214;-  const SWord8 s6216 = s6215 ? s6211 : s6212;-  const SWord8 s6217 = s3848 ? s6213 : s6216;-  const SWord8 s6218 = s3826 ? s6204 : s6217;-  const SBool  s6219 = (SBool) ((s3907 >> 0) & 1);-  const SBool  s6220 = false != s6219;-  const SBool  s6221 = (SBool) ((s3903 >> 0) & 1);-  const SBool  s6222 = false != s6221;-  const SBool  s6223 = (SBool) ((s3896 >> 0) & 1);-  const SBool  s6224 = false != s6223;-  const SWord8 s6225 = s6224 ? s6190 : s6191;-  const SWord8 s6226 = (s6225 >> 1) | (s6225 << 7);-  const SWord8 s6227 = 128 | s6226;-  const SWord8 s6228 = 127 & s6226;-  const SWord8 s6229 = s6222 ? s6227 : s6228;-  const SWord8 s6230 = (s6229 >> 1) | (s6229 << 7);-  const SWord8 s6231 = 128 | s6230;-  const SWord8 s6232 = 127 & s6230;-  const SWord8 s6233 = s6220 ? s6231 : s6232;-  const SBool  s6234 = (SBool) ((s3912 >> 0) & 1);-  const SBool  s6235 = false != s6234;-  const SWord8 s6236 = s6235 ? s6231 : s6232;-  const SWord8 s6237 = s3848 ? s6233 : s6236;-  const SBool  s6238 = (SBool) ((s3928 >> 0) & 1);-  const SBool  s6239 = false != s6238;-  const SBool  s6240 = (SBool) ((s3921 >> 0) & 1);-  const SBool  s6241 = false != s6240;-  const SWord8 s6242 = s6241 ? s6227 : s6228;-  const SWord8 s6243 = (s6242 >> 1) | (s6242 << 7);-  const SWord8 s6244 = 128 | s6243;-  const SWord8 s6245 = 127 & s6243;-  const SWord8 s6246 = s6239 ? s6244 : s6245;-  const SBool  s6247 = (SBool) ((s3933 >> 0) & 1);-  const SBool  s6248 = false != s6247;-  const SWord8 s6249 = s6248 ? s6244 : s6245;-  const SWord8 s6250 = s3848 ? s6246 : s6249;-  const SWord8 s6251 = s3826 ? s6237 : s6250;-  const SWord8 s6252 = s3571 ? s6218 : s6251;-  const SBool  s6253 = (SBool) ((s3968 >> 0) & 1);-  const SBool  s6254 = false != s6253;-  const SBool  s6255 = (SBool) ((s3964 >> 0) & 1);-  const SBool  s6256 = false != s6255;-  const SBool  s6257 = (SBool) ((s3960 >> 0) & 1);-  const SBool  s6258 = false != s6257;-  const SWord8 s6259 = (s3947 >> 1) | (s3947 << 7);-  const SWord8 s6260 = 128 | s6259;-  const SWord8 s6261 = 127 & s6259;-  const SWord8 s6262 = s6258 ? s6260 : s6261;-  const SWord8 s6263 = (s6262 >> 1) | (s6262 << 7);-  const SWord8 s6264 = 128 | s6263;-  const SWord8 s6265 = 127 & s6263;-  const SWord8 s6266 = s6256 ? s6264 : s6265;-  const SWord8 s6267 = (s6266 >> 1) | (s6266 << 7);-  const SWord8 s6268 = 128 | s6267;-  const SWord8 s6269 = 127 & s6267;-  const SWord8 s6270 = s6254 ? s6268 : s6269;-  const SBool  s6271 = (SBool) ((s3973 >> 0) & 1);-  const SBool  s6272 = false != s6271;-  const SWord8 s6273 = s6272 ? s6268 : s6269;-  const SWord8 s6274 = s3953 ? s6270 : s6273;-  const SBool  s6275 = (SBool) ((s3989 >> 0) & 1);-  const SBool  s6276 = false != s6275;-  const SBool  s6277 = (SBool) ((s3982 >> 0) & 1);-  const SBool  s6278 = false != s6277;-  const SWord8 s6279 = s6278 ? s6264 : s6265;-  const SWord8 s6280 = (s6279 >> 1) | (s6279 << 7);-  const SWord8 s6281 = 128 | s6280;-  const SWord8 s6282 = 127 & s6280;-  const SWord8 s6283 = s6276 ? s6281 : s6282;-  const SBool  s6284 = (SBool) ((s3994 >> 0) & 1);-  const SBool  s6285 = false != s6284;-  const SWord8 s6286 = s6285 ? s6281 : s6282;-  const SWord8 s6287 = s3953 ? s6283 : s6286;-  const SWord8 s6288 = s3826 ? s6274 : s6287;-  const SBool  s6289 = (SBool) ((s4015 >> 0) & 1);-  const SBool  s6290 = false != s6289;-  const SBool  s6291 = (SBool) ((s4011 >> 0) & 1);-  const SBool  s6292 = false != s6291;-  const SBool  s6293 = (SBool) ((s4004 >> 0) & 1);-  const SBool  s6294 = false != s6293;-  const SWord8 s6295 = s6294 ? s6260 : s6261;-  const SWord8 s6296 = (s6295 >> 1) | (s6295 << 7);-  const SWord8 s6297 = 128 | s6296;-  const SWord8 s6298 = 127 & s6296;-  const SWord8 s6299 = s6292 ? s6297 : s6298;-  const SWord8 s6300 = (s6299 >> 1) | (s6299 << 7);-  const SWord8 s6301 = 128 | s6300;-  const SWord8 s6302 = 127 & s6300;-  const SWord8 s6303 = s6290 ? s6301 : s6302;-  const SBool  s6304 = (SBool) ((s4020 >> 0) & 1);-  const SBool  s6305 = false != s6304;-  const SWord8 s6306 = s6305 ? s6301 : s6302;-  const SWord8 s6307 = s3953 ? s6303 : s6306;-  const SBool  s6308 = (SBool) ((s4036 >> 0) & 1);-  const SBool  s6309 = false != s6308;-  const SBool  s6310 = (SBool) ((s4029 >> 0) & 1);-  const SBool  s6311 = false != s6310;-  const SWord8 s6312 = s6311 ? s6297 : s6298;-  const SWord8 s6313 = (s6312 >> 1) | (s6312 << 7);-  const SWord8 s6314 = 128 | s6313;-  const SWord8 s6315 = 127 & s6313;-  const SWord8 s6316 = s6309 ? s6314 : s6315;-  const SBool  s6317 = (SBool) ((s4041 >> 0) & 1);-  const SBool  s6318 = false != s6317;-  const SWord8 s6319 = s6318 ? s6314 : s6315;-  const SWord8 s6320 = s3953 ? s6316 : s6319;-  const SWord8 s6321 = s3826 ? s6307 : s6320;-  const SWord8 s6322 = s3571 ? s6288 : s6321;-  const SWord8 s6323 = s3060 ? s6252 : s6322;-  const SWord8 s6324 = s2042 ? s6182 : s6323;-  const SWord8 s6325 = s16 ? s6041 : s6324;-  const SWord8 s6326 = s11 ? s5758 : s6325;-  const SWord8 s6327 = s5 ? s5191 : s6326;--  *hi = s4056;-  *lo = s6327;-}-== END: "legatoMult.c" ==================
− SBVUnitTest/GoldFiles/merge.gold 
@@ -1,156 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for merge. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: merge_driver--merge.o: merge.c merge.h-	${CC} ${CCFLAGS} -c $< -o $@--merge_driver.o: merge_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--merge_driver: merge.o merge_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f merge_driver-== END: "Makefile" ==================-== BEGIN: "merge.h" ================-/* Header file for merge. Automatically generated by SBV. Do not edit! */--#ifndef __merge__HEADER_INCLUDED__-#define __merge__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-void merge(const SWord8 *xs, SWord8 *ys);--#endif /* __merge__HEADER_INCLUDED__ */-== END: "merge.h" ==================-== BEGIN: "merge_driver.c" ================-/* Example driver program for merge. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "merge.h"--int main(void)-{-  const SWord8 xs[5] = {-      10,  6,  4, 82, 71-  };--  printf("Contents of input array xs:\n");-  int xs_ctr;-  for(xs_ctr = 0; xs_ctr < 5 ; ++xs_ctr)-    printf("  xs[%d] = %"PRIu8"\n", xs_ctr ,xs[xs_ctr]);--  SWord8 ys[5];--  merge(xs, ys);--  printf("merge(xs, ys) ->\n");-  int ys_ctr;-  for(ys_ctr = 0; ys_ctr < 5 ; ++ys_ctr)-    printf("  ys[%d] = %"PRIu8"\n", ys_ctr ,ys[ys_ctr]);--  return 0;-}-== END: "merge_driver.c" ==================-== BEGIN: "merge.c" ================-/* File: "merge.c". Automatically generated by SBV. Do not edit! */--#include "merge.h"--void merge(const SWord8 *xs, SWord8 *ys)-{-  const SWord8 s0 = xs[0];-  const SWord8 s1 = xs[1];-  const SWord8 s2 = xs[2];-  const SWord8 s3 = xs[3];-  const SWord8 s4 = xs[4];-  const SBool  s5 = s0 < s1;-  const SWord8 s6 = s5 ? s0 : s1;-  const SBool  s7 = s3 < s4;-  const SWord8 s8 = s7 ? s3 : s4;-  const SBool  s9 = s2 < s8;-  const SWord8 s10 = s9 ? s2 : s8;-  const SBool  s11 = s6 < s10;-  const SWord8 s12 = s11 ? s6 : s10;-  const SWord8 s13 = s5 ? s1 : s0;-  const SBool  s14 = s13 < s10;-  const SWord8 s15 = s14 ? s13 : s10;-  const SWord8 s16 = s7 ? s4 : s3;-  const SBool  s17 = s2 < s16;-  const SWord8 s18 = s17 ? s2 : s16;-  const SWord8 s19 = s9 ? s8 : s18;-  const SBool  s20 = s6 < s19;-  const SWord8 s21 = s20 ? s6 : s19;-  const SWord8 s22 = s11 ? s15 : s21;-  const SBool  s23 = s13 < s19;-  const SWord8 s24 = s23 ? s13 : s19;-  const SWord8 s25 = s14 ? s10 : s24;-  const SWord8 s26 = s17 ? s16 : s2;-  const SWord8 s27 = s9 ? s16 : s26;-  const SBool  s28 = s6 < s27;-  const SWord8 s29 = s28 ? s6 : s27;-  const SWord8 s30 = s20 ? s24 : s29;-  const SWord8 s31 = s11 ? s25 : s30;-  const SBool  s32 = s13 < s27;-  const SWord8 s33 = s32 ? s13 : s27;-  const SWord8 s34 = s23 ? s19 : s33;-  const SWord8 s35 = s14 ? s19 : s34;-  const SWord8 s36 = s28 ? s33 : s6;-  const SWord8 s37 = s20 ? s34 : s36;-  const SWord8 s38 = s11 ? s35 : s37;-  const SWord8 s39 = s32 ? s27 : s13;-  const SWord8 s40 = s23 ? s27 : s39;-  const SWord8 s41 = s14 ? s27 : s40;-  const SWord8 s42 = s28 ? s39 : s13;-  const SWord8 s43 = s20 ? s40 : s42;-  const SWord8 s44 = s11 ? s41 : s43;--  ys[0] = s12;-  ys[1] = s22;-  ys[2] = s31;-  ys[3] = s38;-  ys[4] = s44;-}-== END: "merge.c" ==================
− SBVUnitTest/GoldFiles/popCount1.gold 
@@ -1,138 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for popCount. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: popCount_driver--popCount.o: popCount.c popCount.h-	${CC} ${CCFLAGS} -c $< -o $@--popCount_driver.o: popCount_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--popCount_driver: popCount.o popCount_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f popCount_driver-== END: "Makefile" ==================-== BEGIN: "popCount.h" ================-/* Header file for popCount. Automatically generated by SBV. Do not edit! */--#ifndef __popCount__HEADER_INCLUDED__-#define __popCount__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-SWord8 popCount(const SWord64 x);--#endif /* __popCount__HEADER_INCLUDED__ */-== END: "popCount.h" ==================-== BEGIN: "popCount_driver.c" ================-/* Example driver program for popCount. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "popCount.h"--int main(void)-{-  const SWord8 __result = popCount(0x0123456789abcdefULL);--  printf("popCount(0x0123456789abcdefULL) = %"PRIu8"\n", __result);--  return 0;-}-== END: "popCount_driver.c" ==================-== BEGIN: "popCount.c" ================-/* File: "popCount.c". Automatically generated by SBV. Do not edit! */--#include "popCount.h"--SWord8 popCount(const SWord64 x)-{-  const SWord64 s0 = x;-  static const SWord8 table0[] = {-      0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3,-      3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4,-      3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2,-      2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5,-      3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5,-      5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3,-      2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4,-      4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,-      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4,-      4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6,-      5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5,-      5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8-  };-  const SWord64 s11 = s0 & 0x00000000000000ffULL;-  const SWord8  s12 = table0[s11];-  const SWord64 s13 = s0 >> 8;-  const SWord64 s14 = 0x00000000000000ffULL & s13;-  const SWord8  s15 = table0[s14];-  const SWord8  s16 = s12 + s15;-  const SWord64 s17 = s13 >> 8;-  const SWord64 s18 = 0x00000000000000ffULL & s17;-  const SWord8  s19 = table0[s18];-  const SWord8  s20 = s16 + s19;-  const SWord64 s21 = s17 >> 8;-  const SWord64 s22 = 0x00000000000000ffULL & s21;-  const SWord8  s23 = table0[s22];-  const SWord8  s24 = s20 + s23;-  const SWord64 s25 = s21 >> 8;-  const SWord64 s26 = 0x00000000000000ffULL & s25;-  const SWord8  s27 = table0[s26];-  const SWord8  s28 = s24 + s27;-  const SWord64 s29 = s25 >> 8;-  const SWord64 s30 = 0x00000000000000ffULL & s29;-  const SWord8  s31 = table0[s30];-  const SWord8  s32 = s28 + s31;-  const SWord64 s33 = s29 >> 8;-  const SWord64 s34 = 0x00000000000000ffULL & s33;-  const SWord8  s35 = table0[s34];-  const SWord8  s36 = s32 + s35;-  const SWord64 s37 = s33 >> 8;-  const SWord64 s38 = 0x00000000000000ffULL & s37;-  const SWord8  s39 = table0[s38];-  const SWord8  s40 = s36 + s39;--  return s40;-}-== END: "popCount.c" ==================
− SBVUnitTest/GoldFiles/popCount2.gold 
@@ -1,138 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for popCount. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: popCount_driver--popCount.o: popCount.c popCount.h-	${CC} ${CCFLAGS} -c $< -o $@--popCount_driver.o: popCount_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--popCount_driver: popCount.o popCount_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f popCount_driver-== END: "Makefile" ==================-== BEGIN: "popCount.h" ================-/* Header file for popCount. Automatically generated by SBV. Do not edit! */--#ifndef __popCount__HEADER_INCLUDED__-#define __popCount__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-SWord8 popCount(const SWord64 x);--#endif /* __popCount__HEADER_INCLUDED__ */-== END: "popCount.h" ==================-== BEGIN: "popCount_driver.c" ================-/* Example driver program for popCount. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "popCount.h"--int main(void)-{-  const SWord8 __result = popCount(0x0123456789abcdefULL);--  printf("popCount(0x0123456789abcdefULL) = %"PRIu8"\n", __result);--  return 0;-}-== END: "popCount_driver.c" ==================-== BEGIN: "popCount.c" ================-/* File: "popCount.c". Automatically generated by SBV. Do not edit! */--#include "popCount.h"--SWord8 popCount(const SWord64 x)-{-  const SWord64 s0 = x;-  static const SWord8 table0[] = {-      0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3,-      3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4,-      3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2,-      2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5,-      3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5,-      5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3,-      2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4,-      4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,-      3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4,-      4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6,-      5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5,-      5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8-  };-  const SWord64 s11 = s0 & 0x00000000000000ffULL;-  const SWord8  s12 = s11 >= 256 ? 0 : table0[s11];-  const SWord64 s13 = s0 >> 8;-  const SWord64 s14 = 0x00000000000000ffULL & s13;-  const SWord8  s15 = s14 >= 256 ? 0 : table0[s14];-  const SWord8  s16 = s12 + s15;-  const SWord64 s17 = s13 >> 8;-  const SWord64 s18 = 0x00000000000000ffULL & s17;-  const SWord8  s19 = s18 >= 256 ? 0 : table0[s18];-  const SWord8  s20 = s16 + s19;-  const SWord64 s21 = s17 >> 8;-  const SWord64 s22 = 0x00000000000000ffULL & s21;-  const SWord8  s23 = s22 >= 256 ? 0 : table0[s22];-  const SWord8  s24 = s20 + s23;-  const SWord64 s25 = s21 >> 8;-  const SWord64 s26 = 0x00000000000000ffULL & s25;-  const SWord8  s27 = s26 >= 256 ? 0 : table0[s26];-  const SWord8  s28 = s24 + s27;-  const SWord64 s29 = s25 >> 8;-  const SWord64 s30 = 0x00000000000000ffULL & s29;-  const SWord8  s31 = s30 >= 256 ? 0 : table0[s30];-  const SWord8  s32 = s28 + s31;-  const SWord64 s33 = s29 >> 8;-  const SWord64 s34 = 0x00000000000000ffULL & s33;-  const SWord8  s35 = s34 >= 256 ? 0 : table0[s34];-  const SWord8  s36 = s32 + s35;-  const SWord64 s37 = s33 >> 8;-  const SWord64 s38 = 0x00000000000000ffULL & s37;-  const SWord8  s39 = s38 >= 256 ? 0 : table0[s38];-  const SWord8  s40 = s36 + s39;--  return s40;-}-== END: "popCount.c" ==================
− SBVUnitTest/GoldFiles/selChecked.gold 
@@ -1,99 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for selChecked. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: selChecked_driver--selChecked.o: selChecked.c selChecked.h-	${CC} ${CCFLAGS} -c $< -o $@--selChecked_driver.o: selChecked_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--selChecked_driver: selChecked.o selChecked_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f selChecked_driver-== END: "Makefile" ==================-== BEGIN: "selChecked.h" ================-/* Header file for selChecked. Automatically generated by SBV. Do not edit! */--#ifndef __selChecked__HEADER_INCLUDED__-#define __selChecked__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-SWord8 selChecked(const SWord8 x);--#endif /* __selChecked__HEADER_INCLUDED__ */-== END: "selChecked.h" ==================-== BEGIN: "selChecked_driver.c" ================-/* Example driver program for selChecked. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "selChecked.h"--int main(void)-{-  const SWord8 __result = selChecked(65);--  printf("selChecked(65) = %"PRIu8"\n", __result);--  return 0;-}-== END: "selChecked_driver.c" ==================-== BEGIN: "selChecked.c" ================-/* File: "selChecked.c". Automatically generated by SBV. Do not edit! */--#include "selChecked.h"--SWord8 selChecked(const SWord8 x)-{-  const SWord8 s0 = x;-  const SWord8 s3 = s0 + 2;-  const SWord8 table0[] = {-       1, s3-  };-  const SWord8 s5 = s0 >= 2 ? 3 : table0[s0];--  return s5;-}-== END: "selChecked.c" ==================
− SBVUnitTest/GoldFiles/selUnchecked.gold 
@@ -1,99 +0,0 @@-== BEGIN: "Makefile" ================-# Makefile for selUnChecked. Automatically generated by SBV. Do not edit!--# include any user-defined .mk file in the current directory.--include *.mk--CC?=gcc-CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer--all: selUnChecked_driver--selUnChecked.o: selUnChecked.c selUnChecked.h-	${CC} ${CCFLAGS} -c $< -o $@--selUnChecked_driver.o: selUnChecked_driver.c-	${CC} ${CCFLAGS} -c $< -o $@--selUnChecked_driver: selUnChecked.o selUnChecked_driver.o-	${CC} ${CCFLAGS} $^ -o $@--clean:-	rm -f *.o--veryclean: clean-	rm -f selUnChecked_driver-== END: "Makefile" ==================-== BEGIN: "selUnChecked.h" ================-/* Header file for selUnChecked. Automatically generated by SBV. Do not edit! */--#ifndef __selUnChecked__HEADER_INCLUDED__-#define __selUnChecked__HEADER_INCLUDED__--#include <stdio.h>-#include <stdlib.h>-#include <inttypes.h>-#include <stdint.h>-#include <stdbool.h>-#include <string.h>-#include <math.h>--/* The boolean type */-typedef bool SBool;--/* The float type */-typedef float SFloat;--/* The double type */-typedef double SDouble;--/* Unsigned bit-vectors */-typedef uint8_t  SWord8 ;-typedef uint16_t SWord16;-typedef uint32_t SWord32;-typedef uint64_t SWord64;--/* Signed bit-vectors */-typedef int8_t  SInt8 ;-typedef int16_t SInt16;-typedef int32_t SInt32;-typedef int64_t SInt64;--/* Entry point prototype: */-SWord8 selUnChecked(const SWord8 x);--#endif /* __selUnChecked__HEADER_INCLUDED__ */-== END: "selUnChecked.h" ==================-== BEGIN: "selUnChecked_driver.c" ================-/* Example driver program for selUnChecked. */-/* Automatically generated by SBV. Edit as you see fit! */--#include <stdio.h>-#include "selUnChecked.h"--int main(void)-{-  const SWord8 __result = selUnChecked(65);--  printf("selUnChecked(65) = %"PRIu8"\n", __result);--  return 0;-}-== END: "selUnChecked_driver.c" ==================-== BEGIN: "selUnChecked.c" ================-/* File: "selUnChecked.c". Automatically generated by SBV. Do not edit! */--#include "selUnChecked.h"--SWord8 selUnChecked(const SWord8 x)-{-  const SWord8 s0 = x;-  const SWord8 s3 = s0 + 2;-  const SWord8 table0[] = {-       1, s3-  };-  const SWord8 s5 = table0[s0];--  return s5;-}-== END: "selUnChecked.c" ==================
− SBVUnitTest/GoldFiles/temperature.gold 
@@ -1,5 +0,0 @@-Solution #1:-  s0 = 28 :: Integer-Solution #2:-  s0 = 16 :: Integer-Found 2 different solutions.
− SBVUnitTest/SBVBasicTests.hs 
@@ -1,70 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Main--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ SBV library basic test suite; i.e., those tests that do not--- require the use of an external SMT solver.---------------------------------------------------------------------------------- Nothing needs to be changed in this file, add test cases--- appropriately to SBVUnitTest.hs file, and they will be--- picked up here automagically-module Main(main) where--import Control.Monad    (unless, when)-import System.Directory (doesDirectoryExist)-import System.Exit      (exitWith, exitSuccess, ExitCode(..))-import System.FilePath  ((</>))-import System.IO        (stderr, hPutStrLn)-import Test.HUnit       (Test(..), Counts(..), runTestText, PutText(..), showCounts)--import Data.Version     (showVersion)-import SBVTest          (SBVTestSuite(..), generateGoldCheck)-import Paths_sbv        (getDataDir, version)--import SBVTestCollection    (allTestCases)--testCollection :: [(String, SBVTestSuite)]-testCollection = [(n, s) | (n, False, s) <- allTestCases]--main :: IO ()-main = do putStrLn $ "*** SBVBasicTester, version: " ++ showVersion version-          d <- getDataDir -          run $ d </> "SBVUnitTest" </> "GoldFiles"--checkGoldDir :: FilePath -> IO ()-checkGoldDir gd = do e <- doesDirectoryExist gd-                     unless e $ do putStrLn "*** Cannot locate gold file repository!"-                                   putStrLn "*** Please call with one argument, the directory name of the gold files."-                                   putStrLn "*** Cannot run test cases, exiting."-                                   exitWith $ ExitFailure 1--run :: FilePath -> IO ()-run gd = do putStrLn $ "*** Starting SBV basic tests..\n*** Gold files at: " ++ show gd-            checkGoldDir gd-            let collections = map (mkTst . snd) testCollection-                cNames      = map fst testCollection-            putStrLn $ "*** Running " ++ show (length collections) ++ " test categories."-            runEach 1 (zip cNames collections)-  where runEach :: Int -> [(String, Test)] -> IO ()-        runEach _ []            = exitSuccess-        runEach i ((n, tc):tcs) = do putStrLn $ "Starting category: " ++ show n-                                     (cts, _) <- runTestText (PutText put ()) tc-                                     hPutStrLn stderr $ showCounts cts-                                     decide n cts-                                     runEach (i+1) tcs-        mkTst (SBVTestSuite f) = f $ generateGoldCheck gd False-        put _ _ = return--decide :: String -> Counts -> IO ()-decide cat (Counts c t e f) = do-        when (c /= t) $ putStrLn $ "*** Not all test cases were tried. (Only tested " ++ show t ++ " of " ++ show c ++ ")"-        when (e /= 0) $ putStrLn $ "*** " ++ show e ++ " (of " ++ show c ++ ") test cases in error."-        when (f /= 0) $ putStrLn $ "*** " ++ show f ++ " (of " ++ show c ++ ") test cases failed."-        if c == t && e == 0 && f == 0-           then putStrLn $ "All " ++ show c ++ " test cases in category " ++ show cat ++ " successfully passed."-           else exitWith $ ExitFailure 2
− SBVUnitTest/SBVTest.hs 
@@ -1,70 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  SBVTest--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Integration with HUnit-based test suite for SBV--------------------------------------------------------------------------------{-# LANGUAGE RankNTypes #-}-module SBVTest(-          generateGoldCheck, showsAs, ioShowsAs, mkTestSuite, SBVTestSuite(..)-        , isThm, isSat, runSAT, numberOfModels-        , module Test.HUnit-        , module Data.SBV-        ) where--import Data.SBV                (SMTConfig(..), Provable(..), isTheorem, isTheoremWith, isSatisfiable, AllSatResult(..), allSat, SymWord(free), SymArray(newArray), defaultSMTCfg)-import Data.SBV.Internals      (runSymbolic, Symbolic, Result)--import Data.Maybe              (fromJust)-import System.FilePath         ((</>))-import Test.HUnit              (Test(..), Assertion, assert, (~:), test)---- | A Test-suite, parameterized by the gold-check generator/checker-newtype SBVTestSuite = SBVTestSuite ((forall a. Show a => (IO a -> FilePath -> IO ())) -> Test)---- | Wrap over 'SBVTestSuite', avoids exporting the constructor-mkTestSuite :: ((forall a. (Show a) => IO a -> FilePath -> IO ()) -> Test) -> SBVTestSuite-mkTestSuite = SBVTestSuite---- | Checks that a particular result shows as @s@-showsAs :: Show a => a -> String -> Assertion-showsAs r s = assert $ show r == s---- | Run an IO computation and check that it's result shows as @s@-ioShowsAs :: Show a => IO a -> String -> Assertion-ioShowsAs r s = do v <- r-                   assert $ show v == s---- | Create a gold file for the test case-generateGoldCheck :: FilePath -> Bool -> (forall a. Show a => IO a -> FilePath -> IO ())-generateGoldCheck goldDir shouldCreate action goldFile-  | shouldCreate = do v <- action-                      writeFile gf (show v)-                      putStrLn $ "\nCreated Gold File: " ++ show gf-                      assert True-  | True         = do v <- action-                      g <- readFile gf-                      assert $ show v == g- where gf = goldDir </> goldFile---- | Check if a property is a theorem, no timeout-isThm :: Provable a => a -> IO Bool-isThm p = fromJust `fmap` isTheorem Nothing p---- | Check if a property is satisfiable, no timeout-isSat :: Provable a => a -> IO Bool-isSat p = fromJust `fmap` isSatisfiable Nothing p---- | Count the number of models-numberOfModels :: Provable a => a -> IO Int-numberOfModels p = do AllSatResult (_, rs) <- allSat p-                      return $ length rs---- | Symbolicly run a SAT instance using the default config-runSAT :: Symbolic a -> IO Result-runSAT = runSymbolic (True, defaultSMTCfg)
− SBVUnitTest/SBVTestCollection.hs 
@@ -1,114 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Main--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ SBV test collection--------------------------------------------------------------------------------module SBVTestCollection(allTestCases) where--import SBVTest---- To add a new collection of tests, import below and add to allTestCases variable-import qualified TestSuite.Arrays.Memory                  as T01_01(testSuite)-import qualified TestSuite.Basics.ArithNoSolver           as T02_01(testSuite)-import qualified TestSuite.Basics.ArithSolver             as T02_02(testSuite)-import qualified TestSuite.Basics.BasicTests              as T02_03(testSuite)-import qualified TestSuite.Basics.Higher                  as T02_04(testSuite)-import qualified TestSuite.Basics.Index                   as T02_05(testSuite)-import qualified TestSuite.Basics.IteTest                 as T02_06(testSuite)-import qualified TestSuite.Basics.ProofTests              as T02_07(testSuite)-import qualified TestSuite.Basics.QRem                    as T02_08(testSuite)-import qualified TestSuite.BitPrecise.BitTricks           as T03_01(testSuite)-import qualified TestSuite.BitPrecise.Legato              as T03_02(testSuite)-import qualified TestSuite.BitPrecise.MergeSort           as T03_03(testSuite)-import qualified TestSuite.BitPrecise.PrefixSum           as T03_04(testSuite)-import qualified TestSuite.CRC.CCITT                      as T04_01(testSuite)-import qualified TestSuite.CRC.CCITT_Unidir               as T04_02(testSuite)-import qualified TestSuite.CRC.GenPoly                    as T04_03(testSuite)-import qualified TestSuite.CRC.Parity                     as T04_04(testSuite)-import qualified TestSuite.CRC.USB5                       as T04_05(testSuite)-import qualified TestSuite.CodeGeneration.AddSub          as T05_01(testSuite)-import qualified TestSuite.CodeGeneration.CgTests         as T05_02(testSuite)-import qualified TestSuite.CodeGeneration.CRC_USB5        as T05_03(testSuite)-import qualified TestSuite.CodeGeneration.Fibonacci       as T05_04(testSuite)-import qualified TestSuite.CodeGeneration.Floats          as T05_05(testSuite)-import qualified TestSuite.CodeGeneration.GCD             as T05_06(testSuite)-import qualified TestSuite.CodeGeneration.PopulationCount as T05_07(testSuite)-import qualified TestSuite.CodeGeneration.Uninterpreted   as T05_08(testSuite)-import qualified TestSuite.Crypto.AES                     as T06_01(testSuite)-import qualified TestSuite.Crypto.RC4                     as T06_02(testSuite)-import qualified TestSuite.Existentials.CRCPolynomial     as T07_01(testSuite)-import qualified TestSuite.Polynomials.Polynomials        as T08_01(testSuite)-import qualified TestSuite.Puzzles.Coins                  as T09_01(testSuite)-import qualified TestSuite.Puzzles.Counts                 as T09_02(testSuite)-import qualified TestSuite.Puzzles.DogCatMouse            as T09_03(testSuite)-import qualified TestSuite.Puzzles.Euler185               as T09_04(testSuite)-import qualified TestSuite.Puzzles.MagicSquare            as T09_05(testSuite)-import qualified TestSuite.Puzzles.NQueens                as T09_06(testSuite)-import qualified TestSuite.Puzzles.PowerSet               as T09_07(testSuite)-import qualified TestSuite.Puzzles.Sudoku                 as T09_08(testSuite)-import qualified TestSuite.Puzzles.Temperature            as T09_09(testSuite)-import qualified TestSuite.Puzzles.U2Bridge               as T09_10(testSuite)-import qualified TestSuite.Uninterpreted.AUF              as T10_01(testSuite)-import qualified TestSuite.Uninterpreted.Axioms           as T10_02(testSuite)-import qualified TestSuite.Uninterpreted.Function         as T10_03(testSuite)-import qualified TestSuite.Uninterpreted.Sort             as T10_04(testSuite)-import qualified TestSuite.Uninterpreted.Uninterpreted    as T10_05(testSuite)---- Bool says whether we need a real SMT solver to run this test--- Note that it's ok to say True even if an SMT solver is *not*--- needed, but we'd like most things to be targeted False so that--- those tests can be run as part of cabal.-allTestCases :: [(String, Bool, SBVTestSuite)]-allTestCases = [-       ("mem",         True,  T01_01.testSuite)-     , ("arithCF",     False, T02_01.testSuite)-     , ("arith",       True,  T02_02.testSuite)-     , ("basic",       False, T02_03.testSuite)-     , ("higher",      True,  T02_04.testSuite)-     , ("index",       True,  T02_05.testSuite)-     , ("ite",         True,  T02_06.testSuite)-     , ("proof",       True,  T02_07.testSuite)-     , ("qrem",        True,  T02_08.testSuite)-     , ("bitTricks",   True,  T03_01.testSuite)-     , ("legato",      False, T03_02.testSuite)-     , ("mergeSort",   False, T03_03.testSuite)-     , ("prefixSum",   True,  T03_04.testSuite)-     , ("ccitt",       False, T04_01.testSuite)-     , ("ccitt2",      True,  T04_02.testSuite)-     , ("genPoly",     True,  T04_03.testSuite)-     , ("parity",      True,  T04_04.testSuite)-     , ("usb5",        True,  T04_05.testSuite)-     , ("addSub",      False, T05_01.testSuite)-     , ("cgtest",      False, T05_02.testSuite)-     , ("cgUSB5",      False, T05_03.testSuite)-     , ("fib",         False, T05_04.testSuite)-     , ("floats",      False, T05_05.testSuite)-     , ("gcd",         False, T05_06.testSuite)-     , ("popCount",    False, T05_07.testSuite)-     , ("cgUninterp",  False, T05_08.testSuite)-     , ("aes",         False, T06_01.testSuite)-     , ("rc4",         True,  T06_02.testSuite)-     , ("existPoly",   False, T07_01.testSuite)-     , ("poly",        True,  T08_01.testSuite)-     , ("coins",       False, T09_01.testSuite)-     , ("counts",      False, T09_02.testSuite)-     , ("dogCatMouse", True,  T09_03.testSuite)-     , ("euler185",    True,  T09_04.testSuite)-     , ("magicSquare", True,  T09_05.testSuite)-     , ("nQueens",     True,  T09_06.testSuite)-     , ("powerset",    True,  T09_07.testSuite)-     , ("sudoku",      True,  T09_08.testSuite)-     , ("temperature", True,  T09_09.testSuite)-     , ("u2bridge",    True,  T09_10.testSuite)-     , ("auf1",        True,  T10_01.testSuite)-     , ("unint-axms",  True,  T10_02.testSuite)-     , ("auf2",        True,  T10_03.testSuite)-     , ("unint-sort",  True,  T10_04.testSuite)-     , ("unint",       True,  T10_05.testSuite)-     ]
− SBVUnitTest/SBVUnitTest.hs 
@@ -1,106 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Main--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ SBV library unit-test program--------------------------------------------------------------------------------module Main(main) where--import Control.Monad        (unless, when)-import Data.Maybe           (isJust)-import Data.List            (isInfixOf)-import System.Directory     (doesDirectoryExist)-import System.Environment   (getArgs)-import System.Exit          (exitWith, exitSuccess, ExitCode(..))-import System.FilePath      ((</>))-import Test.HUnit           (Test(..), Counts(..), runTestTT)--import Data.Version         (showVersion)-import SBVTest              (SBVTestSuite(..), generateGoldCheck)-import Paths_sbv            (getDataDir, version)--import SBVTestCollection    (allTestCases)--main :: IO ()-main = do putStrLn $ "*** SBVUnitTester, version: " ++ showVersion version-          tgts <- getArgs-          case tgts of-            [x] | x `elem` ["-h", "--help", "-?"]-                   -> do putStrLn "Usage: SBVUnitTests [-c] [-l] [-s] [targets]" -- Not quite right, but sufficient-                         putStrLn "  -l: List all tests"-                         putStrLn "  -s: Skip constant-folding tests"-                         putStrLn "  -c: Create gold-files"-                         putStrLn "  -m: Do a wild-card match on targets"-                         putStrLn "  -i: Do an inverse wild-card match on targets"-                         putStrLn "If targets are given, run those groups; except with the -m flag which matches test names."-            ["-l"] -> showTargets-            -- undocumented really-            ("-c":ts) -> run (Nothing,     ts)   False True ["SBVUnitTest/GoldFiles"]-            ("-s":ts) -> run (Nothing,     ts)   True  False []-            ("-m":ts) -> run (Just False,  ts)   False False []-            ("-i":ts) -> run (Just True,   ts)   False False []-            _         -> run (Nothing,   tgts) False False []--checkGoldDir :: FilePath -> IO ()-checkGoldDir gd = do e <- doesDirectoryExist gd-                     unless e $ do putStrLn "*** Cannot locate gold file repository!"-                                   putStrLn "*** Please call with one argument, the directory name of the gold files."-                                   putStrLn "*** Cannot run test cases, exiting."-                                   exitWith $ ExitFailure 1--allTargets :: [String]-allTargets = [s | (s, _, _) <- allTestCases]--showTargets :: IO ()-showTargets = do putStrLn "Known test targets are:"-                 mapM_ (putStrLn . ("\t" ++))  allTargets--run :: (Maybe Bool, [String]) -> Bool -> Bool -> [String] -> IO ()-run (mbWCMatch, targets) skipCF shouldCreate [gd] =-        do mapM_ checkTgt targets-           putStrLn $ "*** Starting SBV unit tests..\n*** Gold files at: " ++ show gd-           checkGoldDir gd-           cts <- runTestTT $ TestList $ concatMap mkTst [c | (tc, needsSolver, c) <- allTestCases, select needsSolver tc]-           decide shouldCreate cts-  where mkTst (SBVTestSuite f) = pick $ f (generateGoldCheck gd shouldCreate)-          where pick :: Test -> [Test]-                pick tst = case mbWCMatch of-                             Nothing       -> [tst]-                             Just inverted -> collect tst-                              where collect (TestCase _)    = []-                                    collect (TestList ts)   = concatMap collect ts-                                    collect t@(TestLabel s _)-                                       | all (`isInfixOf` s) targets = [t | not inverted]-                                       | True                        = [t |     inverted]-        wcMode = isJust mbWCMatch-        select needsSolver tc-           | not included = False-           | shouldCreate = True-           | needsSolver  = True-           | True         = not skipCF-          where included | wcMode = True-                         | True   = null targets || tc `elem` targets-        checkTgt t | wcMode              = return ()-                   | t `elem` allTargets = return ()-                   | True                = do putStrLn $ "*** Unknown test target: " ++ show t-                                              exitWith $ ExitFailure 1-run targets skipCF shouldCreate [] = getDataDir >>= \d -> run targets skipCF shouldCreate [d </> "SBVUnitTest" </> "GoldFiles"]-run _       _      _            _  = error "SBVUnitTests.run: impossible happened!"--decide :: Bool -> Counts -> IO ()-decide shouldCreate (Counts c t e f) = do-        when (c /= t) $ putStrLn $ "*** Not all test cases were tried. (Only tested " ++ show t ++ " of " ++ show c ++ ")"-        when (e /= 0) $ putStrLn $ "*** " ++ show e ++ " (of " ++ show c ++ ") test cases in error."-        when (f /= 0) $ putStrLn $ "*** " ++ show f ++ " (of " ++ show c ++ ") test cases failed."-        if c == t && e == 0 && f == 0-           then do putStrLn $ "All " ++ show c ++ " test cases "-                            ++ (if shouldCreate-                                then " executed in gold-file generation mode."-                                else " successfully passed.")-                   exitSuccess-           else exitWith $ ExitFailure 2
− SBVUnitTest/TestSuite/Arrays/Memory.hs 
@@ -1,30 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Arrays.Memory--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.Arrays.Memory--------------------------------------------------------------------------------module TestSuite.Arrays.Memory(testSuite) where--import Examples.Arrays.Memory-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-     "memory-raw"           ~: assert       =<< isThm t1-   , "memory-waw"           ~: assert       =<< isThm t2-   , "memory-wcommute-good" ~: assert       =<< isThm t3-   , "memory-wcommute-bad"  ~: assert . not =<< isThm t4-   ]-   where t1 = free "a" >>= \a -> free "x" >>= \x ->                                       newArray "m" Nothing >>= return . raw a x-         t2 = free "a" >>= \a -> free "x" >>= \x -> free "y" >>= \y ->                    newArray "m" Nothing >>= return . waw a x y-         t3 = free "a" >>= \a -> free "x" >>= \x -> free "b" >>= \b -> free "y" >>= \y -> newArray "m" Nothing >>= return . wcommutesGood (a, x) (b, y)-         t4 = free "a" >>= \a -> free "x" >>= \x -> free "b" >>= \b -> free "y" >>= \y -> newArray "m" Nothing >>= return . wcommutesBad  (a, x) (b, y)--{-# ANN module ("HLint: ignore Use fmap" :: String) #-}
− SBVUnitTest/TestSuite/Basics/ArithNoSolver.hs 
@@ -1,488 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Basics.ArithNoSolver--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for basic concrete arithmetic, i.e., testing all--- the constant folding based arithmetic implementation in SBV--------------------------------------------------------------------------------{-# LANGUAGE Rank2Types    #-}-{-# LANGUAGE TupleSections #-}--module TestSuite.Basics.ArithNoSolver(testSuite) where--import Data.SBV-import Data.SBV.Internals--import Data.Maybe(fromJust, fromMaybe)--import SBVTest-import qualified Data.Binary.IEEE754 as DB (wordToFloat, wordToDouble, floatToWord, doubleToWord)--ghcBitSize :: Bits a => a -> Int-ghcBitSize x = fromMaybe (error "SBV.ghcBitSize: Unexpected non-finite usage!") (bitSizeMaybe x)---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test $-        genReals-     ++ genFloats-     ++ genQRems-     ++ genBinTest  "+"                (+)-     ++ genBinTest  "-"                (-)-     ++ genBinTest  "*"                (*)-     ++ genUnTest   "negate"           negate-     ++ genUnTest   "abs"              abs-     ++ genUnTest   "signum"           signum-     ++ genBinTest  ".&."              (.&.)-     ++ genBinTest  ".|."              (.|.)-     ++ genBoolTest "<"                (<)  (.<)-     ++ genBoolTest "<="               (<=) (.<=)-     ++ genBoolTest ">"                (>)  (.>)-     ++ genBoolTest ">="               (>=) (.>=)-     ++ genBoolTest "=="               (==) (.==)-     ++ genBoolTest "/="               (/=) (./=)-     ++ genBinTest  "xor"              xor-     ++ genUnTest   "complement"       complement-     ++ genIntTest  "shift"            shift-     ++ genIntTest  "rotate"           rotate-     ++ genIntTestS "setBit"           setBit-     ++ genIntTestS "clearBit"         clearBit-     ++ genIntTestS "complementBit"    complementBit-     ++ genIntTest  "shift"            shift-     ++ genIntTestS "shiftL"           shiftL-     ++ genIntTestS "shiftR"           shiftR-     ++ genIntTest  "rotate"           rotate-     ++ genIntTestS "rotateL"          rotateL-     ++ genIntTestS "rotateR"          rotateR-     ++ genBlasts-     ++ genIntCasts--genBinTest :: String -> (forall a. (Num a, Bits a) => a -> a -> a) -> [Test]-genBinTest nm op = map mkTest $-        zipWith pair [(show x, show y, x `op` y) | x <- w8s,  y <- w8s ] [x `op` y | x <- sw8s,  y <- sw8s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- w16s, y <- w16s] [x `op` y | x <- sw16s, y <- sw16s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- w32s, y <- w32s] [x `op` y | x <- sw32s, y <- sw32s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- w64s, y <- w64s] [x `op` y | x <- sw64s, y <- sw64s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- i8s,  y <- i8s ] [x `op` y | x <- si8s,  y <- si8s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- i16s, y <- i16s] [x `op` y | x <- si16s, y <- si16s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- i32s, y <- i32s] [x `op` y | x <- si32s, y <- si32s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- i64s, y <- i64s] [x `op` y | x <- si64s, y <- si64s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- iUBs, y <- iUBs] [x `op` y | x <- siUBs, y <- siUBs]-  where pair (x, y, a) b   = (x, y, show (fromIntegral a `asTypeOf` b) == show b)-        mkTest (x, y, s) = "arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y  ~: s `showsAs` "True"--genBoolTest :: String -> (forall a. Ord a => a -> a -> Bool) -> (forall a. OrdSymbolic a => a -> a -> SBool) -> [Test]-genBoolTest nm op opS = map mkTest $-        zipWith pair [(show x, show y, x `op` y) | x <- w8s,  y <- w8s ] [x `opS` y | x <- sw8s,  y <- sw8s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- w16s, y <- w16s] [x `opS` y | x <- sw16s, y <- sw16s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- w32s, y <- w32s] [x `opS` y | x <- sw32s, y <- sw32s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- w64s, y <- w64s] [x `opS` y | x <- sw64s, y <- sw64s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- i8s,  y <- i8s ] [x `opS` y | x <- si8s,  y <- si8s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- i16s, y <- i16s] [x `opS` y | x <- si16s, y <- si16s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- i32s, y <- i32s] [x `opS` y | x <- si32s, y <- si32s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- i64s, y <- i64s] [x `opS` y | x <- si64s, y <- si64s]-     ++ zipWith pair [(show x, show y, x `op` y) | x <- iUBs, y <- iUBs] [x `opS` y | x <- siUBs, y <- siUBs]-  where pair (x, y, a) b   = (x, y, Just a == unliteral b)-        mkTest (x, y, s) = "arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y  ~: s `showsAs` "True"--genUnTest :: String -> (forall a. (Num a, Bits a) => a -> a) -> [Test]-genUnTest nm op = map mkTest $-        zipWith pair [(show x, op x) | x <- w8s ] [op x | x <- sw8s ]-     ++ zipWith pair [(show x, op x) | x <- w16s] [op x | x <- sw16s]-     ++ zipWith pair [(show x, op x) | x <- w32s] [op x | x <- sw32s]-     ++ zipWith pair [(show x, op x) | x <- w64s] [op x | x <- sw64s]-     ++ zipWith pair [(show x, op x) | x <- i8s ] [op x | x <- si8s ]-     ++ zipWith pair [(show x, op x) | x <- i16s] [op x | x <- si16s]-     ++ zipWith pair [(show x, op x) | x <- i32s] [op x | x <- si32s]-     ++ zipWith pair [(show x, op x) | x <- i64s] [op x | x <- si64s]-     ++ zipWith pair [(show x, op x) | x <- iUBs] [op x | x <- siUBs]-  where pair (x, a) b   = (x, show (fromIntegral a `asTypeOf` b) == show b)-        mkTest (x, s) = "arithCF-" ++ nm ++ "." ++ x ~: s `showsAs` "True"--genIntTest :: String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [Test]-genIntTest nm op = map mkTest $-        zipWith pair [("u8",  show x, show y, x `op` y) | x <- w8s,  y <- is] [x `op` y | x <- sw8s,  y <- is]-     ++ zipWith pair [("u16", show x, show y, x `op` y) | x <- w16s, y <- is] [x `op` y | x <- sw16s, y <- is]-     ++ zipWith pair [("u32", show x, show y, x `op` y) | x <- w32s, y <- is] [x `op` y | x <- sw32s, y <- is]-     ++ zipWith pair [("u64", show x, show y, x `op` y) | x <- w64s, y <- is] [x `op` y | x <- sw64s, y <- is]-     ++ zipWith pair [("s8",  show x, show y, x `op` y) | x <- i8s,  y <- is] [x `op` y | x <- si8s,  y <- is]-     ++ zipWith pair [("s16", show x, show y, x `op` y) | x <- i16s, y <- is] [x `op` y | x <- si16s, y <- is]-     ++ zipWith pair [("s32", show x, show y, x `op` y) | x <- i32s, y <- is] [x `op` y | x <- si32s, y <- is]-     ++ zipWith pair [("s64", show x, show y, x `op` y) | x <- i64s, y <- is] [x `op` y | x <- si64s, y <- is]-     ++ zipWith pair [("iUB", show x, show y, x `op` y) | x <- iUBs, y <- is] [x `op` y | x <- siUBs, y <- is]-  where pair (t, x, y, a) b       = (t, x, y, show a, show b, show (fromIntegral a `asTypeOf` b) == show b)-        mkTest (t, x, y, a, b, s) = "arithCF-" ++ nm ++ "." ++ t ++ "_" ++ x ++ "_" ++ y ++ "_" ++ a ++ "_" ++ b ~: s `showsAs` "True"-        is = [-10 .. 10]--genIntTestS :: String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [Test]-genIntTestS nm op = map mkTest $-        zipWith pair [("u8",  show x, show y, x `op` y) | x <- w8s,  y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw8s,  y <- [0 .. (ghcBitSize x - 1)]]-     ++ zipWith pair [("u16", show x, show y, x `op` y) | x <- w16s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw16s, y <- [0 .. (ghcBitSize x - 1)]]-     ++ zipWith pair [("u32", show x, show y, x `op` y) | x <- w32s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw32s, y <- [0 .. (ghcBitSize x - 1)]]-     ++ zipWith pair [("u64", show x, show y, x `op` y) | x <- w64s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- sw64s, y <- [0 .. (ghcBitSize x - 1)]]-     ++ zipWith pair [("s8",  show x, show y, x `op` y) | x <- i8s,  y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si8s,  y <- [0 .. (ghcBitSize x - 1)]]-     ++ zipWith pair [("s16", show x, show y, x `op` y) | x <- i16s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si16s, y <- [0 .. (ghcBitSize x - 1)]]-     ++ zipWith pair [("s32", show x, show y, x `op` y) | x <- i32s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si32s, y <- [0 .. (ghcBitSize x - 1)]]-     ++ zipWith pair [("s64", show x, show y, x `op` y) | x <- i64s, y <- [0 .. (ghcBitSize x - 1)]] [x `op` y | x <- si64s, y <- [0 .. (ghcBitSize x - 1)]]-     ++ zipWith pair [("iUB", show x, show y, x `op` y) | x <- iUBs, y <- [0 .. 10]]              [x `op` y | x <- siUBs, y <- [0 .. 10             ]]-  where pair (t, x, y, a) b       = (t, x, y, show a, show b, show (fromIntegral a `asTypeOf` b) == show b)-        mkTest (t, x, y, a, b, s) = "arithCF-" ++ nm ++ "." ++ t ++ "_" ++ x ++ "_" ++ y ++ "_" ++ a ++ "_" ++ b ~: s `showsAs` "True"--genBlasts :: [Test]-genBlasts = map mkTest $-             [(show x, fromBitsLE (blastLE x) .== x) | x <- sw8s ]-          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw8s ]-          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si8s ]-          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si8s ]-          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- sw16s]-          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw16s]-          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si16s]-          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si16s]-          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- sw32s]-          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw32s]-          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si32s]-          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si32s]-          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- sw64s]-          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- sw64s]-          ++ [(show x, fromBitsLE (blastLE x) .== x) | x <- si64s]-          ++ [(show x, fromBitsBE (blastBE x) .== x) | x <- si64s]-  where mkTest (x, r) = "blast-" ++ x ~: r `showsAs` "True"--genIntCasts :: [Test]-genIntCasts = map mkTest $  cast w8s ++ cast w16s ++ cast w32s ++ cast w64s-                         ++ cast i8s ++ cast i16s ++ cast i32s ++ cast i64s-                         ++ cast iUBs-   where mkTest (x, r) = "intCast-" ++ x ~: r `showsAs` "True"-         lhs x = sFromIntegral (literal x)-         rhs x = literal (fromIntegral x)-         cast :: forall a. (Show a, Integral a, SymWord a) => [a] -> [(String, SBool)]-         cast xs = toWords xs ++ toInts xs-         toWords xs =  [(show x, lhs x .== (rhs x :: SWord8 ))  | x <- xs]-                    ++ [(show x, lhs x .== (rhs x :: SWord16))  | x <- xs]-                    ++ [(show x, lhs x .== (rhs x :: SWord32))  | x <- xs]-                    ++ [(show x, lhs x .== (rhs x :: SWord64))  | x <- xs]-         toInts  xs =  [(show x, lhs x .== (rhs x :: SInt8 ))   | x <- xs]-                    ++ [(show x, lhs x .== (rhs x :: SInt16))   | x <- xs]-                    ++ [(show x, lhs x .== (rhs x :: SInt32))   | x <- xs]-                    ++ [(show x, lhs x .== (rhs x :: SInt64))   | x <- xs]-                    ++ [(show x, lhs x .== (rhs x :: SInteger)) | x <- xs]--genQRems :: [Test]-genQRems = map mkTest $-        zipWith pair [("divMod",  show x, show y, x `divMod0`  y) | x <- w8s,  y <- w8s ] [x `sDivMod`  y | x <- sw8s,  y <- sw8s ]-     ++ zipWith pair [("divMod",  show x, show y, x `divMod0`  y) | x <- w16s, y <- w16s] [x `sDivMod`  y | x <- sw16s, y <- sw16s]-     ++ zipWith pair [("divMod",  show x, show y, x `divMod0`  y) | x <- w32s, y <- w32s] [x `sDivMod`  y | x <- sw32s, y <- sw32s]-     ++ zipWith pair [("divMod",  show x, show y, x `divMod0`  y) | x <- w64s, y <- w64s] [x `sDivMod`  y | x <- sw64s, y <- sw64s]-     ++ zipWith pair [("divMod",  show x, show y, x `divMod1`  y) | x <- i8s,  y <- i8s ] [x `sDivMod`  y | x <- si8s,  y <- si8s ]-     ++ zipWith pair [("divMod",  show x, show y, x `divMod1`  y) | x <- i16s, y <- i16s] [x `sDivMod`  y | x <- si16s, y <- si16s]-     ++ zipWith pair [("divMod",  show x, show y, x `divMod1`  y) | x <- i32s, y <- i32s] [x `sDivMod`  y | x <- si32s, y <- si32s]-     ++ zipWith pair [("divMod",  show x, show y, x `divMod1`  y) | x <- i64s, y <- i64s] [x `sDivMod`  y | x <- si64s, y <- si64s]-     ++ zipWith pair [("divMod",  show x, show y, x `divMod0`  y) | x <- iUBs, y <- iUBs] [x `sDivMod`  y | x <- siUBs, y <- siUBs]-     ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w8s,  y <- w8s ] [x `sQuotRem` y | x <- sw8s,  y <- sw8s ]-     ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w16s, y <- w16s] [x `sQuotRem` y | x <- sw16s, y <- sw16s]-     ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w32s, y <- w32s] [x `sQuotRem` y | x <- sw32s, y <- sw32s]-     ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- w64s, y <- w64s] [x `sQuotRem` y | x <- sw64s, y <- sw64s]-     ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i8s,  y <- i8s ] [x `sQuotRem` y | x <- si8s,  y <- si8s ]-     ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i16s, y <- i16s] [x `sQuotRem` y | x <- si16s, y <- si16s]-     ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i32s, y <- i32s] [x `sQuotRem` y | x <- si32s, y <- si32s]-     ++ zipWith pair [("quotRem", show x, show y, x `quotRem1` y) | x <- i64s, y <- i64s] [x `sQuotRem` y | x <- si64s, y <- si64s]-     ++ zipWith pair [("quotRem", show x, show y, x `quotRem0` y) | x <- iUBs, y <- iUBs] [x `sQuotRem` y | x <- siUBs, y <- siUBs]-  where pair (nm, x, y, (r1, r2)) (e1, e2)   = (nm, x, y, show (fromIntegral r1 `asTypeOf` e1, fromIntegral r2 `asTypeOf` e2) == show (e1, e2))-        mkTest (nm, x, y, s) = "arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y  ~: s `showsAs` "True"-        -- Haskell's divMod and quotRem differs from SBV's in two ways:-        --     - when y is 0, Haskell throws an exception, SBV sets the result to 0; like in division-        --     - Haskell overflows if x == minBound and y == -1 for bounded signed types; but SBV returns minBound, 0; which is more meaningful-        -- NB. There was a ticket filed against the second anomaly above, See: https://ghc.haskell.org/trac/ghc/ticket/8695-        -- But the Haskell folks decided not to fix it. Sigh..-        overflow x y = x == minBound && y == -1-        divMod0  x y = if y == 0       then (0, x) else x `divMod`   y-        divMod1  x y = if overflow x y then (x, 0) else x `divMod0`  y-        quotRem0 x y = if y == 0       then (0, x) else x `quotRem`  y-        quotRem1 x y = if overflow x y then (x, 0) else x `quotRem0` y--genReals :: [Test]-genReals = map mkTest $-        map ("+",)  (zipWith pair [(show x, show y, x +  y) | x <- rs, y <- rs        ] [x +   y | x <- srs,  y <- srs                       ])-     ++ map ("-",)  (zipWith pair [(show x, show y, x -  y) | x <- rs, y <- rs        ] [x -   y | x <- srs,  y <- srs                       ])-     ++ map ("*",)  (zipWith pair [(show x, show y, x *  y) | x <- rs, y <- rs        ] [x *   y | x <- srs,  y <- srs                       ])-     ++ map ("<",)  (zipWith pair [(show x, show y, x <  y) | x <- rs, y <- rs        ] [x .<  y | x <- srs,  y <- srs                       ])-     ++ map ("<=",) (zipWith pair [(show x, show y, x <= y) | x <- rs, y <- rs        ] [x .<= y | x <- srs,  y <- srs                       ])-     ++ map (">",)  (zipWith pair [(show x, show y, x >  y) | x <- rs, y <- rs        ] [x .>  y | x <- srs,  y <- srs                       ])-     ++ map (">=",) (zipWith pair [(show x, show y, x >= y) | x <- rs, y <- rs        ] [x .>= y | x <- srs,  y <- srs                       ])-     ++ map ("==",) (zipWith pair [(show x, show y, x == y) | x <- rs, y <- rs        ] [x .== y | x <- srs,  y <- srs                       ])-     ++ map ("/=",) (zipWith pair [(show x, show y, x /= y) | x <- rs, y <- rs        ] [x ./= y | x <- srs,  y <- srs                       ])-     ++ map ("/",)  (zipWith pair [(show x, show y, x /  y) | x <- rs, y <- rs, y /= 0] [x / y   | x <- srs,  y <- srs, unliteral y /= Just 0])-  where pair (x, y, a) b   = (x, y, Just a == unliteral b)-        mkTest (nm, (x, y, s)) = "arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y  ~: s `showsAs` "True"--genFloats :: [Test]-genFloats = bTests ++ uTests ++ fpTests1 ++ fpTests2 ++ converts-  where bTests = map mkTest2 $  floatRun2  "+"  (+)  (+)   comb-                             ++ doubleRun2 "+"  (+)  (+)   comb--                             ++ floatRun2  "-"  (-)  (-)   comb-                             ++ doubleRun2 "-"  (-)  (-)   comb--                             ++ floatRun2  "*"  (*)  (*)   comb-                             ++ doubleRun2 "*"  (*)  (*)   comb--                             ++ floatRun2  "/"  (/)  (/)   comb-                             ++ doubleRun2 "/"  (/)  (/)   comb--                             ++ floatRun2  "<"  (<)  (.<)  combB-                             ++ doubleRun2 "<"  (<)  (.<)  combB--                             ++ floatRun2  "<=" (<=) (.<=) combB-                             ++ doubleRun2 "<=" (<=) (.<=) combB--                             ++ floatRun2  ">"  (>)  (.>)  combB-                             ++ doubleRun2 ">"  (>)  (.>)  combB--                             ++ floatRun2  ">=" (>=) (.>=) combB-                             ++ doubleRun2 ">=" (>=) (.>=) combB--                             ++ floatRun2  "==" (==) (.==) combB-                             ++ doubleRun2 "==" (==) (.==) combB--                             ++ floatRun2  "/=" (/=) (./=) combN-                             ++ doubleRun2 "/=" (/=) (./=) combN--        fpTests1 = map mkTest1 $  floatRun1   "abs"               abs                abs               comb1-                               ++ floatRun1   "fpAbs"             abs                fpAbs             comb1-                               ++ doubleRun1  "abs"               abs                abs               comb1-                               ++ doubleRun1  "fpAbs"             abs                fpAbs             comb1--                               ++ floatRun1   "negate"            negate             negate            comb1-                               ++ floatRun1   "fpNeg"             negate             fpNeg             comb1-                               ++ doubleRun1  "negate"            negate             negate            comb1-                               ++ doubleRun1  "fpNeg"             negate             fpNeg             comb1--                               ++ floatRun1M  "fpSqrt"            sqrt               fpSqrt            comb1-                               ++ doubleRun1M "fpSqrt"            sqrt               fpSqrt            comb1--                               ++ floatRun1M  "fpRoundToIntegral" fpRoundToIntegralH fpRoundToIntegral comb1-                               ++ doubleRun1M "fpRoundToIntegral" fpRoundToIntegralH fpRoundToIntegral comb1--                               ++ floatRun1   "signum"            signum             signum            comb1-                               ++ doubleRun1  "signum"            signum             signum            comb1--        -- TODO. Can't possibly test fma, unless we FFI out to C. Leave it out for the time being-        fpTests2 = map mkTest2 $  floatRun2M  "fpAdd"           (+)              fpAdd           comb-                               ++ doubleRun2M "fpAdd"           (+)              fpAdd           comb--                               ++ floatRun2M  "fpSub"           (-)              fpSub           comb-                               ++ doubleRun2M "fpSub"           (-)              fpSub           comb--                               ++ floatRun2M  "fpMul"           (*)              fpMul           comb-                               ++ doubleRun2M "fpMul"           (*)              fpMul           comb--                               ++ floatRun2M  "fpDiv"           (/)              fpDiv           comb-                               ++ doubleRun2M "fpDiv"           (/)              fpDiv           comb--                               ++ floatRunMM  "fpMin"           fpMinH           fpMin           comb-                               ++ doubleRunMM "fpMin"           fpMinH           fpMin           comb--                               ++ floatRunMM  "fpMax"           fpMaxH           fpMax           comb-                               ++ doubleRunMM "fpMax"           fpMaxH           fpMax           comb--                               ++ floatRun2   "fpRem"           fpRemH           fpRem           comb-                               ++ doubleRun2  "fpRem"           fpRemH           fpRem           comb--                               ++ floatRun2   "fpIsEqualObject" fpIsEqualObjectH fpIsEqualObject combE-                               ++ doubleRun2  "fpIsEqualObject" fpIsEqualObjectH fpIsEqualObject combE--        converts =  map cvtTest  [("toFP_Int8_ToFloat",     show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- i8s ]-                 ++ map cvtTest  [("toFP_Int16_ToFloat",    show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- i16s]-                 ++ map cvtTest  [("toFP_Int32_ToFloat",    show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- i32s]-                 ++ map cvtTest  [("toFP_Int64_ToFloat",    show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- i64s]-                 ++ map cvtTest  [("toFP_Word8_ToFloat",    show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- w8s ]-                 ++ map cvtTest  [("toFP_Word16_ToFloat",   show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- w16s]-                 ++ map cvtTest  [("toFP_Word32_ToFloat",   show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- w32s]-                 ++ map cvtTest  [("toFP_Word64_ToFloat",   show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- w64s]-                 ++ map cvtTest  [("toFP_Float_ToFloat",    show x, toSFloat  sRNE (literal x),                  literal x ) | x <- fs  ]-                 ++ map cvtTest  [("toFP_Double_ToFloat",   show x, toSFloat  sRNE (literal x),           literal (fp2fp x)) | x <- ds  ]-                 ++ map cvtTest  [("toFP_Integer_ToFloat",  show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- iUBs]-                 ++ map cvtTest  [("toFP_Real_ToFloat",     show x, toSFloat  sRNE (literal x), fromRational (toRational x)) | x <- rs  ]--                 ++ map cvtTest  [("toFP_Int8_ToDouble",    show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i8s ]-                 ++ map cvtTest  [("toFP_Int16_ToDouble",   show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i16s]-                 ++ map cvtTest  [("toFP_Int32_ToDouble",   show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i32s]-                 ++ map cvtTest  [("toFP_Int64_ToDouble",   show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- i64s]-                 ++ map cvtTest  [("toFP_Word8_ToDouble",   show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w8s ]-                 ++ map cvtTest  [("toFP_Word16_ToDouble",  show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w16s]-                 ++ map cvtTest  [("toFP_Word32_ToDouble",  show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w32s]-                 ++ map cvtTest  [("toFP_Word64_ToDouble",  show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- w64s]-                 ++ map cvtTest  [("toFP_Float_ToDouble",   show x, toSDouble sRNE (literal x),           literal (fp2fp x)) | x <- fs  ]-                 ++ map cvtTest  [("toFP_Double_ToDouble",  show x, toSDouble sRNE (literal x),                   literal x) | x <- ds  ]-                 ++ map cvtTest  [("toFP_Integer_ToDouble", show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- iUBs]-                 ++ map cvtTest  [("toFP_Real_ToDouble",    show x, toSDouble sRNE (literal x), fromRational (toRational x)) | x <- rs  ]--                 ++ map cvtTestI [("fromFP_Float_ToInt8",    show x, (fromSFloat sRNE :: SFloat -> SInt8)    (literal x), ((fromIntegral :: Integer -> SInt8)    . fpRound0) x) | x <- fs]-                 ++ map cvtTestI [("fromFP_Float_ToInt16",   show x, (fromSFloat sRNE :: SFloat -> SInt16)   (literal x), ((fromIntegral :: Integer -> SInt16)   . fpRound0) x) | x <- fs]-                 ++ map cvtTestI [("fromFP_Float_ToInt32",   show x, (fromSFloat sRNE :: SFloat -> SInt32)   (literal x), ((fromIntegral :: Integer -> SInt32)   . fpRound0) x) | x <- fs]-                 ++ map cvtTestI [("fromFP_Float_ToInt64",   show x, (fromSFloat sRNE :: SFloat -> SInt64)   (literal x), ((fromIntegral :: Integer -> SInt64)   . fpRound0) x) | x <- fs]-                 ++ map cvtTestI [("fromFP_Float_ToWord8",   show x, (fromSFloat sRNE :: SFloat -> SWord8)   (literal x), ((fromIntegral :: Integer -> SWord8)   . fpRound0) x) | x <- fs]-                 ++ map cvtTestI [("fromFP_Float_ToWord16",  show x, (fromSFloat sRNE :: SFloat -> SWord16)  (literal x), ((fromIntegral :: Integer -> SWord16)  . fpRound0) x) | x <- fs]-                 ++ map cvtTestI [("fromFP_Float_ToWord32",  show x, (fromSFloat sRNE :: SFloat -> SWord32)  (literal x), ((fromIntegral :: Integer -> SWord32)  . fpRound0) x) | x <- fs]-                 ++ map cvtTestI [("fromFP_Float_ToWord64",  show x, (fromSFloat sRNE :: SFloat -> SWord64)  (literal x), ((fromIntegral :: Integer -> SWord64)  . fpRound0) x) | x <- fs]-                 ++ map cvtTest  [("fromFP_Float_ToFloat",   show x, (fromSFloat sRNE :: SFloat -> SFloat)   (literal x),                                            literal x) | x <- fs]-                 ++ map cvtTest  [("fromFP_Float_ToDouble",  show x, (fromSFloat sRNE :: SFloat -> SDouble)  (literal x),                                 (literal .  fp2fp) x) | x <- fs]-                 ++ map cvtTestI [("fromFP_Float_ToInteger", show x, (fromSFloat sRNE :: SFloat -> SInteger) (literal x), ((fromIntegral :: Integer -> SInteger) . fpRound0) x) | x <- fs]-                 ++ map cvtTestI [("fromFP_Float_ToReal",    show x, (fromSFloat sRNE :: SFloat -> SReal)    (literal x),                          (fromRational . fpRatio0) x) | x <- fs]--                 ++ map cvtTestI [("fromFP_Double_ToInt8",    show x, (fromSDouble sRNE :: SDouble -> SInt8)    (literal x), ((fromIntegral :: Integer -> SInt8)    . fpRound0) x) | x <- ds]-                 ++ map cvtTestI [("fromFP_Double_ToInt16",   show x, (fromSDouble sRNE :: SDouble -> SInt16)   (literal x), ((fromIntegral :: Integer -> SInt16)   . fpRound0) x) | x <- ds]-                 ++ map cvtTestI [("fromFP_Double_ToInt32",   show x, (fromSDouble sRNE :: SDouble -> SInt32)   (literal x), ((fromIntegral :: Integer -> SInt32)   . fpRound0) x) | x <- ds]-                 ++ map cvtTestI [("fromFP_Double_ToInt64",   show x, (fromSDouble sRNE :: SDouble -> SInt64)   (literal x), ((fromIntegral :: Integer -> SInt64)   . fpRound0) x) | x <- ds]-                 ++ map cvtTestI [("fromFP_Double_ToWord8",   show x, (fromSDouble sRNE :: SDouble -> SWord8)   (literal x), ((fromIntegral :: Integer -> SWord8)   . fpRound0) x) | x <- ds]-                 ++ map cvtTestI [("fromFP_Double_ToWord16",  show x, (fromSDouble sRNE :: SDouble -> SWord16)  (literal x), ((fromIntegral :: Integer -> SWord16)  . fpRound0) x) | x <- ds]-                 ++ map cvtTestI [("fromFP_Double_ToWord32",  show x, (fromSDouble sRNE :: SDouble -> SWord32)  (literal x), ((fromIntegral :: Integer -> SWord32)  . fpRound0) x) | x <- ds]-                 ++ map cvtTestI [("fromFP_Double_ToWord64",  show x, (fromSDouble sRNE :: SDouble -> SWord64)  (literal x), ((fromIntegral :: Integer -> SWord64)  . fpRound0) x) | x <- ds]-                 ++ map cvtTest  [("fromFP_Double_ToFloat",   show x, (fromSDouble sRNE :: SDouble -> SFloat)   (literal x),                                (literal  .  fp2fp) x) | x <- ds]-                 ++ map cvtTest  [("fromFP_Double_ToDouble",  show x, (fromSDouble sRNE :: SDouble -> SDouble)  (literal x),                                            literal x) | x <- ds]-                 ++ map cvtTestI [("fromFP_Double_ToInteger", show x, (fromSDouble sRNE :: SDouble -> SInteger) (literal x), ((fromIntegral :: Integer -> SInteger) . fpRound0) x) | x <- ds]-                 ++ map cvtTestI [("fromFP_Double_ToReal",    show x, (fromSDouble sRNE :: SDouble -> SReal)    (literal x),                          (fromRational . fpRatio0) x) | x <- ds]--                 ++ map cvtTest  [("reinterp_Word32_Float",  show x, sWord32AsSFloat  (literal x), literal (DB.wordToFloat  x)) | x <- w32s]-                 ++ map cvtTest  [("reinterp_Word64_Double", show x, sWord64AsSDouble (literal x), literal (DB.wordToDouble x)) | x <- w64s]--                 ++ map cvtTestI [("reinterp_Float_Word32",  show x, sFloatAsSWord32  (literal x), literal (DB.floatToWord x))  | x <- fs, not (isNaN x)] -- Not unique for NaN-                 ++ map cvtTestI [("reinterp_Double_Word64", show x, sDoubleAsSWord64 (literal x), literal (DB.doubleToWord x)) | x <- ds, not (isNaN x)] -- Not unique for NaN--        floatRun1   nm f g cmb = map (nm,) [cmb (x,    f x,   extract (g                         (literal x)))             | x <- fs]-        doubleRun1  nm f g cmb = map (nm,) [cmb (x,    f x,   extract (g                         (literal x)))             | x <- ds]-        floatRun1M  nm f g cmb = map (nm,) [cmb (x,    f x,   extract (g sRNE (literal x)))                                | x <- fs]-        doubleRun1M nm f g cmb = map (nm,) [cmb (x,    f x,   extract (g sRNE (literal x)))                                | x <- ds]-        floatRun2   nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g                         (literal x) (literal y))) | x <- fs, y <- fs]-        doubleRun2  nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g                         (literal x) (literal y))) | x <- ds, y <- ds]-        floatRun2M  nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g sRNE (literal x) (literal y))) | x <- fs, y <- fs]-        doubleRun2M nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g sRNE (literal x) (literal y))) | x <- ds, y <- ds]-        floatRunMM  nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g                         (literal x) (literal y))) | x <- fs, y <- fs, not (alt0 x y || alt0 y x)]-        doubleRunMM nm f g cmb = map (nm,) [cmb (x, y, f x y, extract (g                         (literal x) (literal y))) | x <- ds, y <- ds, not (alt0 x y || alt0 y x)]-        -- fpMin/fpMax: skip +0/-0 case as this is underspecified-        alt0 x y = isNegativeZero x && y == 0 && not (isNegativeZero y)-        uTests = map mkTest1 $  concatMap (checkPred fs sfs) predicates-                             ++ concatMap (checkPred ds sds) predicates-        extract :: SymWord a => SBV a -> a-        extract = fromJust . unliteral--        comb  (x, y, a, b) = (show x, show y, same a b)-        combB (x, y, a, b) = (show x, show y, checkNaN f x y a b) where f v w = not (v || w)  -- All comparisons except /=: Both should be False if we have a NaN argument-        combN (x, y, a, b) = (show x, show y, checkNaN f x y a b) where f v w =      v && w   -- /=: Both should be True-        combE (x, y, a, b) = (show x, show y, a == b)-        comb1 (x, a, b)    = (show x, same a b)-        same a b = (isNaN a &&& isNaN b) || (a == b)-        checkNaN f x y a b-          | isNaN x || isNaN y = f a b-          | True               = a == b--        cvtTest  (nm, x, a, b)  = "arithCF-" ++ nm ++ "." ++ x ~: same (extract a) (extract b) `showsAs` "True"-        cvtTestI (nm, x, a, b)  = "arithCF-" ++ nm ++ "." ++ x ~: (a == b) `showsAs` "True"--        mkTest1 (nm, (x, s))    = "arithCF-" ++ nm ++ "." ++ x ~: s `showsAs` "True"-        mkTest2 (nm, (x, y, s)) = "arithCF-" ++ nm ++ "." ++ x ++ "_" ++ y  ~: s `showsAs` "True"--        checkPred :: Show a => [a] -> [SBV a] -> (String, SBV a -> SBool, a -> Bool) -> [(String, (String, Bool))]-        checkPred xs sxs (n, ps, p) = zipWith (chk n) (map (\x -> (x, p x)) xs) (map ps sxs)-          where chk nm (x, v) sv = (nm, (show x, Just v == unliteral sv))--        predicates :: IEEEFloating a => [(String, SBV a -> SBool, a -> Bool)]-        predicates = [ ("fpIsNormal",       fpIsNormal,        fpIsNormalizedH)-                     , ("fpIsSubnormal",    fpIsSubnormal,     isDenormalized)-                     , ("fpIsZero",         fpIsZero,          (== 0))-                     , ("fpIsInfinite",     fpIsInfinite,      isInfinite)-                     , ("fpIsNaN",          fpIsNaN,           isNaN)-                     , ("fpIsNegative",     fpIsNegative,      \x -> x < 0  ||      isNegativeZero x)-                     , ("fpIsPositive",     fpIsPositive,      \x -> x >= 0 && not (isNegativeZero x))-                     , ("fpIsNegativeZero", fpIsNegativeZero,  isNegativeZero)-                     , ("fpIsPositiveZero", fpIsPositiveZero,  \x -> x == 0 && not (isNegativeZero x))-                     , ("fpIsPoint",        fpIsPoint,         \x -> not (isNaN x || isInfinite x))-                     ]---- Concrete test data-xsUnsigned :: (Num a, Bounded a) => [a]-xsUnsigned = take 5 (iterate (1+) minBound) ++ take 5 (iterate (\x -> x-1) maxBound)--xsSigned :: (Num a, Enum a, Bounded a) => [a]-xsSigned   = xsUnsigned ++ [-5 .. 5]--w8s :: [Word8]-w8s = xsUnsigned--sw8s :: [SWord8]-sw8s = xsUnsigned--w16s :: [Word16]-w16s = xsUnsigned--sw16s :: [SWord16]-sw16s = xsUnsigned--w32s :: [Word32]-w32s = xsUnsigned--sw32s :: [SWord32]-sw32s = xsUnsigned--w64s :: [Word64]-w64s = xsUnsigned--sw64s :: [SWord64]-sw64s = xsUnsigned--i8s :: [Int8]-i8s = xsSigned--si8s :: [SInt8]-si8s = xsSigned--i16s :: [Int16]-i16s = xsSigned--si16s :: [SInt16]-si16s = xsSigned--i32s :: [Int32]-i32s = xsSigned--si32s :: [SInt32]-si32s = xsSigned--i64s :: [Int64]-i64s = xsSigned--si64s :: [SInt64]-si64s = xsSigned--iUBs :: [Integer]-iUBs = [-1000000 .. -999995] ++ [-5 .. 5] ++ [999995 ..  1000000]--siUBs :: [SInteger]-siUBs = map literal iUBs--rs :: [AlgReal]-rs = [fromRational (i % d) | i <- nums, d <- dens]- where nums = [-1000000 .. -999998] ++ [-2 .. 2] ++ [999998 ..  1000001]-       dens = [2 .. 5] ++ [98 .. 102] ++ [999998 .. 1000000]--srs :: [SReal]-srs = map literal rs--fs :: [Float]-fs = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan- where xs = [nan, infinity, 0, 0.5, 0.68302244, 0.5268265, 0.10283524, 5.8336496e-2, 1.0e-45]--sfs :: [SFloat]-sfs = map literal fs--ds :: [Double]-ds = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan- where xs = [nan, infinity, 0, 0.5, 2.516632060108026e-2, 0.8601891300751106, 7.518897767550192e-2, 1.1656043286207285e-2, 5.0e-324]--sds :: [SDouble]-sds = map literal ds
− SBVUnitTest/TestSuite/Basics/ArithSolver.hs 
@@ -1,484 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Basics.ArithSolver--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for basic non-concrete arithmetic, i.e., testing all--- basic arithmetic reasoning using an SMT solver without any--- constant folding.--------------------------------------------------------------------------------{-# LANGUAGE Rank2Types    #-}--module TestSuite.Basics.ArithSolver(testSuite) where--import Data.Maybe (fromMaybe, fromJust)-import qualified Data.Binary.IEEE754 as DB (wordToFloat, wordToDouble, floatToWord, doubleToWord)--import Data.SBV-import Data.SBV.Internals--import SBVTest--ghcBitSize :: Bits a => a -> Int-ghcBitSize x = fromMaybe (error "SBV.ghcBitSize: Unexpected non-finite usage!") (bitSizeMaybe x)---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test $-        genReals-     ++ genFloats-     ++ genDoubles-     ++ genFPConverts-     ++ genQRems-     ++ genBinTest  True   "+"                (+)-     ++ genBinTest  True   "-"                (-)-     ++ genBinTest  True   "*"                (*)-     ++ genUnTest   True   "negate"           negate-     ++ genUnTest   True   "abs"              abs-     ++ genUnTest   True   "signum"           signum-     ++ genBinTest  False  ".&."              (.&.)-     ++ genBinTest  False  ".|."              (.|.)-     ++ genBoolTest        "<"                (<)  (.<)-     ++ genBoolTest        "<="               (<=) (.<=)-     ++ genBoolTest        ">"                (>)  (.>)-     ++ genBoolTest        ">="               (>=) (.>=)-     ++ genBoolTest        "=="               (==) (.==)-     ++ genBoolTest        "/="               (/=) (./=)-     ++ genBinTest  False  "xor"              xor-     ++ genUnTest   False  "complement"       complement-     ++ genIntTest         "shift"            shift-     ++ genIntTest         "rotate"           rotate-     ++ genIntTestS False  "setBit"           setBit-     ++ genIntTestS False  "clearBit"         clearBit-     ++ genIntTestS False  "complementBit"    complementBit-     ++ genIntTest         "shift"            shift-     ++ genIntTestS True   "shiftL"           shiftL-     ++ genIntTestS True   "shiftR"           shiftR-     ++ genIntTest         "rotate"           rotate-     ++ genIntTestS True   "rotateL"          rotateL-     ++ genIntTestS True   "rotateR"          rotateR-     ++ genBlasts-     ++ genIntCasts--genBinTest :: Bool -> String -> (forall a. (Num a, Bits a) => a -> a -> a) -> [Test]-genBinTest unboundedOK nm op = map mkTest $  [(show x, show y, mkThm2 x y (x `op` y)) | x <- w8s,  y <- w8s ]-                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- w16s]-                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- w32s]-                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- w64s]-                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i8s,  y <- i8s ]-                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- i16s]-                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- i32s]-                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- i64s]-                                          ++ [(show x, show y, mkThm2 x y (x `op` y)) | unboundedOK, x <- iUBs, y <- iUBs]-  where mkTest (x, y, t) = "genBinTest.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y  ~: assert t-        mkThm2 x y r = isThm $ do [a, b] <- mapM free ["x", "y"]-                                  constrain $ a .== literal x-                                  constrain $ b .== literal y-                                  return $ literal r .== a `op` b--genBoolTest :: String -> (forall a. Ord a => a -> a -> Bool) -> (forall a. OrdSymbolic a => a -> a -> SBool) -> [Test]-genBoolTest nm op opS = map mkTest $  [(show x, show y, mkThm2 x y (x `op` y)) | x <- w8s,  y <- w8s ]-                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- w16s]-                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- w32s]-                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- w64s]-                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i8s,  y <- i8s ]-                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- i16s]-                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- i32s]-                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- i64s]-                                   ++ [(show x, show y, mkThm2 x y (x `op` y)) | x <- iUBs, y <- iUBs]-  where mkTest (x, y, t) = "genBoolTest.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y  ~: assert t-        mkThm2 x y r = isThm $ do [a, b] <- mapM free ["x", "y"]-                                  constrain $ a .== literal x-                                  constrain $ b .== literal y-                                  return $ literal r .== a `opS` b--genUnTest :: Bool -> String -> (forall a. (Num a, Bits a) => a -> a) -> [Test]-genUnTest unboundedOK nm op = map mkTest $  [(show x, mkThm x (op x)) | x <- w8s ]-                                         ++ [(show x, mkThm x (op x)) | x <- w16s]-                                         ++ [(show x, mkThm x (op x)) | x <- w32s]-                                         ++ [(show x, mkThm x (op x)) | x <- w64s]-                                         ++ [(show x, mkThm x (op x)) | x <- i8s ]-                                         ++ [(show x, mkThm x (op x)) | x <- i16s]-                                         ++ [(show x, mkThm x (op x)) | x <- i32s]-                                         ++ [(show x, mkThm x (op x)) | x <- i64s]-                                         ++ [(show x, mkThm x (op x)) | unboundedOK, x <- iUBs]-  where mkTest (x, t) = "genUnTest.arithmetic-" ++ nm ++ "." ++ x ~: assert t-        mkThm x r = isThm $ do a <- free "x"-                               constrain $ a .== literal x-                               return $ literal r .== op a--genIntTest :: String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [Test]-genIntTest nm op = map mkTest $  [("u8",  show x, show y, mkThm2 x y (x `op` y)) | x <- w8s,  y <- is]-                              ++ [("u16", show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- is]-                              ++ [("u32", show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- is]-                              ++ [("u64", show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- is]-                              ++ [("s8",  show x, show y, mkThm2 x y (x `op` y)) | x <- i8s,  y <- is]-                              ++ [("s16", show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- is]-                              ++ [("s32", show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- is]-                              ++ [("s64", show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- is]-                              ++ [("iUB", show x, show y, mkThm2 x y (x `op` y)) | x <- iUBs, y <- is]-  where mkTest (l, x, y, t) = "genIntTest.arithmetic-" ++ nm ++ "." ++ l ++ "_" ++ x ++ "_" ++ y ~: assert t-        is = [-10 .. 10]-        mkThm2 x y r = isThm $ do a <- free "x"-                                  constrain $ a .== literal x-                                  return $ literal r .== a `op` y---genIntTestS :: Bool -> String -> (forall a. (Num a, Bits a) => a -> Int -> a) -> [Test]-genIntTestS unboundedOK nm op = map mkTest $  [("u8",  show x, show y, mkThm2 x y (x `op` y)) | x <- w8s,  y <- [0 .. (ghcBitSize x - 1)]]-                                           ++ [("u16", show x, show y, mkThm2 x y (x `op` y)) | x <- w16s, y <- [0 .. (ghcBitSize x - 1)]]-                                           ++ [("u32", show x, show y, mkThm2 x y (x `op` y)) | x <- w32s, y <- [0 .. (ghcBitSize x - 1)]]-                                           ++ [("u64", show x, show y, mkThm2 x y (x `op` y)) | x <- w64s, y <- [0 .. (ghcBitSize x - 1)]]-                                           ++ [("s8",  show x, show y, mkThm2 x y (x `op` y)) | x <- i8s,  y <- [0 .. (ghcBitSize x - 1)]]-                                           ++ [("s16", show x, show y, mkThm2 x y (x `op` y)) | x <- i16s, y <- [0 .. (ghcBitSize x - 1)]]-                                           ++ [("s32", show x, show y, mkThm2 x y (x `op` y)) | x <- i32s, y <- [0 .. (ghcBitSize x - 1)]]-                                           ++ [("s64", show x, show y, mkThm2 x y (x `op` y)) | x <- i64s, y <- [0 .. (ghcBitSize x - 1)]]-                                           ++ [("iUB", show x, show y, mkThm2 x y (x `op` y)) | unboundedOK, x <- iUBs, y <- [0 .. 10]]-  where mkTest (l, x, y, t) = "genIntTestS.arithmetic-" ++ nm ++ "." ++ l ++ "_" ++ x ++ "_" ++ y ~: assert t-        mkThm2 x y r = isThm $ do a <- free "x"-                                  constrain $ a .== literal x-                                  return $ literal r .== a `op` y--genBlasts :: [Test]-genBlasts = map mkTest $  [(show x, mkThm fromBitsLE blastLE x) | x <- w8s ]-                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w8s ]-                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i8s ]-                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i8s ]-                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- w16s]-                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w16s]-                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i16s]-                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i16s]-                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- w32s]-                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w32s]-                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i32s]-                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i32s]-                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- w64s]-                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- w64s]-                       ++ [(show x, mkThm fromBitsLE blastLE x) | x <- i64s]-                       ++ [(show x, mkThm fromBitsBE blastBE x) | x <- i64s]-  where mkTest (x, t) = "genBlasts.blast-" ++ show x ~: assert t-        mkThm from to v = isThm $ do a <- free "x"-                                     constrain $ a .== literal v-                                     return $ a .== from (to a)--genIntCasts :: [Test]-genIntCasts = map mkTest $  cast w8s ++ cast w16s ++ cast w32s ++ cast w64s-                         ++ cast i8s ++ cast i16s ++ cast i32s ++ cast i64s-                         ++ cast iUBs-   where mkTest (x, t) = "sIntCast-" ++ x ~: assert t-         cast :: forall a. (Show a, Integral a, SymWord a) => [a] -> [(String, IO Bool)]-         cast xs = toWords xs ++ toInts xs-         toWords xs =  [(show x, mkThm x (fromIntegral x :: Word8 ))  | x <- xs]-                    ++ [(show x, mkThm x (fromIntegral x :: Word16))  | x <- xs]-                    ++ [(show x, mkThm x (fromIntegral x :: Word32))  | x <- xs]-                    ++ [(show x, mkThm x (fromIntegral x :: Word64))  | x <- xs]-         toInts  xs =  [(show x, mkThm x (fromIntegral x :: Int8 ))   | x <- xs]-                    ++ [(show x, mkThm x (fromIntegral x :: Int16))   | x <- xs]-                    ++ [(show x, mkThm x (fromIntegral x :: Int32))   | x <- xs]-                    ++ [(show x, mkThm x (fromIntegral x :: Int64))   | x <- xs]-                    ++ [(show x, mkThm x (fromIntegral x :: Integer)) | x <- xs]-         mkThm v res = isThm $ do a <- free "x"-                                  constrain $ a .== literal v-                                  return $ literal res .== sFromIntegral a--genReals :: [Test]-genReals = map mkTest $  [("+",  show x, show y, mkThm2 (+)   x y (x +  y)) | x <- rs, y <- rs        ]-                      ++ [("-",  show x, show y, mkThm2 (-)   x y (x -  y)) | x <- rs, y <- rs        ]-                      ++ [("*",  show x, show y, mkThm2 (*)   x y (x *  y)) | x <- rs, y <- rs        ]-                      ++ [("/",  show x, show y, mkThm2 (/)   x y (x /  y)) | x <- rs, y <- rs, y /= 0]-                      ++ [("<",  show x, show y, mkThm2 (.<)  x y (x <  y)) | x <- rs, y <- rs        ]-                      ++ [("<=", show x, show y, mkThm2 (.<=) x y (x <= y)) | x <- rs, y <- rs        ]-                      ++ [(">",  show x, show y, mkThm2 (.>)  x y (x >  y)) | x <- rs, y <- rs        ]-                      ++ [(">=", show x, show y, mkThm2 (.>=) x y (x >= y)) | x <- rs, y <- rs        ]-                      ++ [("==", show x, show y, mkThm2 (.==) x y (x == y)) | x <- rs, y <- rs        ]-                      ++ [("/=", show x, show y, mkThm2 (./=) x y (x /= y)) | x <- rs, y <- rs        ]-  where mkTest (nm, x, y, t) = "genReals.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y  ~: assert t-        mkThm2 op x y r = isThm $ do [a, b] <- mapM free ["x", "y"]-                                     constrain $ a .== literal x-                                     constrain $ b .== literal y-                                     return $ literal r .== a `op` b--genFloats :: [Test]-genFloats = genIEEE754 "genFloats" fs--genDoubles :: [Test]-genDoubles = genIEEE754 "genDoubles" ds--genIEEE754 :: (IEEEFloating a, Show a, Ord a) => String -> [a] -> [Test]-genIEEE754 origin vs =  map tst1 [("pred_"   ++ nm, x, y)    | (nm, x, y)    <- preds]-                     ++ map tst1 [("unary_"  ++ nm, x, y)    | (nm, x, y)    <- uns]-                     ++ map tst2 [("binary_" ++ nm, x, y, r) | (nm, x, y, r) <- bins]-  where uns =     [("abs",               show x, mkThm1 abs                   x  (abs x))                | x <- vs]-               ++ [("negate",            show x, mkThm1 negate                x  (negate x))             | x <- vs]-               ++ [("signum",            show x, mkThm1 signum                x  (signum x))             | x <- vs]-               ++ [("fpAbs",             show x, mkThm1 fpAbs                 x  (abs x))                | x <- vs]-               ++ [("fpNeg",             show x, mkThm1 fpNeg                 x  (negate x))             | x <- vs]-               ++ [("fpSqrt",            show x, mkThm1 (m fpSqrt)            x  (sqrt   x))             | x <- vs]-               ++ [("fpRoundToIntegral", show x, mkThm1 (m fpRoundToIntegral) x  (fpRoundToIntegralH x)) | x <- vs]--        bins =    [("+",      show x,  show y, mkThm2        (+)       x y (x +  y))   | x <- vs, y <- vs]-               ++ [("-",      show x,  show y, mkThm2        (-)       x y (x -  y))   | x <- vs, y <- vs]-               ++ [("*",      show x,  show y, mkThm2        (*)       x y (x *  y))   | x <- vs, y <- vs]-               ++ [("/",      show x,  show y, mkThm2        (/)       x y (x /  y))   | x <- vs, y <- vs]-               ++ [("<",      show x,  show y, mkThm2C False (.<)      x y (x <  y))   | x <- vs, y <- vs]-               ++ [("<=",     show x,  show y, mkThm2C False (.<=)     x y (x <= y))   | x <- vs, y <- vs]-               ++ [(">",      show x,  show y, mkThm2C False (.>)      x y (x >  y))   | x <- vs, y <- vs]-               ++ [(">=",     show x,  show y, mkThm2C False (.>=)     x y (x >= y))   | x <- vs, y <- vs]-               ++ [("==",     show x,  show y, mkThm2C False (.==)     x y (x == y))   | x <- vs, y <- vs]-               ++ [("/=",     show x,  show y, mkThm2C True  (./=)     x y (x /= y))   | x <- vs, y <- vs]-               -- TODO. Can't possibly test fma, unless we FFI out to C. Leave it out for the time being-               ++ [("fpAdd",           show x, show y, mkThm2  (m fpAdd)        x y ((+)              x y)) | x <- vs, y <- vs]-               ++ [("fpSub",           show x, show y, mkThm2  (m fpSub)        x y ((-)              x y)) | x <- vs, y <- vs]-               ++ [("fpMul",           show x, show y, mkThm2  (m fpMul)        x y ((*)              x y)) | x <- vs, y <- vs]-               ++ [("fpDiv",           show x, show y, mkThm2  (m fpDiv)        x y ((/)              x y)) | x <- vs, y <- vs]-               ++ [("fpMin",           show x, show y, mkThm2  fpMin            x y (fpMinH           x y)) | x <- vs, y <- vs, not (alt0 x y || alt0 y x)]-               ++ [("fpMax",           show x, show y, mkThm2  fpMax            x y (fpMaxH           x y)) | x <- vs, y <- vs, not (alt0 x y || alt0 y x)]-               ++ [("fpIsEqualObject", show x, show y, mkThm2P fpIsEqualObject  x y (fpIsEqualObjectH x y)) | x <- vs, y <- vs]-               ++ [("fpRem",           show x, show y, mkThm2  fpRem            x y (fpRemH           x y)) | x <- vsFPRem, y <- vsFPRem]--        -- TODO: For doubles fpRem takes too long, so we only do a subset-        vsFPRem-          | origin == "genDoubles" = [nan, infinity, 0, 0.5, -infinity, -0, -0.5]-          | True                   = vs--        -- fpMin/fpMax: skip +0/-0 case as this is underspecified-        alt0 x y = isNegativeZero x && y == 0 && not (isNegativeZero y)--        m f = f sRNE--        preds =   [(pn, show x, mkThmP ps x (pc x)) | (pn, ps, pc) <- predicates, x <- vs]-        tst2 (nm, x, y, t) = origin ++ ".arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y  ~: assert t-        tst1 (nm, x,    t) = origin ++ ".arithmetic-" ++ nm ++ "." ++ x              ~: assert t--        eqF v val-          | isNaN          val        = constrain $ fpIsNaN v-          | isNegativeZero val        = constrain $ fpIsNegativeZero v-          | val == 0                  = constrain $ fpIsPositiveZero v-          | isInfinite val && val > 0 = constrain $ fpIsInfinite v &&& fpIsPositive v-          | isInfinite val && val < 0 = constrain $ fpIsInfinite v &&& fpIsNegative v-          | True                      = constrain $ v .== literal val--        -- Quickly pick which solver to use. Currently z3 or mathSAT supports FP-        fpProver :: SMTConfig-        fpProver = z3 -- mathSAT--        fpThm :: Provable a => a -> IO Bool-        fpThm p = fromJust `fmap` isTheoremWith fpProver Nothing p--        mkThmP op x r = fpThm $ do a <- free "x"-                                   eqF a x-                                   return $ literal r .== op a--        mkThm2P op x y r = fpThm $ do [a, b] <- mapM free ["x", "y"]-                                      eqF a x-                                      eqF b y-                                      return $ literal r .== a `op` b--        mkThm1 op x r = fpThm $ do a <- free "x"-                                   eqF a x-                                   return $ literal r `fpIsEqualObject` op a--        mkThm2 op x y r = fpThm $ do [a, b] <- mapM free ["x", "y"]-                                     eqF a x-                                     eqF b y-                                     return $ literal r `fpIsEqualObject` (a `op` b)--        mkThm2C neq op x y r = fpThm $ do [a, b] <- mapM free ["x", "y"]-                                          eqF a x-                                          eqF b y-                                          return $ if isNaN x || isNaN y-                                                   then (if neq then a `op` b else bnot (a `op` b))-                                                   else literal r .== a `op` b--        predicates :: (IEEEFloating a) => [(String, SBV a -> SBool, a -> Bool)]-        predicates = [ ("fpIsNormal",       fpIsNormal,        fpIsNormalizedH)-                     , ("fpIsSubnormal",    fpIsSubnormal,     isDenormalized)-                     , ("fpIsZero",         fpIsZero,          (== 0))-                     , ("fpIsInfinite",     fpIsInfinite,      isInfinite)-                     , ("fpIsNaN",          fpIsNaN,           isNaN)-                     , ("fpIsNegative",     fpIsNegative,      \x -> x < 0  ||      isNegativeZero x)-                     , ("fpIsPositive",     fpIsPositive,      \x -> x >= 0 && not (isNegativeZero x))-                     , ("fpIsNegativeZero", fpIsNegativeZero,  isNegativeZero)-                     , ("fpIsPositiveZero", fpIsPositiveZero,  \x -> x == 0 && not (isNegativeZero x))-                     , ("fpIsPoint",        fpIsPoint,         \x -> not (isNaN x || isInfinite x))-                     ]--genFPConverts :: [Test]-genFPConverts = map tst1 [("fpCast_" ++ nm, x, y) | (nm, x, y) <- converts]-  where converts =   [("toFP_Int8_ToFloat",     show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i8s ]-                 ++  [("toFP_Int16_ToFloat",    show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i16s]-                 ++  [("toFP_Int32_ToFloat",    show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i32s]-                 ++  [("toFP_Int64_ToFloat",    show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- i64s]-                 ++  [("toFP_Word8_ToFloat",    show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w8s ]-                 ++  [("toFP_Word16_ToFloat",   show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w16s]-                 ++  [("toFP_Word32_ToFloat",   show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w32s]-                 ++  [("toFP_Word64_ToFloat",   show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- w64s]-                 ++  [("toFP_Float_ToFloat",    show x, mkThm1 (m toSFloat) x                           x  ) | x <- fs  ]-                 ++  [("toFP_Double_ToFloat",   show x, mkThm1 (m toSFloat) x (                   fp2fp x )) | x <- ds  ]-                 ++  [("toFP_Integer_ToFloat",  show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- iUBs]-                 ++  [("toFP_Real_ToFloat",     show x, mkThmC (m toSFloat) x (fromRational (toRational x))) | x <- rs  ]--                 ++  [("toFP_Int8_ToDouble",    show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i8s ]-                 ++  [("toFP_Int16_ToDouble",   show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i16s]-                 ++  [("toFP_Int32_ToDouble",   show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i32s]-                 ++  [("toFP_Int64_ToDouble",   show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- i64s]-                 ++  [("toFP_Word8_ToDouble",   show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w8s ]-                 ++  [("toFP_Word16_ToDouble",  show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w16s]-                 ++  [("toFP_Word32_ToDouble",  show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w32s]-                 ++  [("toFP_Word64_ToDouble",  show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- w64s]-                 ++  [("toFP_Float_ToDouble",   show x, mkThm1 (m toSDouble) x (                   fp2fp x )) | x <- fs  ]-                 ++  [("toFP_Double_ToDouble",  show x, mkThm1 (m toSDouble) x                           x )  | x <- ds  ]-                 ++  [("toFP_Integer_ToDouble", show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- iUBs]-                 ++  [("toFP_Real_ToDouble",    show x, mkThmC (m toSDouble) x (fromRational (toRational x))) | x <- rs  ]--                 ++  [("fromFP_Float_ToInt8",    show x, mkThmC' (m fromSFloat :: SFloat -> SInt8)    x (((fromIntegral :: Integer -> Int8)    . fpRound0) x)) | x <- fs]-                 ++  [("fromFP_Float_ToInt16",   show x, mkThmC' (m fromSFloat :: SFloat -> SInt16)   x (((fromIntegral :: Integer -> Int16)   . fpRound0) x)) | x <- fs]-                 ++  [("fromFP_Float_ToInt32",   show x, mkThmC' (m fromSFloat :: SFloat -> SInt32)   x (((fromIntegral :: Integer -> Int32)   . fpRound0) x)) | x <- fs]-                 ++  [("fromFP_Float_ToInt64",   show x, mkThmC' (m fromSFloat :: SFloat -> SInt64)   x (((fromIntegral :: Integer -> Int64)   . fpRound0) x)) | x <- fs]-                 ++  [("fromFP_Float_ToWord8",   show x, mkThmC' (m fromSFloat :: SFloat -> SWord8)   x (((fromIntegral :: Integer -> Word8)   . fpRound0) x)) | x <- fs]-                 ++  [("fromFP_Float_ToWord16",  show x, mkThmC' (m fromSFloat :: SFloat -> SWord16)  x (((fromIntegral :: Integer -> Word16)  . fpRound0) x)) | x <- fs]-                 ++  [("fromFP_Float_ToWord32",  show x, mkThmC' (m fromSFloat :: SFloat -> SWord32)  x (((fromIntegral :: Integer -> Word32)  . fpRound0) x)) | x <- fs]-                 ++  [("fromFP_Float_ToWord64",  show x, mkThmC' (m fromSFloat :: SFloat -> SWord64)  x (((fromIntegral :: Integer -> Word64)  . fpRound0) x)) | x <- fs]-                 ++  [("fromFP_Float_ToFloat",   show x, mkThm1  (m fromSFloat :: SFloat -> SFloat)   x                                                    x ) | x <- fs]-                 ++  [("fromFP_Float_ToDouble",  show x, mkThm1  (m fromSFloat :: SFloat -> SDouble)  x (                                           fp2fp  x)) | x <- fs]-                 -- Neither Z3 nor MathSAT support Float->Integer/Float->Real conversion for the time being; so comment out.-                 -- See GitHub issue: #191-                 -- ++  [("fromFP_Float_ToInteger", show x, mkThmC' (m fromSFloat :: SFloat -> SInteger) x (((fromIntegral :: Integer -> Integer) . fpRound0) x)) | x <- fs]-                 -- ++  [("fromFP_Float_ToReal",    show x, mkThmC' (m fromSFloat :: SFloat -> SReal)    x (                        (fromRational . fpRatio0) x)) | x <- fs]--                 ++  [("fromFP_Double_ToInt8",    show x, mkThmC' (m fromSDouble :: SDouble -> SInt8)    x (((fromIntegral :: Integer -> Int8)    . fpRound0) x)) | x <- ds]-                 ++  [("fromFP_Double_ToInt16",   show x, mkThmC' (m fromSDouble :: SDouble -> SInt16)   x (((fromIntegral :: Integer -> Int16)   . fpRound0) x)) | x <- ds]-                 ++  [("fromFP_Double_ToInt32",   show x, mkThmC' (m fromSDouble :: SDouble -> SInt32)   x (((fromIntegral :: Integer -> Int32)   . fpRound0) x)) | x <- ds]-                 ++  [("fromFP_Double_ToInt64",   show x, mkThmC' (m fromSDouble :: SDouble -> SInt64)   x (((fromIntegral :: Integer -> Int64)   . fpRound0) x)) | x <- ds]-                 ++  [("fromFP_Double_ToWord8",   show x, mkThmC' (m fromSDouble :: SDouble -> SWord8)   x (((fromIntegral :: Integer -> Word8)   . fpRound0) x)) | x <- ds]-                 ++  [("fromFP_Double_ToWord16",  show x, mkThmC' (m fromSDouble :: SDouble -> SWord16)  x (((fromIntegral :: Integer -> Word16)  . fpRound0) x)) | x <- ds]-                 ++  [("fromFP_Double_ToWord32",  show x, mkThmC' (m fromSDouble :: SDouble -> SWord32)  x (((fromIntegral :: Integer -> Word32)  . fpRound0) x)) | x <- ds]-                 ++  [("fromFP_Double_ToWord64",  show x, mkThmC' (m fromSDouble :: SDouble -> SWord64)  x (((fromIntegral :: Integer -> Word64)  . fpRound0) x)) | x <- ds]-                 ++  [("fromFP_Double_ToFloat",   show x, mkThm1  (m fromSDouble :: SDouble -> SFloat)   x (                                            fp2fp x)) | x <- ds]-                 ++  [("fromFP_Double_ToDouble",  show x, mkThm1  (m fromSDouble :: SDouble -> SDouble)  x                                                    x ) | x <- ds]-                 -- Neither Z3 nor MathSAT support Float->Integer/Float->Real conversion for the time being; so comment out.-                 -- See GitHub issue: #191-                 -- ++  [("fromFP_Double_ToInteger", show x, mkThmC' (m fromSDouble :: SDouble -> SInteger) x (((fromIntegral :: Integer -> Integer) . fpRound0) x)) | x <- ds]-                 -- ++  [("fromFP_Double_ToReal",    show x, mkThmC' (m fromSDouble :: SDouble -> SReal)    x (                        (fromRational . fpRatio0) x)) | x <- ds]--                 ++  [("reinterp_Word32_Float",  show x, mkThmC sWord32AsSFloat  x (DB.wordToFloat  x)) | x <- w32s]-                 ++  [("reinterp_Word64_Double", show x, mkThmC sWord64AsSDouble x (DB.wordToDouble x)) | x <- w64s]--                 ++  [("reinterp_Float_Word32",  show x, mkThmP sFloatAsSWord32  x (DB.floatToWord x))  | x <- fs, not (isNaN x)] -- Not unique for NaN-                 ++  [("reinterp_Double_Word64", show x, mkThmP sDoubleAsSWord64 x (DB.doubleToWord x)) | x <- ds, not (isNaN x)] -- Not unique for NaN--        m f = f sRNE--        tst1 (nm, x, t) = "fpConverts.arithmetic-" ++ nm ++ "." ++ x ~: assert t--        eqF v val-          | isNaN          val        = constrain $ fpIsNaN v-          | isNegativeZero val        = constrain $ fpIsNegativeZero v-          | val == 0                  = constrain $ fpIsPositiveZero v-          | isInfinite val && val > 0 = constrain $ fpIsInfinite v &&& fpIsPositive v-          | isInfinite val && val < 0 = constrain $ fpIsInfinite v &&& fpIsNegative v-          | True                      = constrain $ v .== literal val--        -- Quickly pick which solver to use. Currently z3 or mathSAT supports FP-        fpProver :: SMTConfig-        fpProver = z3 -- mathSAT--        fpThm :: Provable a => a -> IO Bool-        fpThm p = fromJust `fmap` isTheoremWith fpProver Nothing p--        mkThmP op x r = fpThm $ do a <- free "x"-                                   eqF a x-                                   return $ literal r .== op a--        mkThm1 op x r = fpThm $ do a <- free "x"-                                   eqF a x-                                   return $ literal r `fpIsEqualObject` op a--        mkThmC op x r = fpThm $ do a <- free "x"-                                   constrain $ a .== literal x-                                   return $ literal r `fpIsEqualObject` op a--        mkThmC' op x r = fpThm $ do a <- free "x"-                                    eqF a x-                                    return $ literal r .== op a--genQRems :: [Test]-genQRems = map mkTest $  [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- w8s,  y <- w8s ]-                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- w16s, y <- w16s]-                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- w32s, y <- w32s]-                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- w64s, y <- w64s]-                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- i8s,  y <- i8s , noOverflow x y]-                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- i16s, y <- i16s, noOverflow x y]-                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- i32s, y <- i32s, noOverflow x y]-                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- i64s, y <- i64s, noOverflow x y]-                      ++ [("divMod",  show x, show y, mkThm2 sDivMod  x y (x `divMod'`  y)) | x <- iUBs, y <- iUBs]-                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w8s,  y <- w8s ]-                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w16s, y <- w16s]-                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w32s, y <- w32s]-                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- w64s, y <- w64s]-                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i8s,  y <- i8s , noOverflow x y]-                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i16s, y <- i16s, noOverflow x y]-                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i32s, y <- i32s, noOverflow x y]-                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- i64s, y <- i64s, noOverflow x y]-                      ++ [("quotRem", show x, show y, mkThm2 sQuotRem x y (x `quotRem'` y)) | x <- iUBs, y <- iUBs]-  where divMod'  x y = if y == 0 then (0, x) else x `divMod`  y-        quotRem' x y = if y == 0 then (0, x) else x `quotRem` y-        mkTest (nm, x, y, t) = "genQRems.arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y  ~: assert t-        mkThm2 op x y (e1, e2) = isThm $ do [a, b] <- mapM free ["x", "y"]-                                            constrain $ a .== literal x-                                            constrain $ b .== literal y-                                            return $ (literal e1, literal e2) .== a `op` b-        -- Haskell's divMod and quotRem overflows if x == minBound and y == -1 for signed types; so avoid that case-        noOverflow x y = not (x == minBound && y == -1)---- Concrete test data-xsSigned, xsUnsigned :: (Num a, Bounded a) => [a]-xsUnsigned = [0, 1, maxBound - 1, maxBound]-xsSigned   = xsUnsigned ++ [minBound, minBound + 1, -1]--w8s :: [Word8]-w8s = xsUnsigned--w16s :: [Word16]-w16s = xsUnsigned--w32s :: [Word32]-w32s = xsUnsigned--w64s :: [Word64]-w64s = xsUnsigned--i8s :: [Int8]-i8s = xsSigned--i16s :: [Int16]-i16s = xsSigned--i32s :: [Int32]-i32s = xsSigned--i64s :: [Int64]-i64s = xsSigned--iUBs :: [Integer]-iUBs = [-1000000] ++ [-1 .. 1] ++ [1000000]--rs :: [AlgReal]-rs = [fromRational (i % d) | i <- is, d <- dens]- where is   = [-1000000] ++ [-1 .. 1] ++ [10000001]-       dens = [5,100,1000000]---- Admittedly paltry test-cases for float/double-fs :: [Float]-fs = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan-   where xs = [nan, infinity, 0, 0.5, 0.68302244, 0.5268265, 0.10283524, 5.8336496e-2, 1.0e-45]--ds :: [Double]-ds = xs ++ map (* (-1)) (filter (not . isNaN) xs) -- -nan is the same as nan-  where xs = [nan, infinity, 0, 0.5, 2.516632060108026e-2, 0.8601891300751106, 5.0e-324]--{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
− SBVUnitTest/TestSuite/Basics/BasicTests.hs 
@@ -1,50 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Basics.BasicTests--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.Basics.BasicTests--------------------------------------------------------------------------------module TestSuite.Basics.BasicTests(testSuite) where--import Examples.Basics.BasicTests-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "basic-0.1" ~: test0 f1 `showsAs` "5"- , "basic-0.2" ~: test0 f2 `showsAs` "5"- , "basic-0.3" ~: test0 f3 `showsAs` "25"- , "basic-0.4" ~: test0 f4 `showsAs` "25"- , "basic-0.5" ~: test0 f5 `showsAs` "4"- , "basic-1.1" ~: test1 f1 `goldCheck` "basic-1_1.gold"- , "basic-1.2" ~: test1 f2 `goldCheck` "basic-1_2.gold"- , "basic-1.3" ~: test1 f3 `goldCheck` "basic-1_3.gold"- , "basic-1.4" ~: test1 f4 `goldCheck` "basic-1_4.gold"- , "basic-1.5" ~: test1 f5 `goldCheck` "basic-1_5.gold"- , "basic-2.1" ~: test2 f1 `goldCheck` "basic-2_1.gold"- , "basic-2.2" ~: test2 f2 `goldCheck` "basic-2_2.gold"- , "basic-2.3" ~: test2 f3 `goldCheck` "basic-2_3.gold"- , "basic-2.4" ~: test2 f4 `goldCheck` "basic-2_4.gold"- , "basic-2.5" ~: test2 f5 `goldCheck` "basic-2_5.gold"- , "basic-3.1" ~: test3 f1 `goldCheck` "basic-3_1.gold"- , "basic-3.2" ~: test3 f2 `goldCheck` "basic-3_2.gold"- , "basic-3.3" ~: test3 f3 `goldCheck` "basic-3_3.gold"- , "basic-3.4" ~: test3 f4 `goldCheck` "basic-3_4.gold"- , "basic-3.5" ~: test3 f5 `goldCheck` "basic-3_5.gold"- , "basic-4.1" ~: test4 f1 `goldCheck` "basic-4_1.gold"- , "basic-4.2" ~: test4 f2 `goldCheck` "basic-4_2.gold"- , "basic-4.3" ~: test4 f3 `goldCheck` "basic-4_3.gold"- , "basic-4.4" ~: test4 f4 `goldCheck` "basic-4_4.gold"- , "basic-4.5" ~: test4 f5 `goldCheck` "basic-4_5.gold"- , "basic-5.1" ~: test5 f1 `goldCheck` "basic-5_1.gold"- , "basic-5.2" ~: test5 f2 `goldCheck` "basic-5_2.gold"- , "basic-5.3" ~: test5 f3 `goldCheck` "basic-5_3.gold"- , "basic-5.4" ~: test5 f4 `goldCheck` "basic-5_4.gold"- , "basic-5.5" ~: test5 f5 `goldCheck` "basic-5_5.gold"- ]
− SBVUnitTest/TestSuite/Basics/Higher.hs 
@@ -1,33 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Basics.Higher--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.Basics.Higher--------------------------------------------------------------------------------module TestSuite.Basics.Higher(testSuite) where--import Data.SBV--import Examples.Basics.Higher-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "higher-1"  ~: (f11 === f11)   `goldCheck` "higher-1.gold"- , "higher-2"  ~: (f12 === f12)   `goldCheck` "higher-2.gold"- , "higher-3"  ~: (f21 === f21)   `goldCheck` "higher-3.gold"- , "higher-4"  ~: (f22 === f22)   `goldCheck` "higher-4.gold"- , "higher-5"  ~: (f31 === f31)   `goldCheck` "higher-5.gold"- , "higher-6"  ~: (f32 === f32)   `goldCheck` "higher-6.gold"- , "higher-7"  ~: (f33 === f33)   `goldCheck` "higher-7.gold"- , "higher-8"  ~: double          `goldCheck` "higher-8.gold"- , "higher-9"  ~: onlyFailsFor128 `goldCheck` "higher-9.gold"- ]- where double          = (2*) === (\x -> x+(x::SWord8))-       onlyFailsFor128 = (2*) === (\x -> ite (x .== 128) 5 (x+(x::SWord8)))
− SBVUnitTest/TestSuite/Basics/Index.hs 
@@ -1,20 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Basics.Index--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.Basics.Index--------------------------------------------------------------------------------module TestSuite.Basics.Index(testSuite) where--import Examples.Basics.Index-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test $ zipWith tst [f x | f <- [test1, test2, test3], x <- [0..13]] [(0::Int)..]-  where tst t i = "index-" ++ show i ~: t `ioShowsAs` "True"
− SBVUnitTest/TestSuite/Basics/IteTest.hs 
@@ -1,37 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Basics.IteTest--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test various incarnations of ite/iteLazy/sBranch--------------------------------------------------------------------------------module TestSuite.Basics.IteTest(testSuite)  where--import Data.SBV--import SBVTest--chk1 :: (SBool -> SBool -> SBool -> SBool) -> SWord8 -> SBool-chk1 cond x = cond (x .== x) true undefined--chk2 :: (SBool -> [SBool] -> [SBool] -> [SBool]) -> SWord8 -> SBool-chk2 cond x = head (cond (x .== x) [true] [undefined])--chk3 :: (SBool -> (SBool, SBool) -> (SBool, SBool)  -> (SBool, SBool)) -> SWord8 -> SBool-chk3 cond x = fst (cond (x .== x) (true, undefined::SBool) (undefined, undefined))---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "ite-1"  ~: rs (chk1 ite) `goldCheck` "iteTest1.gold"- , "ite-2"  ~: rs (chk2 ite) `goldCheck` "iteTest2.gold"- , "ite-3"  ~: rs (chk3 ite) `goldCheck` "iteTest3.gold"- , "ite-4"  ~: assert =<< isThm (chk1 iteLazy)- , "ite-5"  ~: assert =<< isThm (chk2 iteLazy)- , "ite-6"  ~: assert =<< isThm (chk3 iteLazy)- ]- where rs f = runSAT $ forAll ["x"] f
− SBVUnitTest/TestSuite/Basics/ProofTests.hs 
@@ -1,34 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Basics.ProofTests--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.Basics.ProofTests--------------------------------------------------------------------------------module TestSuite.Basics.ProofTests(testSuite)  where--import Data.SBV--import Examples.Basics.ProofTests-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "proofs-1"  ~: assert       =<< isThm f1eqf2- , "proofs-2"  ~: assert . not =<< isThm f1eqf3- , "proofs-3"  ~: assert       =<< isThm f3eqf4- , "proofs-4"  ~: assert       =<< isThm f1Single- , "proofs-5"  ~: assert       =<< isSat (f1 `xyEq` f2)- , "proofs-6"  ~: assert       =<< isSat (f1 `xyEq` f3)- , "proofs-7"  ~: assert . not =<< isSat (exists "x" >>= \x -> return (x .== x + (1 :: SWord16)))- , "proofs-8"  ~: assert       =<< isSat (exists "x" >>= \x -> return (x :: SBool))- , "proofs-9"  ~: assert       =<< isSat (exists "x" >>= \x -> return x :: Predicate)- ]- where func1 `xyEq` func2 = do x <- exists_-                               y <- exists_-                               return $ func1 x y .== func2 x (y :: SWord8)
− SBVUnitTest/TestSuite/Basics/QRem.hs 
@@ -1,25 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Basics.QRem--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.Basics.QRem--------------------------------------------------------------------------------module TestSuite.Basics.QRem(testSuite) where--import Data.SBV--import Examples.Basics.QRem-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "qremW8" ~: assert =<< isThm (qrem :: SWord8   -> SWord8   -> SBool)- , "qremI8" ~: assert =<< isThm (qrem :: SInt8    -> SInt8    -> SBool)- , "qremI"  ~: assert =<< isThm (qrem :: SInteger -> SInteger -> SBool)- ]
− SBVUnitTest/TestSuite/BitPrecise/BitTricks.hs 
@@ -1,26 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.BitPrecise.BitTricks--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.BitPrecise.BitTricks--------------------------------------------------------------------------------module TestSuite.BitPrecise.BitTricks(testSuite) where--import Data.SBV.Examples.BitPrecise.BitTricks--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "fast min"              ~: assert =<< isThm fastMinCorrect- , "fast max"              ~: assert =<< isThm fastMaxCorrect- , "opposite signs"        ~: assert =<< isThm oppositeSignsCorrect- , "conditional set clear" ~: assert =<< isThm conditionalSetClearCorrect- , "power of two"          ~: assert =<< isThm powerOfTwoCorrect- ]
− SBVUnitTest/TestSuite/BitPrecise/Legato.hs 
@@ -1,46 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.BitPrecise.Legato--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.BitPrecise.Legato--------------------------------------------------------------------------------module TestSuite.BitPrecise.Legato(testSuite) where--import Data.SBV-import Data.SBV.Internals-import Data.SBV.Examples.BitPrecise.Legato--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "legato-1" ~: legatoPgm `goldCheck` "legato.gold"- , "legato-2" ~: legatoC `goldCheck` "legato_c.gold"- ]- where legatoPgm = runSAT $ do-                       mem     <- newArray "mem" Nothing-                       addrX   <- free "addrX"-                       x       <- free "x"-                       addrY   <- free "addrY"-                       y       <- free "y"-                       addrLow <- free "addrLow"-                       regX    <- free "regX"-                       regA    <- free "regA"-                       memVals <- free "memVals"-                       flagC   <- free "flagC"-                       flagZ   <- free "flagZ"-                       output $ legatoIsCorrect mem (addrX, x) (addrY, y) addrLow (regX, regA, memVals, flagC, flagZ)-       legatoC = compileToC' "legatoMult" $ do-                    cgSetDriverValues [87, 92]-                    cgPerformRTCs True-                    x <- cgInput "x"-                    y <- cgInput "y"-                    let (hi, lo) = runLegato (0, x) (1, y) 2 (initMachine (mkSFunArray (const 0)) (0, 0, 0, false, false))-                    cgOutput "hi" hi-                    cgOutput "lo" lo
− SBVUnitTest/TestSuite/BitPrecise/MergeSort.hs 
@@ -1,27 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.BitPrecise.MergeSort--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.BitPrecise.MergeSort--------------------------------------------------------------------------------module TestSuite.BitPrecise.MergeSort where--import Data.SBV.Internals-import Data.SBV.Examples.BitPrecise.MergeSort--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "mergeSort" ~: mergeC `goldCheck` "merge.gold"- ]- where mergeC = compileToC' "merge" $ do-                   cgSetDriverValues [10, 6, 4, 82, 71]-                   xs <- cgInputArr 5 "xs"-                   cgOutputArr "ys" (mergeSort xs)
− SBVUnitTest/TestSuite/BitPrecise/PrefixSum.hs 
@@ -1,24 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.BitPrecise.PrefixSum--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.PrefixSum.PrefixSum--------------------------------------------------------------------------------module TestSuite.BitPrecise.PrefixSum(testSuite) where--import Data.SBV-import Data.SBV.Examples.BitPrecise.PrefixSum--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-    "prefixSum1" ~: assert =<< isThm (flIsCorrect  8 (0, (+)))-  , "prefixSum2" ~: assert =<< isThm (flIsCorrect 16 (0, smax))-  ]
− SBVUnitTest/TestSuite/CRC/CCITT.hs 
@@ -1,24 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CRC.CCITT--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.CRC.CCITT--------------------------------------------------------------------------------module TestSuite.CRC.CCITT(testSuite) where--import Data.SBV--import Examples.CRC.CCITT-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-  "ccitt" ~: crcPgm `goldCheck` "ccitt.gold"- ]- where crcPgm = runSAT $ forAll_ crcGood >>= output
− SBVUnitTest/TestSuite/CRC/CCITT_Unidir.hs 
@@ -1,22 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CRC.CCITT_Unidir--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.CRC.CCITT_Unidir--------------------------------------------------------------------------------module TestSuite.CRC.CCITT_Unidir(testSuite) where--import Examples.CRC.CCITT_Unidir-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "ccitHDis3" ~: assert       =<< isThm (crcUniGood 3)- , "ccitHDis4" ~: assert . not =<< isThm (crcUniGood 4)- ]
− SBVUnitTest/TestSuite/CRC/GenPoly.hs 
@@ -1,29 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CRC.GenPoly--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.CRC.GenPoly--------------------------------------------------------------------------------module TestSuite.CRC.GenPoly(testSuite) where--import Data.SBV--import Examples.CRC.GenPoly-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "crcGood" ~: assert       =<< isSat crcGoodE- , "crcGood" ~: assert . not =<< isThm (crcGood 3 12)- ]- where crcGoodE = do x1 <- exists_-                     x2 <- exists_-                     y1 <- exists_-                     y2 <- exists_-                     return (crcGood 3 0 (x1,x2) (y1,y2))
− SBVUnitTest/TestSuite/CRC/Parity.hs 
@@ -1,21 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CRC.Parity--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.CRC.Parity--------------------------------------------------------------------------------module TestSuite.CRC.Parity(testSuite) where--import Examples.CRC.Parity-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "parity" ~: assert =<< isThm parityOK- ]
− SBVUnitTest/TestSuite/CRC/USB5.hs 
@@ -1,21 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CRC.USB5--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.CRC.USB5--------------------------------------------------------------------------------module TestSuite.CRC.USB5(testSuite) where--import Examples.CRC.USB5-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "usbGood" ~: assert =<< isThm usbGood- ]
− SBVUnitTest/TestSuite/CodeGeneration/AddSub.hs 
@@ -1,31 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CodeGeneration.AddSub--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.CodeGeneration.AddSub--------------------------------------------------------------------------------module TestSuite.CodeGeneration.AddSub(testSuite) where--import Data.SBV.Internals-import Data.SBV.Examples.CodeGeneration.AddSub--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "addSub" ~: code `goldCheck` "addSub.gold"- ]- where code = compileToC' "addSub" $ do-                cgSetDriverValues [76, 92]-                cgPerformRTCs True-                x <- cgInput "x"-                y <- cgInput "y"-                let (s, d) = addSub x y-                cgOutput "sum" s-                cgOutput "dif" d
− SBVUnitTest/TestSuite/CodeGeneration/CRC_USB5.hs 
@@ -1,28 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CodeGeneration.CRC_USB5--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.CodeGeneration.CRC_USB5--------------------------------------------------------------------------------module TestSuite.CodeGeneration.CRC_USB5(testSuite) where--import Data.SBV.Internals-import Data.SBV.Examples.CodeGeneration.CRC_USB5--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "crcUSB5-1" ~: genC crcUSB  `goldCheck` "crcUSB5_1.gold"- , "crcUSB5-2" ~: genC crcUSB' `goldCheck` "crcUSB5_2.gold"- ]- where genC f = compileToC' "crcUSB5" $ do-                   cgSetDriverValues [0xFEDC]-                   msg <- cgInput "msg"-                   cgReturn $ f msg
− SBVUnitTest/TestSuite/CodeGeneration/CgTests.hs 
@@ -1,42 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CodeGeneration.CgTests--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for code-generation features--------------------------------------------------------------------------------{-# LANGUAGE ScopedTypeVariables #-}--module TestSuite.CodeGeneration.CgTests(testSuite) where--import Data.SBV-import Data.SBV.Internals--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "selChecked"   ~: genSelect True  "selChecked"   `goldCheck` "selChecked.gold"- , "selUnchecked" ~: genSelect False "selUnChecked" `goldCheck` "selUnchecked.gold"- , "codegen1"     ~: foo `goldCheck` "codeGen1.gold"- ]- where genSelect b n = compileToC' n $ do-                         cgSetDriverValues [65]-                         cgPerformRTCs b-                         let sel :: SWord8 -> SWord8-                             sel x = select [1, x+2] 3 x-                         x <- cgInput "x"-                         cgReturn $ sel x-       foo = compileToC' "foo" $ do-                        cgSetDriverValues $ repeat 0-                        (x::SInt16)    <- cgInput "x"-                        (ys::[SInt64]) <- cgInputArr 45 "xArr"-                        cgOutput "z" (5 :: SWord16)-                        cgOutputArr "zArr" (replicate 7 (x+1))-                        cgOutputArr "yArr" ys-                        cgReturn (x*2)
− SBVUnitTest/TestSuite/CodeGeneration/Fibonacci.hs 
@@ -1,28 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CodeGeneration.Fibonacci--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.CodeGeneration.Fibonacci--------------------------------------------------------------------------------module TestSuite.CodeGeneration.Fibonacci(testSuite) where--import Data.SBV.Internals-import Data.SBV.Examples.CodeGeneration.Fibonacci--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "fib1" ~: tst [12] "fib1" (fib1 64) `goldCheck` "fib1.gold"- , "fib2" ~: tst [20] "fib2" (fib2 64) `goldCheck` "fib2.gold"- ]- where tst vs nm f = compileToC' nm $ do cgPerformRTCs True-                                         cgSetDriverValues vs-                                         n <- cgInput "n"-                                         cgReturn $ f n
− SBVUnitTest/TestSuite/CodeGeneration/Floats.hs 
@@ -1,164 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CodeGeneration.Floats--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test-suite for generating floating-point related C code--------------------------------------------------------------------------------module TestSuite.CodeGeneration.Floats(testSuite) where--import Data.SBV-import Data.SBV.Internals--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "floats_cgen" ~: code `goldCheck` "floats_cgen.gold"- ]- where code  = compileToCLib' "floatCodeGen" cases--       setup = do cgSRealType CgLongDouble-                  cgIntegerSize 64-                  cgSetDriverValues [42, 43, 44]--       test1 nm f = (nm, do setup-                            a <- cgInput "a"-                            cgReturn (f a))--       test2 nm f = (nm, do setup-                            a <- cgInput "a"-                            b <- cgInput "b"-                            cgReturn (f a b))--       test3 nm f = (nm, do setup-                            a <- cgInput "a"-                            b <- cgInput "b"-                            c <- cgInput "c"-                            cgReturn (f a b c))--       cases = [-            test1 "toFP_Int8_ToFloat"       (toSFloat sRoundNearestTiesToEven  :: SInt8    -> SFloat)-          , test1 "toFP_Int16_ToFloat"      (toSFloat sRoundNearestTiesToEven  :: SInt16   -> SFloat)-          , test1 "toFP_Int32_ToFloat"      (toSFloat sRoundNearestTiesToEven  :: SInt32   -> SFloat)-          , test1 "toFP_Int64_ToFloat"      (toSFloat sRoundNearestTiesToEven  :: SInt64   -> SFloat)-          , test1 "toFP_Word8_ToFloat"      (toSFloat sRoundNearestTiesToEven  :: SWord8   -> SFloat)-          , test1 "toFP_Word16_ToFloat"     (toSFloat sRoundNearestTiesToEven  :: SWord16  -> SFloat)-          , test1 "toFP_Word32_ToFloat"     (toSFloat sRoundNearestTiesToEven  :: SWord32  -> SFloat)-          , test1 "toFP_Word64_ToFloat"     (toSFloat sRoundNearestTiesToEven  :: SWord64  -> SFloat)-          , test1 "toFP_Float_ToFloat"      (toSFloat sRoundNearestTiesToEven  :: SFloat   -> SFloat)-          , test1 "toFP_Double_ToFloat"     (toSFloat sRoundNearestTiesToEven  :: SDouble  -> SFloat)-          , test1 "toFP_Integer_ToFloat"    (toSFloat sRoundNearestTiesToEven  :: SInteger -> SFloat)-          , test1 "toFP_Real_ToFloat"       (toSFloat sRoundNearestTiesToEven  :: SReal    -> SFloat)--          , test1 "toFP_Int8_ToDouble"      (toSDouble sRoundNearestTiesToEven :: SInt8    -> SDouble)-          , test1 "toFP_Int16_ToDouble"     (toSDouble sRoundNearestTiesToEven :: SInt16   -> SDouble)-          , test1 "toFP_Int32_ToDouble"     (toSDouble sRoundNearestTiesToEven :: SInt32   -> SDouble)-          , test1 "toFP_Int64_ToDouble"     (toSDouble sRoundNearestTiesToEven :: SInt64   -> SDouble)-          , test1 "toFP_Word8_ToDouble"     (toSDouble sRoundNearestTiesToEven :: SWord8   -> SDouble)-          , test1 "toFP_Word16_ToDouble"    (toSDouble sRoundNearestTiesToEven :: SWord16  -> SDouble)-          , test1 "toFP_Word32_ToDouble"    (toSDouble sRoundNearestTiesToEven :: SWord32  -> SDouble)-          , test1 "toFP_Word64_ToDouble"    (toSDouble sRoundNearestTiesToEven :: SWord64  -> SDouble)-          , test1 "toFP_Float_ToDouble"     (toSDouble sRoundNearestTiesToEven :: SFloat   -> SDouble)-          , test1 "toFP_Double_ToDouble"    (toSDouble sRoundNearestTiesToEven :: SDouble  -> SDouble)-          , test1 "toFP_Integer_ToDouble"   (toSDouble sRoundNearestTiesToEven :: SInteger -> SDouble)-          , test1 "toFP_Real_ToDouble"      (toSDouble sRoundNearestTiesToEven :: SReal    -> SDouble)--          , test1 "fromFP_Float_ToInt8"     (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt8)-          , test1 "fromFP_Float_ToInt16"    (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt16)-          , test1 "fromFP_Float_ToInt32"    (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt32)-          , test1 "fromFP_Float_ToInt64"    (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInt64)-          , test1 "fromFP_Float_ToWord8"    (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord8)-          , test1 "fromFP_Float_ToWord16"   (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord16)-          , test1 "fromFP_Float_ToWord32"   (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord32)-          , test1 "fromFP_Float_ToWord64"   (fromSFloat sRoundNearestTiesToEven :: SFloat -> SWord64)-          , test1 "fromFP_Float_ToFloat"    (fromSFloat sRoundNearestTiesToEven :: SFloat -> SFloat)-          , test1 "fromFP_Float_ToDouble"   (fromSFloat sRoundNearestTiesToEven :: SFloat -> SDouble)-          , test1 "fromFP_Float_ToInteger"  (fromSFloat sRoundNearestTiesToEven :: SFloat -> SInteger)-          , test1 "fromFP_Float_ToReal"     (fromSFloat sRoundNearestTiesToEven :: SFloat -> SReal)--          , test1 "fromFP_DoubleTo_Int8"    (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt8)-          , test1 "fromFP_DoubleTo_Int16"   (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt16)-          , test1 "fromFP_DoubleTo_Int32"   (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt32)-          , test1 "fromFP_DoubleTo_Int64"   (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInt64)-          , test1 "fromFP_DoubleTo_Word8"   (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord8)-          , test1 "fromFP_DoubleTo_Word16"  (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord16)-          , test1 "fromFP_DoubleTo_Word32"  (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord32)-          , test1 "fromFP_DoubleTo_Word64"  (fromSDouble sRoundNearestTiesToEven :: SDouble -> SWord64)-          , test1 "fromFP_DoubleTo_Float"   (fromSDouble sRoundNearestTiesToEven :: SDouble -> SFloat)-          , test1 "fromFP_DoubleTo_Double"  (fromSDouble sRoundNearestTiesToEven :: SDouble -> SDouble)-          , test1 "fromFP_DoubleTo_Integer" (fromSDouble sRoundNearestTiesToEven :: SDouble -> SInteger)-          , test1 "fromFP_DoubleTo_Real"    (fromSDouble sRoundNearestTiesToEven :: SDouble -> SReal)--          , test1 "fromFP_SWord32_SFloat"   (sWord32AsSFloat  :: SWord32 -> SFloat)-          , test1 "fromFP_SWord64_SDouble"  (sWord64AsSDouble :: SWord64 -> SDouble)-          , test1 "fromFP_SFloat_SWord32"   (sFloatAsSWord32  :: SFloat  -> SWord32)-          , test1 "fromFP_SDouble_SWord64"  (sDoubleAsSWord64 :: SDouble -> SWord64)--          , test1 "f_FP_Abs"                (abs    :: SFloat -> SFloat)-          , test1 "d_FP_Abs"                (abs    :: SDouble -> SDouble)--          , test1 "f_FP_Neg"                (negate :: SFloat -> SFloat)-          , test1 "d_FP_Neg"                (negate :: SDouble -> SDouble)--          , test2 "f_FP_Add"                (fpAdd  sRoundNearestTiesToEven :: SFloat  -> SFloat  -> SFloat)-          , test2 "d_FP_Add"                (fpAdd  sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble)--          , test2 "f_FP_Sub"                (fpSub  sRoundNearestTiesToEven :: SFloat  -> SFloat  -> SFloat)-          , test2 "d_FP_Sub"                (fpSub  sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble)--          , test2 "f_FP_Mul"                (fpMul  sRoundNearestTiesToEven :: SFloat  -> SFloat  -> SFloat)-          , test2 "d_FP_Mul"                (fpMul  sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble)--          , test2 "f_FP_Div"                (fpDiv  sRoundNearestTiesToEven :: SFloat  -> SFloat  -> SFloat)-          , test2 "d_FP_Div"                (fpDiv  sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble)--          , test3 "f_FP_FMA"                (fpFMA  sRoundNearestTiesToEven :: SFloat  -> SFloat  -> SFloat  -> SFloat)-          , test3 "d_FP_FMA"                (fpFMA  sRoundNearestTiesToEven :: SDouble -> SDouble -> SDouble -> SDouble)--          , test1 "f_FP_Sqrt"               (fpSqrt sRoundNearestTiesToEven :: SFloat  -> SFloat)-          , test1 "d_FP_Sqrt"               (fpSqrt sRoundNearestTiesToEven :: SDouble -> SDouble)--          , test2 "f_FP_Rem"                (fpRem  :: SFloat  -> SFloat  -> SFloat)-          , test2 "d_FP_Rem"                (fpRem  :: SDouble -> SDouble -> SDouble)--          , test1 "f_FP_RoundToIntegral"    (fpRoundToIntegral sRoundNearestTiesToEven :: SFloat  -> SFloat)-          , test1 "d_FP_RoundToIntegral"    (fpRoundToIntegral sRoundNearestTiesToEven :: SDouble -> SDouble)--          , test2 "f_FP_Min"                (fpMin :: SFloat  -> SFloat  -> SFloat)-          , test2 "d_FP_Min"                (fpMin :: SDouble -> SDouble -> SDouble)--          , test2 "f_FP_Max"                (fpMax :: SFloat  -> SFloat  -> SFloat)-          , test2 "d_FP_Max"                (fpMax :: SDouble -> SDouble -> SDouble)--          , test2 "f_FP_IsEqualObject"      (fpIsEqualObject :: SFloat  -> SFloat  -> SBool)-          , test2 "d_FP_IsEqualObject"      (fpIsEqualObject :: SDouble -> SDouble -> SBool)--          , test1 "f_FP_IsNormal"           (fpIsNormal :: SFloat  -> SBool)-          , test1 "d_FP_IsNormal"           (fpIsNormal :: SDouble -> SBool)--          , test1 "f_FP_IsZero"             (fpIsZero :: SFloat  -> SBool)-          , test1 "d_FP_IsZero"             (fpIsZero :: SDouble -> SBool)--          , test1 "f_FP_IsSubnormal"        (fpIsSubnormal :: SFloat  -> SBool)-          , test1 "d_FP_IsSubnormal"        (fpIsSubnormal :: SDouble -> SBool)--          , test1 "f_FP_IsInfinite"         (fpIsInfinite :: SFloat  -> SBool)-          , test1 "d_FP_IsInfinite"         (fpIsInfinite :: SDouble -> SBool)--          , test1 "f_FP_IsNaN"              (fpIsNaN :: SFloat  -> SBool)-          , test1 "d_FP_IsNaN"              (fpIsNaN :: SDouble -> SBool)--          , test1 "f_FP_IsNegative"         (fpIsNegative :: SFloat  -> SBool)-          , test1 "d_FP_IsNegative"         (fpIsNegative :: SDouble -> SBool)--          , test1 "f_FP_IsPositive"         (fpIsPositive :: SFloat  -> SBool)-          , test1 "d_FP_IsPositive"         (fpIsPositive :: SDouble -> SBool)-          ]--{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-}
− SBVUnitTest/TestSuite/CodeGeneration/GCD.hs 
@@ -1,28 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CodeGeneration.GCD--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.CodeGeneration.GCD--------------------------------------------------------------------------------module TestSuite.CodeGeneration.GCD(testSuite) where--import Data.SBV.Internals-import Data.SBV.Examples.CodeGeneration.GCD--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "gcd" ~: gcdC `goldCheck` "gcd.gold"- ]- where gcdC = compileToC' "sgcd" $ do-                cgSetDriverValues [55,154]-                x <- cgInput "x"-                y <- cgInput "y"-                cgReturn $ sgcd x y
− SBVUnitTest/TestSuite/CodeGeneration/PopulationCount.hs 
@@ -1,29 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CodeGeneration.PopulationCount--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.CodeGeneration.PopulationCount--------------------------------------------------------------------------------module TestSuite.CodeGeneration.PopulationCount(testSuite) where--import Data.SBV.Internals-import Data.SBV.Examples.CodeGeneration.PopulationCount--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "popCount-1" ~: genC False `goldCheck` "popCount1.gold"- , "popCount-2" ~: genC True  `goldCheck` "popCount2.gold"- ]- where genC b = compileToC' "popCount" $ do-                  cgSetDriverValues [0x0123456789ABCDEF]-                  cgPerformRTCs b-                  x <- cgInput "x"-                  cgReturn $ popCountFast x
− SBVUnitTest/TestSuite/CodeGeneration/Uninterpreted.hs 
@@ -1,27 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.CodeGeneration.Uninterpreted--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.CodeGeneration.Uninterpreted--------------------------------------------------------------------------------module TestSuite.CodeGeneration.Uninterpreted(testSuite) where--import Data.SBV.Internals-import Data.SBV.Examples.CodeGeneration.Uninterpreted--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "cgUninterpret" ~: genC `goldCheck` "cgUninterpret.gold"- ]- where genC = compileToC' "tstShiftLeft" $ do-                  cgSetDriverValues [1, 2, 3]-                  [x, y, z] <- cgInputArr 3 "vs"-                  cgReturn $ tstShiftLeft x y z
− SBVUnitTest/TestSuite/Crypto/AES.hs 
@@ -1,34 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Crypto.AES--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Crypto.AES--------------------------------------------------------------------------------module TestSuite.Crypto.AES(testSuite) where--import Data.SBV.Internals-import Data.SBV.Examples.Crypto.AES--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "aes128Enc" ~: compileToC'    "aes128Enc" (aes128EncDec True)  `goldCheck` "aes128Enc.gold"- , "aes128Dec" ~: compileToC'    "aes128Dec" (aes128EncDec False) `goldCheck` "aes128Dec.gold"- , "aes128Lib" ~: compileToCLib' "aes128Lib" aes128Comps          `goldCheck` "aes128Lib.gold"- ]- where aes128EncDec d = do pt  <- cgInputArr 4 "pt"-                           key <- cgInputArr 4 "key"-                           cgSetDriverValues $ repeat 0-                           let (encKs, decKs) = aesKeySchedule key-                               res | d    = aesEncrypt pt encKs-                                   | True = aesDecrypt pt decKs-                           cgOutputArr "ct" res-       aes128Comps = [(f, setVals c) | (f, c) <- aes128LibComponents]-       setVals c = cgSetDriverValues (repeat 0) >> c
− SBVUnitTest/TestSuite/Crypto/RC4.hs 
@@ -1,25 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Crypto.RC4--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Crypto.RC4--------------------------------------------------------------------------------module TestSuite.Crypto.RC4(testSuite) where--import Data.SBV-import Data.SBV.Tools.STree-import Data.SBV.Examples.Crypto.RC4--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "rc4swap" ~: assert =<< isThm readWrite- ]- where readWrite i j = readSTree (writeSTree initS i j) i .== j
− SBVUnitTest/TestSuite/Existentials/CRCPolynomial.hs 
@@ -1,32 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Existentials.CRCPolynomial--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Existentials.CRCPolynomial--------------------------------------------------------------------------------module TestSuite.Existentials.CRCPolynomial(testSuite) where--import Data.SBV-import Data.SBV.Examples.Existentials.CRCPolynomial--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-  "crcPolyExist" ~: pgm `goldCheck` "crcPolyExist.gold"- ]- where pgm = runSAT $ do-                p <- exists "poly"-                s <- do sh <- forall "sh"-                        sl <- forall "sl"-                        return (sh, sl)-                r <- do rh <- forall "rh"-                        rl <- forall "rl"-                        return (rh, rl)-                output $ sTestBit p 0 &&& crcGood 4 p s r
− SBVUnitTest/TestSuite/Polynomials/Polynomials.hs 
@@ -1,24 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Polynomials.Polynomials--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Polynomials.Polynomials--------------------------------------------------------------------------------module TestSuite.Polynomials.Polynomials(testSuite) where--import Data.SBV.Examples.Polynomials.Polynomials--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "polynomial-1" ~: assert =<< isThm multUnit- , "polynomial-2" ~: assert =<< isThm multComm- , "polynomial-3" ~: assert =<< isThm polyDivMod- ]
− SBVUnitTest/TestSuite/Puzzles/Coins.hs 
@@ -1,27 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Puzzles.Coins--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Puzzles.Coins--------------------------------------------------------------------------------module TestSuite.Puzzles.Coins(testSuite) where--import Data.SBV-import Data.SBV.Examples.Puzzles.Coins--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-  "coins" ~: coinsPgm `goldCheck` "coins.gold"- ]- where coinsPgm = runSAT $ do cs <- mapM mkCoin [1..6]-                              mapM_ constrain [c s | s <- combinations cs, length s >= 2, c <- [c1, c2, c3, c4, c5, c6]]-                              constrain $ bAnd $ zipWith (.>=) cs (tail cs)-                              output $ sum cs .== 115
− SBVUnitTest/TestSuite/Puzzles/Counts.hs 
@@ -1,25 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Puzzles.Counts--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Puzzles.Counts--------------------------------------------------------------------------------module TestSuite.Puzzles.Counts(testSuite) where--import Data.SBV-import Data.SBV.Examples.Puzzles.Counts--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-  "counts" ~: countPgm `goldCheck` "counts.gold"- ]- where countPgm = runSAT $ forAll_ puzzle' >>= output-       puzzle' d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 = puzzle [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9]
− SBVUnitTest/TestSuite/Puzzles/DogCatMouse.hs 
@@ -1,30 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Puzzles.DogCatMouse--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Puzzles.DogCatMouse--------------------------------------------------------------------------------module TestSuite.Puzzles.DogCatMouse(testSuite) where--import Data.SBV--- import Data.SBV.Examples.Puzzles.DogCatMouse   -- everything defined here--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-  "dog_cat_mouse" ~: allSat p `goldCheck` "dogCatMouse.gold"- ]- where p = do [dog, cat, mouse] <- sIntegers ["dog", "cat", "mouse"]-              solve [ dog   .>= 1                                   -- at least one dog-                    , cat   .>= 1                                   -- at least one cat-                    , mouse .>= 1                                   -- at least one mouse-                    , dog + cat + mouse .== 100                     -- buy precisely 100 animals-                    , 1500 * dog + 100 * cat + 25 * mouse .== 10000 -- spend exactly 100 dollars (use cents since we don't have fractions)-                    ]
− SBVUnitTest/TestSuite/Puzzles/Euler185.hs 
@@ -1,23 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Puzzles.Euler185--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Puzzles.Euler185--------------------------------------------------------------------------------module TestSuite.Puzzles.Euler185(testSuite) where--import Data.SBV-import Data.SBV.Examples.Puzzles.Euler185--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-  "euler185" ~: allSat euler185 `goldCheck` "euler185.gold"- ]
− SBVUnitTest/TestSuite/Puzzles/MagicSquare.hs 
@@ -1,25 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Puzzles.MagicSquare--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Puzzles.MagicSquare--------------------------------------------------------------------------------module TestSuite.Puzzles.MagicSquare(testSuite) where--import Data.SBV-import Data.SBV.Examples.Puzzles.MagicSquare--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "magic 2" ~: assert . not =<< isSat (mkMagic 2)- , "magic 3" ~: assert       =<< isSat (mkMagic 3)- ]- where mkMagic n = (isMagic . chunk n) `fmap` mkExistVars (n*n)
− SBVUnitTest/TestSuite/Puzzles/NQueens.hs 
@@ -1,32 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Puzzles.NQueens--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Puzzles.NQueens--------------------------------------------------------------------------------module TestSuite.Puzzles.NQueens(testSuite) where--import Data.SBV-import Data.SBV.Examples.Puzzles.NQueens--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   -- number of *distinct* solutions is given in http://en.wikipedia.org/wiki/Eight_queens_puzzle-   "nQueens 1" ~: assert $ (==  1) `fmap` numberOfModels (mkQueens 1)- , "nQueens 2" ~: assert $ (==  0) `fmap` numberOfModels (mkQueens 2)- , "nQueens 3" ~: assert $ (==  0) `fmap` numberOfModels (mkQueens 3)- , "nQueens 4" ~: assert $ (==  2) `fmap` numberOfModels (mkQueens 4)- , "nQueens 5" ~: assert $ (== 10) `fmap` numberOfModels (mkQueens 5)- , "nQueens 6" ~: assert $ (==  4) `fmap` numberOfModels (mkQueens 6)- , "nQueens 7" ~: assert $ (== 40) `fmap` numberOfModels (mkQueens 7)- , "nQueens 8" ~: assert $ (== 92) `fmap` numberOfModels (mkQueens 8)- ]- where mkQueens n = isValid n `fmap` mkExistVars n
− SBVUnitTest/TestSuite/Puzzles/PowerSet.hs 
@@ -1,24 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Puzzles.PowerSet--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.Puzzles.PowerSet--------------------------------------------------------------------------------module TestSuite.Puzzles.PowerSet(testSuite) where--import Data.SBV--import Examples.Puzzles.PowerSet-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [ "powerSet " ++ show i ~: assert (pSet i) | i <- [0 .. 7] ]- where pSet :: Int -> IO Bool-       pSet n = do cnt <- numberOfModels $ genPowerSet `fmap` mkExistVars n-                   return (cnt == 2^n)
− SBVUnitTest/TestSuite/Puzzles/Sudoku.hs 
@@ -1,25 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Puzzles.Sudoku--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Puzzles.Sudoku--------------------------------------------------------------------------------module TestSuite.Puzzles.Sudoku(testSuite) where--import Data.SBV-import Data.SBV.Examples.Puzzles.Sudoku--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-  "sudoku " ++ show n ~: assert (checkPuzzle s)-     | (n, s) <- zip [(0::Int)..] [puzzle0, puzzle1, puzzle2, puzzle3, puzzle4, puzzle5, puzzle6]- ]- where checkPuzzle (i, f) = isSat $ (valid . f) `fmap` mkExistVars i
− SBVUnitTest/TestSuite/Puzzles/Temperature.hs 
@@ -1,23 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Puzzles.Temperature--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.Puzzles.Temperature--------------------------------------------------------------------------------module TestSuite.Puzzles.Temperature(testSuite) where--import Data.SBV--import Examples.Puzzles.Temperature-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-  "temperature" ~: allSat (revOf `fmap` exists_) `goldCheck` "temperature.gold"- ]
− SBVUnitTest/TestSuite/Puzzles/U2Bridge.hs 
@@ -1,31 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Puzzles.U2Bridge--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Puzzles.U2Bridge--------------------------------------------------------------------------------module TestSuite.Puzzles.U2Bridge(testSuite) where--import Data.SBV-import Data.SBV.Examples.Puzzles.U2Bridge--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "U2Bridge-1" ~: assert $ (0 ==) `fmap` count 1- , "U2Bridge-2" ~: assert $ (0 ==) `fmap` count 2- , "U2Bridge-3" ~: assert $ (0 ==) `fmap` count 3- , "U2Bridge-4" ~: assert $ (0 ==) `fmap` count 4- , "U2Bridge-5" ~: slv 5 `goldCheck` "U2Bridge.gold"- , "U2Bridge-6" ~: assert $ (0 ==) `fmap` count 6- ]- where act     = do b <- exists_; p1 <- exists_; p2 <- exists_; return (b, p1, p2)-       count n = numberOfModels $ isValid `fmap` mapM (const act) [1..(n::Int)]-       slv n   = sat $ isValid `fmap` mapM (const act) [1..(n::Int)]
− SBVUnitTest/TestSuite/Uninterpreted/AUF.hs 
@@ -1,31 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Uninterpreted.AUF--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Data.SBV.Examples.Uninterpreted.AUF--------------------------------------------------------------------------------module TestSuite.Uninterpreted.AUF where--import Data.SBV-import Data.SBV.Examples.Uninterpreted.AUF--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \goldCheck -> test [-   "auf-0" ~: assert =<< isThm (newArray "a" Nothing >>= \a -> free "x" >>= \x -> free "y" >>= \y -> free "i" >>= \i -> return (thm1 x y a i))- , "auf-1" ~: assert =<< isThm (newArray "b" Nothing >>= \b -> free "x" >>= \x -> free "y" >>= \y                    -> return (thm2 x y b))- , "auf-2" ~: pgm `goldCheck` "auf-1.gold"- ]- where pgm = runSAT $ do-                x <- free "x"-                y <- free "y"-                a <- newArray "a" Nothing-                i <- free "initVal"-                output $ thm1 x y a i
− SBVUnitTest/TestSuite/Uninterpreted/Axioms.hs 
@@ -1,49 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Uninterpreted.Axioms--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for basic axioms and uninterpreted functions--------------------------------------------------------------------------------{-# LANGUAGE DeriveAnyClass     #-}-{-# LANGUAGE DeriveDataTypeable #-}--module TestSuite.Uninterpreted.Axioms(testSuite) where--import Data.SBV-import SBVTest-import Data.Generics---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-  "unint-axioms" ~: assert =<< isThm p0- ]---- Example provided by Thomas DuBuisson:-newtype Bitstring = Bitstring () deriving (Eq, Ord, Show, Read, Data, SymWord, HasKind)-type SBitstring = SBV Bitstring--a :: SBitstring -> SBool-a = uninterpret "a"--e :: SBitstring -> SBitstring -> SBitstring-e = uninterpret "e"--axE :: [String]-axE = [ "(assert (forall ((p Bitstring) (k Bitstring))"-      , "         (=> (and (a k) (a p)) (a (e k p)))))"-      ]--p0 :: Symbolic SBool-p0 = do-    p <- free "p" :: Symbolic SBitstring-    k <- free "k" :: Symbolic SBitstring-    addAxiom "axE" axE-    constrain $ a p-    constrain $ a k-    return $ a (e k p)
− SBVUnitTest/TestSuite/Uninterpreted/Function.hs 
@@ -1,22 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Uninterpreted.Function--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Testsuite for Data.SBV.Examples.Uninterpreted.Function--------------------------------------------------------------------------------module TestSuite.Uninterpreted.Function where--import Data.SBV.Examples.Uninterpreted.Function--import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "aufunc-0" ~: assert =<< isThm thmGood- ]
− SBVUnitTest/TestSuite/Uninterpreted/Sort.hs 
@@ -1,45 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  TestSuite.Uninterpreted.Sort--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for uninterpreted sorts--------------------------------------------------------------------------------{-# LANGUAGE DeriveDataTypeable  #-}-{-# LANGUAGE ScopedTypeVariables #-}--module TestSuite.Uninterpreted.Sort where--import Data.SBV-import SBVTest-import Data.Generics---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-  "unint-sort" ~: assert . (==4) . length . (extractModels :: AllSatResult -> [L]) =<< allSat p0- ]--data L = Nil | Cons Int L deriving (Eq, Ord, Data, Read, Show)-instance SymWord L-instance HasKind L-instance SatModel L where-  parseCWs = undefined -- make GHC shut up about the missing method, we won't actually call it--type SList = SBV L--len :: SList -> SInteger-len = uninterpret "len"--p0 :: Symbolic SBool-p0 = do-    [l, l0, l1] <- symbolics ["l", "l0", "l1"]-    constrain $ len l0 .== 0-    constrain $ len l1 .== 1-    x :: SInteger <- symbolic "x"-    constrain $ x .== 0 ||| x.== 1-    return $ l .== l0 ||| l .== l1
− SBVUnitTest/TestSuite/Uninterpreted/Uninterpreted.hs 
@@ -1,23 +0,0 @@--------------------------------------------------------------------------------- |--- Module      :  Examples.TestSuite.Uninterpreted--- Copyright   :  (c) Levent Erkok--- License     :  BSD3--- Maintainer  :  erkokl@gmail.com--- Stability   :  experimental------ Test suite for Examples.Uninterpreted.Uninterpreted--------------------------------------------------------------------------------module TestSuite.Uninterpreted.Uninterpreted where--import Examples.Uninterpreted.Uninterpreted-import SBVTest---- Test suite-testSuite :: SBVTestSuite-testSuite = mkTestSuite $ \_ -> test [-   "uninterpreted-0" ~: assert       =<< isThm p0- , "uninterpreted-1" ~: assert       =<< isThm p1- , "uninterpreted-2" ~: assert . not =<< isThm p2- ]
sbv.cabal view
@@ -1,5 +1,5 @@ Name:          sbv-Version:       6.1+Version:       7.0 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@@ -17,7 +17,7 @@ Maintainer:    Levent Erkok (erkokl@gmail.com) Build-Type:    Simple Cabal-Version: >= 1.14-Data-Files: SBVUnitTest/GoldFiles/*.gold+Data-Files: SBVTestSuite/GoldFiles/*.gold Extra-Source-Files: INSTALL, README.md, COPYRIGHT, CHANGES.md  source-repository head@@ -42,27 +42,24 @@                     Rank2Types                     RankNTypes                     ScopedTypeVariables+                    StandaloneDeriving+                    TemplateHaskell                     TupleSections                     TypeOperators                     TypeSynonymInstances-  Build-Depends   : base >= 4.8 && < 5-                  , base-compat >= 0.6+  Build-Depends   : base >= 4.9 && < 5                   , ghc                   , QuickCheck >= 2.9.2                   , crackNum >= 1.9-                  , array, async, containers, deepseq, directory, filepath, old-time+                  , template-haskell >= 2.11+                  , array, async, containers, deepseq, directory, filepath, time                   , pretty, process, mtl, random, syb, data-binary-ieee754+                  , generic-deriving   Exposed-modules : Data.SBV-                  , Data.SBV.Bridge.Boolector-                  , Data.SBV.Bridge.CVC4-                  , Data.SBV.Bridge.MathSAT-                  , Data.SBV.Bridge.Yices-                  , Data.SBV.Bridge.Z3-                  , Data.SBV.Bridge.ABC+                  , Data.SBV.Control                   , Data.SBV.Dynamic                   , Data.SBV.Internals                   , Data.SBV.Tools.CodeGen-                  , Data.SBV.Tools.ExpectedValue                   , Data.SBV.Tools.GenTest                   , Data.SBV.Tools.Polynomial                   , Data.SBV.Tools.STree@@ -87,11 +84,11 @@                   , Data.SBV.Examples.Misc.Auxiliary                   , Data.SBV.Examples.Misc.NoDiv0                   , Data.SBV.Examples.Misc.Word4-                  , Data.SBV.Examples.Misc.UnsatCore                   , Data.SBV.Examples.Polynomials.Polynomials                   , Data.SBV.Examples.Optimization.LinearOpt                   , Data.SBV.Examples.Optimization.Production                   , Data.SBV.Examples.Optimization.VM+                  , Data.SBV.Examples.Optimization.ExtField                   , Data.SBV.Examples.Puzzles.Birthday                   , Data.SBV.Examples.Puzzles.Coins                   , Data.SBV.Examples.Puzzles.Counts@@ -103,6 +100,12 @@                   , Data.SBV.Examples.Puzzles.SendMoreMoney                   , Data.SBV.Examples.Puzzles.Sudoku                   , Data.SBV.Examples.Puzzles.U2Bridge+                  , Data.SBV.Examples.Queries.AllSat+                  , Data.SBV.Examples.Queries.UnsatCore+                  , Data.SBV.Examples.Queries.FourFours+                  , Data.SBV.Examples.Queries.GuessNumber+                  , Data.SBV.Examples.Queries.CaseSplit+                  , Data.SBV.Examples.Queries.Enums                   , Data.SBV.Examples.Uninterpreted.AUF                   , Data.SBV.Examples.Uninterpreted.Deduce                   , Data.SBV.Examples.Uninterpreted.Function@@ -118,14 +121,17 @@                   , Data.SBV.Core.Floating                   , Data.SBV.Core.Splittable                   , Data.SBV.Core.Symbolic+                  , Data.SBV.Control.Query+                  , Data.SBV.Control.Types+                  , Data.SBV.Control.Utils                   , Data.SBV.Compilers.C                   , Data.SBV.Compilers.CodeGen                   , Data.SBV.SMT.SMT                   , Data.SBV.SMT.SMTLib                   , Data.SBV.SMT.SMTLib2                   , Data.SBV.SMT.SMTLibNames+                  , Data.SBV.SMT.Utils                   , Data.SBV.Provers.Prover-                  , Data.SBV.Provers.SExpr                   , Data.SBV.Provers.Boolector                   , Data.SBV.Provers.CVC4                   , Data.SBV.Provers.Yices@@ -137,46 +143,42 @@                   , Data.SBV.Utils.TDiff                   , Data.SBV.Utils.Lib                   , Data.SBV.Utils.PrettyNum-                  , GHC.SrcLoc.Compat-                  , GHC.Stack.Compat+                  , Data.SBV.Utils.SExpr -Executable SBVUnitTests+Test-Suite SBVTest+  type            : exitcode-stdio-1.0   default-language: Haskell2010-  ghc-options     : -Wall+  ghc-options     : -Wall -with-rtsopts=-K64m   other-extensions: DeriveAnyClass-                    Rank2Types-                    RankNTypes-                    ScopedTypeVariables-                    TupleSections-  Build-depends : base  >= 4.8 && < 5-                , HUnit, directory, filepath, process, syb, sbv, data-binary-ieee754-  Hs-Source-Dirs  : SBVUnitTest-  main-is         : SBVUnitTest.hs-  Other-modules   : SBVTest-                  , SBVTestCollection-                  , Examples.Arrays.Memory-                  , Examples.Basics.BasicTests-                  , Examples.Basics.Higher-                  , Examples.Basics.Index-                  , Examples.Basics.ProofTests-                  , Examples.Basics.QRem-                  , Examples.CRC.CCITT-                  , Examples.CRC.CCITT_Unidir-                  , Examples.CRC.GenPoly-                  , Examples.CRC.Parity-                  , Examples.CRC.USB5-                  , Examples.Puzzles.PowerSet-                  , Examples.Puzzles.Temperature-                  , Examples.Uninterpreted.Uninterpreted+                  , DeriveDataTypeable+                  , Rank2Types+                  , ScopedTypeVariables+  Build-depends : base >= 4.9, data-binary-ieee754, filepath, syb+                , sbv, directory, random, mtl+                , template-haskell >= 2.11+                , bytestring   >= 0.9+                , tasty        >= 0.11.2.3+                , tasty-golden >= 2.3.1.1+                , tasty-hunit  >= 0.9.2+  Hs-Source-Dirs  : SBVTestSuite+  main-is         : SBVTest.hs+  Other-modules   : Utils.SBVTestFramework                   , TestSuite.Arrays.Memory+                  , TestSuite.Basics.AllSat                   , TestSuite.Basics.ArithNoSolver                   , TestSuite.Basics.ArithSolver                   , TestSuite.Basics.BasicTests+                  , TestSuite.Basics.GenBenchmark                   , TestSuite.Basics.Higher                   , TestSuite.Basics.Index                   , TestSuite.Basics.IteTest                   , TestSuite.Basics.ProofTests+                  , TestSuite.Basics.PseudoBoolean                   , TestSuite.Basics.QRem+                  , TestSuite.Basics.Quantifiers+                  , TestSuite.Basics.Recursive+                  , TestSuite.Basics.SquashReals+                  , TestSuite.Basics.TOut                   , TestSuite.BitPrecise.BitTricks                   , TestSuite.BitPrecise.Legato                   , TestSuite.BitPrecise.MergeSort@@ -189,16 +191,22 @@                   , TestSuite.CodeGeneration.GCD                   , TestSuite.CodeGeneration.PopulationCount                   , TestSuite.CodeGeneration.Uninterpreted-                  , TestSuite.Crypto.AES-                  , TestSuite.Crypto.RC4-                  , TestSuite.Existentials.CRCPolynomial                   , TestSuite.CRC.CCITT                   , TestSuite.CRC.CCITT_Unidir                   , TestSuite.CRC.GenPoly                   , TestSuite.CRC.Parity                   , TestSuite.CRC.USB5-                  , TestSuite.Puzzles.Coins+                  , TestSuite.Crypto.AES+                  , TestSuite.Crypto.RC4+                  , TestSuite.Existentials.CRCPolynomial+                  , TestSuite.GenTest.GenTests+                  , TestSuite.Optimization.AssertSoft+                  , TestSuite.Optimization.Basics+                  , TestSuite.Optimization.Combined+                  , TestSuite.Optimization.ExtensionField+                  , TestSuite.Optimization.Reals                   , TestSuite.Polynomials.Polynomials+                  , TestSuite.Puzzles.Coins                   , TestSuite.Puzzles.Counts                   , TestSuite.Puzzles.DogCatMouse                   , TestSuite.Puzzles.Euler185@@ -206,21 +214,34 @@                   , TestSuite.Puzzles.NQueens                   , TestSuite.Puzzles.PowerSet                   , TestSuite.Puzzles.Sudoku-                  , TestSuite.Puzzles.U2Bridge                   , TestSuite.Puzzles.Temperature+                  , TestSuite.Puzzles.U2Bridge+                  , TestSuite.Queries.BasicQuery+                  , TestSuite.Queries.Enums+                  , TestSuite.Queries.FreshVars+                  , TestSuite.Queries.Int_ABC+                  , TestSuite.Queries.Int_Boolector+                  , TestSuite.Queries.Int_CVC4+                  , TestSuite.Queries.Int_Mathsat+                  , TestSuite.Queries.Int_Yices+                  , TestSuite.Queries.Int_Z3+                  , TestSuite.Queries.Uninterpreted                   , TestSuite.Uninterpreted.AUF+                  , TestSuite.Uninterpreted.Axioms                   , TestSuite.Uninterpreted.Function-                  , TestSuite.Uninterpreted.Uninterpreted                   , TestSuite.Uninterpreted.Sort-                  , TestSuite.Uninterpreted.Axioms+                  , TestSuite.Uninterpreted.Uninterpreted -Test-Suite SBVBasicTests-  type            : exitcode-stdio-1.0-  default-language: Haskell2010-  ghc-options     : -Wall -with-rtsopts=-K64m-  Build-depends : base >= 4.8 && < 5-                , HUnit, directory, filepath, syb, sbv, data-binary-ieee754-  Hs-Source-Dirs  : SBVUnitTest-  main-is         : SBVBasicTests.hs-  Other-modules   : SBVBasicTests-                  , SBVTestCollection+Test-Suite SBVDocTest+    Build-Depends:    base, doctest >= 0.9, Glob >= 0.7+    default-language: Haskell2010+    Hs-Source-Dirs  : SBVTestSuite+    main-is:          SBVDocTest.hs+    type:             exitcode-stdio-1.0++Test-Suite SBVHLint+    build-depends:    base, hlint >= 2.0.9+    default-language: Haskell2010+    hs-source-dirs:   SBVTestSuite+    main-is:          SBVHLint.hs+    type:             exitcode-stdio-1.0