packages feed

Noise 1.0.0 → 1.0.1

raw patch · 148 files changed

+36015/−16 lines, 148 filesbinary-addedPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

Noise.cabal view
@@ -1,27 +1,25 @@-name:          Noise-version:       1.0.0-maintainer:    Hugo Daniel <hugodaniel@hackological.com>-cabal-version: >= 1.6-build-type:    Simple-category:      Math-synopsis:      A Haskell coherent noise generator-description:   A Haskell coherent noise generator roughly based on libnoise.-               For more information on libnoise, please check: <http://libnoise.sourceforge.net>.-               .+Name:          Noise+Version:       1.0.1+Maintainer:    Hugo Gomes <mr.hugo.gomes@gmail.com>+Cabal-version: >= 1.6+Build-type:    Simple+Category:      Math+Synopsis:      A Haskell coherent noise generator+Description:   A Haskell coherent noise generator roughly based on libnoise.+               For more information on libnoise, please check: <http://libnoise.sourceforge.net>                The noise modules were extensively profiled and benchmarked,                the slower pure functions were rewritten in C.                The main objective of this packer is to provide a simple interface                 to compose noise modules.-               .                You could compose several noise modules like this:                .                > myPerlin = perlin `isSourceOf` scalebias { scale = 1.0 } -                                   `isSourceOf` absolute+               >                   `isSourceOf` absolute                > myComposition = perlin { perlinFrequency = 0.123 } -                                 `andModule` billow { billowOctaves = 12 } -                                 `andModule` myPerlin -                                 `areSourcesOf` -                                 select { upperBound = 0.7, lowerBound = 0.2 }+               >                 `andModule` billow { billowOctaves = 12 } +               >                 `andModule` myPerlin +               >                 `areSourcesOf` +               >                 select { upperBound = 0.7, lowerBound = 0.2 }                .                This is a 3D noise package, to get a value you need to specify a                triple:
+ Temp/Biobase-0.3.1.1.tar.gz view

binary file changed (absent → 92344 bytes)

+ Temp/sbv-0.9.18.tar.gz view

binary file changed (absent → 320911 bytes)

+ Temp/sbv-0.9.18/.sbv.cabal.swp view

binary file changed (absent → 16384 bytes)

+ Temp/sbv-0.9.18/COPYRIGHT view
@@ -0,0 +1,5 @@+Copyright (c) 2010-2011, Levent Erkok (erkokl@gmail.com)+All rights reserved.++The sbv library is distributed with the BSD3 license. See the LICENSE file+for details.
+ Temp/sbv-0.9.18/Data/SBV.hs view
@@ -0,0 +1,277 @@+---------------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- (The sbv library is hosted at <http://github.com/LeventErkok/sbv>.+-- Comments, bug reports, and patches are always welcome.)+--+-- SBV: Symbolic Bit Vectors in Haskell+--+-- Express properties about bit-precise Haskell programs and automatically prove+-- them using SMT solvers.+--+-- >>> prove $ \x -> x `shiftL` 2 .== 4 * (x :: SWord8)+-- Q.E.D.+--+-- >>> prove $ forAll ["x"] $ \x -> x `shiftL` 2 .== (x :: SWord8)+-- Falsifiable. Counter-example:+--   x = 128 :: SWord8+--+-- The function 'prove' has the following type:+--+-- @+--     'prove' :: 'Provable' a => a -> 'IO' 'ThmResult'+-- @+--+-- The class 'Provable' comes with instances for n-ary predicates, for arbitrary n.+-- The predicates are just regular Haskell functions over symbolic signed and unsigned+-- bit-vectors. Functions for checking satisfiability ('sat' and 'allSat') are also+-- provided.+--+-- In particular, the sbv library introduces the types:+--+--   * 'SBool': Symbolic Booleans (bits)+--+--   * 'SWord8', 'SWord16', 'SWord32', 'SWord64': Symbolic Words (unsigned)+--+--   * 'SInt8',  'SInt16',  'SInt32',  'SInt64': Symbolic Ints (signed)+--+--   * 'SArray', 'SFunArray': Flat arrays of symbolic values+--+--   * Symbolic polynomials over GF(2^n), and polynomial arithmetic+--+--   * Uninterpreted constants and functions over symbolic values, with user+--     defined SMT-Lib axioms+--+-- The user can construct ordinary Haskell programs using these types, which behave+-- very similar to their concrete counterparts. In particular these types belong to the+-- standard classes 'Num', 'Bits', custom versions of 'Eq' ('EqSymbolic') +-- and 'Ord' ('OrdSymbolic'), along with several other custom classes for simplifying+-- bit-precise programming with symbolic values. The framework takes full advantage+-- of Haskell's type inference to avoid many common mistakes.+--+-- Furthermore, predicates (i.e., functions that return 'SBool') built out of+-- these types can also be:+--+--   * proven correct via an external SMT solver (the 'prove' function)+--+--   * checked for satisfiability (the 'sat' and 'allSat' functions)+--+--   * quick-checked+--+-- 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.+--+-- The sbv library uses third-party SMT solvers via the standard SMT-Lib interface:+-- <http://goedel.cs.uiowa.edu/smtlib/>.+--+-- While the library is designed to work with any SMT-Lib compliant SMT-solver,+-- solver specific support is required for parsing counter-example/model data since+-- there is currently no agreed upon format for getting models from arbitrary SMT+-- solvers. (The SMT-Lib2 initiative will potentially address this issue in the+-- future, at which point the sbv library can be generalized as well.) Currently, we+-- only support the Yices SMT solver from SRI as far as the counter-example+-- and model generation support is concerned: <http://yices.csl.sri.com/>.+-- However, other solvers can be hooked up with relative ease.+--+-- You /should/ download and install Yices on your machine, and make sure the+-- @yices@ executable is in your path before using the sbv library, as it is the+-- current default solver. Alternatively, you can specify the location of yices+-- executable in the environment variable @SBV_YICES@ and the options to yices+-- in @SBV_YICES_OPTIONS@. (The default for the latter is '\"-m -f\"'.)+---------------------------------------------------------------------------------++module Data.SBV (+  -- * Programming with symbolic values+  -- $progIntro++  -- ** Symbolic types++  -- *** Symbolic bit+    SBool+  -- *** Unsigned symbolic bit-vectors+  , SWord8, SWord16, SWord32, SWord64+  -- *** Signed symbolic bit-vectors+  , SInt8, SInt16, SInt32, SInt64+  -- *** Arrays of symbolic values+  , SymArray(..), SArray, SFunArray, mkSFunArray+  -- ** Operations on symbolic words+  -- *** Word level+  , bitValue, setBitTo, oneIf, lsb, msb+  -- *** List level+  , allEqual, allDifferent+  -- *** Blasting/Unblasting+  , blastBE, blastLE, FromBits(..)+  -- *** Splitting, joining, and extending+  , Splittable(..)+  -- ** Polynomial arithmetic+  , Polynomial(..)+  -- ** Conditionals: Mergeable values+  , Mergeable(..)+  -- ** Symbolic equality+  , EqSymbolic(..)+  -- ** Symbolic ordering+  , OrdSymbolic(..)+  -- ** Division+  , BVDivisible(..)+  -- ** The Boolean class+  , Boolean(..)+  -- *** Generalizations of boolean operations+  , bAnd, bOr, bAny, bAll+  -- ** Pretty-printing and reading numbers in Hex & Binary+  , PrettyNum(..), readBin+  -- * Uninterpreted constants and functions+  , Uninterpreted(..)+  -- ** Accessing the handle+  , SBVUF, sbvUFName+  -- ** Adding axioms+  , addAxiom++  -- * Proving properties+  -- $proveIntro++  -- ** Predicates+  , Predicate, Provable(..), Equality(..)+  -- ** Proving properties+  , prove, proveWith, isTheorem, isTheoremWithin+  -- ** Checking satisfiability+  , sat, satWith, isSatisfiable, isSatisfiableWithin+  -- ** Finding all satisfying assignments+  , allSat, allSatWith, numberOfModels+  -- * Model extraction+  -- $modelExtraction++  -- ** Inspecting proof results+  -- $resultTypes+  , ThmResult(..), SatResult(..), AllSatResult(..), SMTResult(..)++  -- ** Programmable model extraction+  -- $programmableExtraction+  , SatModel(..), getModel, displayModels++  -- * SMT Interface: Configurations and solvers+  , SMTConfig(..), SMTSolver(..), defaultSMTCfg, verboseSMTCfg, timingSMTCfg, verboseTimingSMTCfg, timeout+  , yices++  -- * Symbolic computations+  , Symbolic, output, SymWord(..)++  -- * Getting SMT-Lib output (for offline analysis)+  , compileToSMTLib++  -- * Code generation from symbolic programs+  -- $cCodeGeneration+  , SBVCodeGen++  -- ** Setting code-generation options+  , cgPerformRTCs, cgSetDriverValues++  -- ** Designating inputs+  , cgInput, cgInputArr++  -- ** Designating outputs+  , cgOutput, cgOutputArr++  -- ** Designating return values+  , cgReturn, cgReturnArr++  -- ** Compilation to C+  , compileToC, compileToCLib++  -- * Module exports+  -- $moduleExportIntro++  , module Data.Bits+  , module Data.Word+  , module Data.Int+  ) where++import Data.SBV.BitVectors.Data+import Data.SBV.BitVectors.Model+import Data.SBV.BitVectors.PrettyNum+import Data.SBV.BitVectors.Polynomial+import Data.SBV.BitVectors.Splittable+import Data.SBV.Compilers.C+import Data.SBV.Compilers.CodeGen+import Data.SBV.Provers.Prover+import Data.SBV.Utils.Boolean+import Data.Bits+import Data.Word+import Data.Int++-- Haddock section documentation+{- $progIntro+The SBV library is really two things:++  * A framework for writing bit-precise programs in Haskell++  * A framework for proving properties of such programs using SMT solvers++In this first section we will look at the constructs that will let us construct such+programs in Haskell. The goal is to have a "seamless" experience, i.e., program in+the usual Haskell style without distractions of symbolic coding. While Haskell helps+in some aspects (the 'Num' and 'Bits' classes simplify coding), it makes life harder+in others. For instance, @if-then-else@ only takes 'Bool' as a test in Haskell, and+comparisons ('>' etc.) only return 'Bool's. Clearly we would like these values to be+symbolic (i.e., 'SBool'), thus stopping us from using some native Haskell constructs.+When symbolic versions of operators are needed, they are typically obtained by prepending a dot,+for instance '==' becomes '.=='. Care has been taken to make the transition painless. In+particular, any Haskell program you build out of symbolic components is fully concretely+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.+-}++{- $proveIntro+The SBV library provides a "push-button" verification system via automated SMT solving. The+design goal is to let SMT solvers be used without any knowledge of how SMT solvers work+or how different logics operate. The details are hidden behind the SBV framework, providing+Haskell programmers with a clean API that is unencumbered by the details of individual solvers.+To that end, we use the SMT-Lib standard (<http://goedel.cs.uiowa.edu/smtlib/>)+to communicate with arbitrary SMT solvers. Unfortunately,+the SMT-Lib version 1.X does not standardize how models are communicated back from solvers, so+there is some work in parsing individual SMT solver output. The 2.X version of the SMT-Lib+standard (not yet implemented by SMT solvers widely, unfortunately) will bring new standard features+for getting models; at which time the SBV framework can be modified into a truly plug-and-play+system where arbitrary SMT solvers can be used.+-}++{- $modelExtraction+The default 'Show' instances for prover calls provide all the counter-example information in a+human-readable form and should be sufficient for most casual uses of sbv. However, tools built+on top of sbv will inevitably need to look into the constructed models more deeply, programmatically+extracting their results and performing actions based on them. The API provided in this section+aims at simplifying this task.+-}++{- $resultTypes+'ThmResult', 'SatResult', and 'AllSatResult' are simple newtype wrappers over 'SMTResult'. Their+main purpose is so that we can provide custom 'Show' instances to print results accordingly.+-}++{- $programmableExtraction+While default 'Show' instances are sufficient for most use cases, it is sometimes desirable (especially+for library construction) that the SMT-models are reinterpreted in terms of domain types. Programmable+extraction allows getting arbitrarily typed models out of SMT models.+-}++{- $cCodeGeneration+The SBV library can generate straight-line executable code in C. (While other target languages are+certainly possible, currently only C is supported.) The generated code will perform no run-time memory-allocations,+(no calls to @malloc@), so its memory usage can be predicted ahead of time. Also, the functions will execute precisely the+same instructions in all calls, so they have predictable timing properties as well. The generated code+has no loops or jumps, and is typically quite fast. While the generated code can be large due to complete unrolling,+these characteristics make them suitable for use in hard real-time systems, as well as in traditional computing.+-}++{- $moduleExportIntro+The SBV library exports the following modules wholesale, as user programs will have to import these+three modules to make any sensible use of the SBV functionality.+-}
+ Temp/sbv-0.9.18/Data/SBV/BitVectors/Data.hs view
@@ -0,0 +1,760 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.BitVectors.Data+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Internal data-structures for the sbv library+-----------------------------------------------------------------------------++{-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE TypeSynonymInstances       #-}+{-# LANGUAGE TypeOperators              #-}+{-# LANGUAGE MultiParamTypeClasses      #-}+{-# LANGUAGE ScopedTypeVariables        #-}+{-# LANGUAGE FlexibleInstances          #-}+{-# LANGUAGE PatternGuards              #-}++module Data.SBV.BitVectors.Data+ ( SBool, SWord8, SWord16, SWord32, SWord64+ , SInt8, SInt16, SInt32, SInt64+ , SymWord(..)+ , CW, cwVal, cwSameType, cwIsBit, cwToBool+ , mkConstCW ,liftCW2, mapCW, mapCW2+ , SW(..), trueSW, falseSW, trueCW, falseCW+ , SBV(..), NodeId(..), mkSymSBV+ , ArrayContext(..), ArrayInfo, SymArray(..), SFunArray(..), mkSFunArray, SArray(..), arrayUIKind+ , sbvToSW, sbvToSymSW+ , SBVExpr(..), newExpr+ , cache, uncache, uncacheAI, HasSignAndSize(..)+ , Op(..), NamedSymVar, UnintKind(..), getTableIndex, Pgm, Symbolic, runSymbolic, runSymbolic', State, Size, Outputtable(..), Result(..)+ , SBVType(..), newUninterpreted, unintFnUIKind, addAxiom+ ) where++import Control.DeepSeq                 (NFData(..))+import Control.Monad.Reader            (MonadReader, ReaderT, ask, runReaderT)+import Control.Monad.Trans             (MonadIO, liftIO)+import Data.Char                       (isAlpha, isAlphaNum)+import Data.Int                        (Int8, Int16, Int32, Int64)+import Data.Word                       (Word8, Word16, Word32, Word64)+import Data.IORef                      (IORef, newIORef, modifyIORef, readIORef, writeIORef)+import Data.List                       (intercalate, sortBy)++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)+import qualified Data.Foldable as F    (toList)+import qualified Data.Sequence as S    (Seq, empty, (|>))++import System.Mem.StableName+import Test.QuickCheck                 (Testable(..))++import Data.SBV.Utils.Lib++-- | 'CW' represents a concrete word of a fixed size:+-- Endianness is mostly irrelevant (see the 'FromBits' class).+-- For signed words, the most significant digit is considered to be the sign+data CW = CW { cwSigned :: !Bool, cwSize :: !Size, cwVal :: !Integer }+        deriving (Eq, Ord)++cwSameType :: CW -> CW -> Bool+cwSameType x y = cwSigned x == cwSigned y && cwSize x == cwSize y++cwIsBit :: CW -> Bool+cwIsBit x = not (cwSigned x) && cwSize x == 1++cwToBool :: CW -> Bool+cwToBool x = cwVal x /= 0++normCW :: CW -> CW+normCW x = x { cwVal = norm }+  where norm | cwSize x == 0  = 0+             | cwSigned x     = let rg = 2 ^ (cwSize x - 1)+                                in case divMod (cwVal x) rg of+                                    (a, b) | even a -> b+                                    (_, b)          -> b - rg+             | True           = cwVal x `mod` (2 ^ cwSize x)++type Size      = Int+newtype NodeId = NodeId Int deriving (Eq, Ord)+data SW        = SW (Bool, Size) NodeId deriving (Eq, Ord)++falseSW, trueSW :: SW+falseSW = SW (False, 1) $ NodeId (-2)+trueSW  = SW (False, 1) $ NodeId (-1)++falseCW, trueCW :: CW+falseCW = CW False 1 0+trueCW  = CW False 1 1++newtype SBVType = SBVType [(Bool, Size)]+             deriving (Eq, Ord)++-- how many arguments does the type take?+typeArity :: SBVType -> Int+typeArity (SBVType xs) = length xs - 1++instance Show SBVType where+  show (SBVType []) = error "SBV: internal error, empty SBVType"+  show (SBVType xs) = intercalate " -> " $ map sh xs+    where sh (False, 1) = "SBool"+          sh (s, sz)    = (if s then "SInt" else "SWord") ++ show sz++data Op = Plus | Times | Minus+        | Quot | Rem -- quot and rem are unsigned only+        | Equal | NotEqual+        | LessThan | GreaterThan | LessEq | GreaterEq+        | Ite+        | And | Or  | XOr | Not+        | Shl Int | Shr Int | Rol Int | Ror Int+        | Extract Int Int -- Extract i j: extract bits i to j. Least significant bit is 0 (big-endian)+        | Join  -- Concat two words to form a bigger one, in the order given+        | LkUp (Int, (Bool, Int), (Bool, Int), Int) !SW !SW   -- (table-index, arg-type, res-type, length of the table) index out-of-bounds-value+        | ArrEq   Int Int+        | ArrRead Int+        | Uninterpreted String+        deriving (Eq, Ord)+data SBVExpr = SBVApp !Op ![SW]+             deriving (Eq, Ord)++class HasSignAndSize a where+  sizeOf   :: a -> Size+  hasSign  :: a -> Bool+  showType :: a -> String+  showType a+    | not (hasSign a) && sizeOf a == 1 = "SBool"+    | True                             = (if hasSign a then "SInt" else "SWord") ++ show (sizeOf a)++instance HasSignAndSize Bool   where {sizeOf _ =  1; hasSign _ = False}+instance HasSignAndSize Int8   where {sizeOf _ =  8; hasSign _ = True }+instance HasSignAndSize Word8  where {sizeOf _ =  8; hasSign _ = False}+instance HasSignAndSize Int16  where {sizeOf _ = 16; hasSign _ = True }+instance HasSignAndSize Word16 where {sizeOf _ = 16; hasSign _ = False}+instance HasSignAndSize Int32  where {sizeOf _ = 32; hasSign _ = True }+instance HasSignAndSize Word32 where {sizeOf _ = 32; hasSign _ = False}+instance HasSignAndSize Int64  where {sizeOf _ = 64; hasSign _ = True }+instance HasSignAndSize Word64 where {sizeOf _ = 64; hasSign _ = False}++liftCW :: (Integer -> b) -> CW -> b+liftCW f x = f (cwVal x)++liftCW2 :: (Integer -> Integer -> b) -> CW -> CW -> b+liftCW2 f x y | cwSameType x y = f (cwVal x) (cwVal y)+liftCW2 _ a b = error $ "SBV.liftCW2: impossible, incompatible args received: " ++ show (a, b)++mapCW :: (Integer -> Integer) -> CW -> CW+mapCW f x  = normCW $ x { cwVal = f (cwVal x) }++mapCW2 :: (Integer -> Integer -> Integer) -> CW -> CW -> CW+mapCW2 f x y+  | cwSameType x y = normCW $ CW (cwSigned x) (cwSize y) (f (cwVal x) (cwVal y))+mapCW2 _ a b = error $ "SBV.mapCW2: impossible, incompatible args received: " ++ show (a, b)++instance HasSignAndSize CW where+  sizeOf  = cwSize+  hasSign = cwSigned++instance HasSignAndSize SW where+  sizeOf  (SW (_, s) _) = s+  hasSign (SW (b, _) _) = b++instance Show CW where+  show w | cwIsBit w = show (cwToBool w)+  show w             = liftCW show w ++ " :: " ++ showType w++instance Show SW where+  show (SW _ (NodeId n))+    | n < 0 = "s_" ++ show (abs n)+    | True  = 's' : show n++instance Show Op where+  show (Shl i) = "<<"  ++ show i+  show (Shr i) = ">>"  ++ show i+  show (Rol i) = "<<<" ++ show i+  show (Ror i) = ">>>" ++ show i+  show (Extract i j) = "choose [" ++ show i ++ ":" ++ show j ++ "]"+  show (LkUp (ti, at, rt, l) i e)+        = "lookup(" ++ tinfo ++ ", " ++ show i ++ ", " ++ show e ++ ")"+        where tinfo = "table" ++ show ti ++ "(" ++ show at ++ " -> " ++ show rt ++ ", " ++ show l ++ ")"+  show (ArrEq i j)   = "array_" ++ show i ++ " == array_" ++ show j+  show (ArrRead i)   = "select array_" ++ show i+  show (Uninterpreted i) = "uninterpreted_" ++ i+  show op+    | Just s <- op `lookup` syms = s+    | True                       = error "impossible happened; can't find op!"+    where syms = [ (Plus, "+"), (Times, "*"), (Minus, "-")+                 , (Quot, "quot")+                 , (Rem,  "rem")+                 , (Equal, "=="), (NotEqual, "/=")+                 , (LessThan, "<"), (GreaterThan, ">"), (LessEq, "<"), (GreaterEq, ">")+                 , (Ite, "if_then_else")+                 , (And, "&"), (Or, "|"), (XOr, "^"), (Not, "~")+                 , (Join, "#")+                 ]++reorder :: SBVExpr -> SBVExpr+reorder s = case s of+              SBVApp op [a, b] | isCommutative op && a > b -> SBVApp op [b, a]+              _ -> s+  where isCommutative :: Op -> Bool+        isCommutative o = o `elem` [Plus, Times, Equal, NotEqual, And, Or, XOr]++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]+  show (SBVApp (Shr i) [a])   = unwords [show a, ">>", show i]+  show (SBVApp (Rol i) [a])   = unwords [show a, "<<<", show i]+  show (SBVApp (Ror i) [a])   = unwords [show a, ">>>", show i]+  show (SBVApp op  [a, b])    = unwords [show a, show op, show b]+  show (SBVApp op  args)      = unwords (show op : map show args)++-- | A program is a sequence of assignments+type Pgm         = S.Seq (SW, SBVExpr)++-- | 'NamedSymVar' pairs symbolic words and user given/automatically generated names+type NamedSymVar = (SW, String)++-- | 'UnintKind' pairs array names and uninterpreted constants with their "kinds"+-- used mainly for printing counterexamples+data UnintKind = UFun Int String | UArr Int String      -- in each case, arity and the aliasing name+ deriving Show++-- | Result of running a symbolic computation+data Result = Result [NamedSymVar]                              -- inputs+                     [(SW, CW)]                                 -- constants+                     [((Int, (Bool, Int), (Bool, Int)), [SW])]  -- tables (automatically constructed) (tableno, index-type, result-type) elts+                     [(Int, ArrayInfo)]                         -- arrays (user specified)+                     [(String, SBVType)]                        -- uninterpreted constants+                     [(String, [String])]                       -- axioms+                     Pgm                                        -- assignments+                     [SW]                                       -- outputs++instance Show Result where+  show (Result _ cs _ _ [] [] _ [r])+    | Just c <- r `lookup` cs+    = show c+  show (Result is cs ts as uis axs xs os)  = intercalate "\n" $+                   ["INPUTS"]+                ++ map shn is+                ++ ["CONSTANTS"]+                ++ map shc cs+                ++ ["TABLES"]+                ++ map sht ts+                ++ ["ARRAYS"]+                ++ map sha as+                ++ ["UNINTERPRETED CONSTANTS"]+                ++ map shui uis+                ++ ["AXIOMS"]+                ++ map shax axs+                ++ ["DEFINE"]+                ++ map (\(s, e) -> "  " ++ shs s ++ " = " ++ show e) (F.toList xs)+                ++ ["OUTPUTS"]+                ++ map (("  " ++) . show) os+    where shs sw = show sw ++ " :: " ++ showType sw+          sht ((i, at, rt), es)  = "  Table " ++ show i ++ " : " ++ show at ++ "->" ++ show rt ++ " = " ++ show es+          shc (sw, cw) = "  " ++ show sw ++ " = " ++ show cw+          shn (sw, nm) = "  " ++ ni ++ " :: " ++ showType sw ++ alias+            where ni = show sw+                  alias | ni == nm = ""+                        | True     = ", aliasing " ++ show nm+          sha (i, (nm, (ai, bi), ctx)) = "  " ++ ni ++ " :: " ++ mkT ai ++ " -> " ++ mkT bi ++ alias+                                       ++ "\n     Context: "     ++ show ctx+            where mkT (b, s)+                   | s == 1  = "SBool"+                   | True    = if b then "SInt" else "SWord" ++ show s+                  ni = "array_" ++ show i+                  alias | ni == nm = ""+                        | True     = ", aliasing " ++ show nm+          shui (nm, t) = "  uninterpreted_" ++ nm ++ " :: " ++ show t+          shax (nm, ss) = "  -- user defined axiom: " ++ nm ++ "\n  " ++ intercalate "\n  " ss++data ArrayContext = ArrayFree (Maybe SW)+                  | ArrayReset Int SW+                  | ArrayMutate Int SW SW+                  | ArrayMerge  SW Int Int++instance Show ArrayContext where+  show (ArrayFree Nothing)  = " initialized with random elements"+  show (ArrayFree (Just s)) = " initialized with " ++ show s ++ " :: " ++ showType s+  show (ArrayReset i s)     = " reset array_" ++ show i ++ " with " ++ show s ++ " :: " ++ showType s+  show (ArrayMutate i a b)  = " cloned from array_" ++ show i ++ " with " ++ show a ++ " :: " ++ showType a ++ " |-> " ++ show b ++ " :: " ++ showType b+  show (ArrayMerge s i j)   = " merged arrays " ++ show i ++ " and " ++ show j ++ " on condition " ++ show s++type ExprMap   = Map.Map SBVExpr SW+type CnstMap   = Map.Map CW SW+type TableMap  = Map.Map [SW] (Int, (Bool, Int), (Bool, Int))+type ArrayInfo = (String, ((Bool, Size), (Bool, Size)), ArrayContext)+type ArrayMap  = IMap.IntMap ArrayInfo+type UIMap     = Map.Map String SBVType+type Cache a   = IMap.IntMap [(StableName (State -> IO a), a)]++unintFnUIKind :: (String, SBVType) -> (String, UnintKind)+unintFnUIKind (s, t) = (s, UFun (typeArity t) s)++arrayUIKind :: (Int, ArrayInfo) -> Maybe (String, UnintKind)+arrayUIKind (i, (nm, _, ctx)) +  | external ctx = Just ("array_" ++ show i, UArr 1 nm) -- arrays are always 1-dimensional in the SMT-land. (Unless encoded explicitly)+  | True         = Nothing+  where external (ArrayFree{})   = True+        external (ArrayReset{})  = False+        external (ArrayMutate{}) = False+        external (ArrayMerge{})  = False++data State  = State { rctr       :: IORef Int+                    , rinps      :: IORef [NamedSymVar]+                    , routs      :: IORef [SW]+                    , rtblMap    :: IORef TableMap+                    , spgm       :: IORef Pgm+                    , rconstMap  :: IORef CnstMap+                    , rexprMap   :: IORef ExprMap+                    , rArrayMap  :: IORef ArrayMap+                    , rUIMap     :: IORef UIMap+                    , raxioms    :: IORef [(String, [String])]+                    , rSWCache   :: IORef (Cache SW)+                    , rAICache   :: IORef (Cache Int)+                    }++-- | The "Symbolic" value. Either a constant (@Left@) or a symbolic+-- value (@Right Cached@). Note that caching is essential for making+-- sure sharing is preserved. The parameter 'a' is phantom, but is+-- extremely important in keeping the user interface strongly typed.+data SBV a = SBV !(Bool, Size) !(Either CW (Cached SW))++-- | A symbolic boolean/bit+type SBool   = SBV Bool++-- | 8-bit unsigned symbolic value+type SWord8  = SBV Word8++-- | 16-bit unsigned symbolic value+type SWord16 = SBV Word16++-- | 32-bit unsigned symbolic value+type SWord32 = SBV Word32++-- | 64-bit unsigned symbolic value+type SWord64 = SBV Word64++-- | 8-bit signed symbolic value, 2's complement representation+type SInt8   = SBV Int8++-- | 16-bit signed symbolic value, 2's complement representation+type SInt16  = SBV Int16++-- | 32-bit signed symbolic value, 2's complement representation+type SInt32  = SBV Int32++-- | 64-bit signed symbolic value, 2's complement representation+type SInt64  = SBV Int64++-- Needed to satisfy the Num hierarchy+instance Show (SBV a) where+  show (SBV _         (Left c))  = show c+  show (SBV (sgn, sz) (Right _)) = "<symbolic> :: " ++ t+                where t | not sgn && sz == 1 = "SBool"+                        | True               = (if sgn then "SInt" else "SWord") ++ show sz++instance Eq (SBV a) where+  SBV _ (Left a) == SBV _ (Left b) = a == b+  a == b = error $ "Comparing symbolic bit-vectors; Use (.==) instead. Received: " ++ show (a, b)+  SBV _ (Left a) /= SBV _ (Left b) = a /= b+  a /= b = error $ "Comparing symbolic bit-vectors; Use (./=) instead. Received: " ++ show (a, b)++instance HasSignAndSize (SBV a) where+  sizeOf  (SBV (_, s) _) = s+  hasSign (SBV (b, _) _) = b++incCtr :: State -> IO Int+incCtr s = do ctr <- readIORef (rctr s)+              let i = ctr + 1+              i `seq` writeIORef (rctr s) i+              return ctr++newUninterpreted :: State -> String -> SBVType -> IO ()+newUninterpreted st nm t+  | null nm || not (isAlpha (head nm)) || not (all isAlphaNum (tail nm))+  = error $ "Bad uninterpreted constant name: " ++ show nm ++ ". Must be a valid identifier."+  | True = do+        uiMap <- readIORef (rUIMap st)+        case nm `Map.lookup` uiMap of+          Just t' -> if t /= t'+                     then error $  "Uninterpreted constant " ++ show nm ++ " used at incompatible types\n"+                                ++ "      Current type      : " ++ show t ++ "\n"+                                ++ "      Previously used at: " ++ show t'+                     else return ()+          Nothing -> modifyIORef (rUIMap st) (Map.insert nm t)++-- Create a new constant; hash-cons as necessary+newConst :: State -> CW -> IO SW+newConst st c = do+  constMap <- readIORef (rconstMap st)+  case c `Map.lookup` constMap of+    Just sw -> return sw+    Nothing -> do ctr <- incCtr st+                  let sw = SW (hasSign c, sizeOf c) (NodeId ctr)+                  modifyIORef (rconstMap st) (Map.insert c sw)+                  return sw++-- Create a new table; hash-cons as necessary+getTableIndex :: State -> (Bool, Int) -> (Bool, Int) -> [SW] -> IO Int+getTableIndex st at rt elts = do+  tblMap <- readIORef (rtblMap st)+  case elts `Map.lookup` tblMap of+    Just (i, _, _)  -> return i+    Nothing         -> do let i = Map.size tblMap+                          modifyIORef (rtblMap st) (Map.insert elts (i, at, rt))+                          return i++-- Create a constant word+mkConstCW :: Integral a => (Bool, Size) -> a -> CW+mkConstCW (signed, size) a = normCW $ CW signed size (toInteger a)++-- Create a new expression; hash-cons as necessary+newExpr :: State -> (Bool, Size) -> SBVExpr -> IO SW+newExpr st sgnsz app = do+   let e = reorder app+   exprMap <- readIORef (rexprMap st)+   case e `Map.lookup` exprMap of+     Just sw -> return sw+     Nothing -> do ctr <- incCtr st+                   let sw = SW sgnsz (NodeId ctr)+                   modifyIORef (spgm st)     (flip (S.|>) (sw, e))+                   modifyIORef (rexprMap st) (Map.insert e sw)+                   return sw++sbvToSW :: State -> SBV a -> IO SW+sbvToSW st (SBV _ (Left c))  = newConst st c+sbvToSW st (SBV _ (Right f)) = uncache f st++-------------------------------------------------------------------------+-- * Symbolic Computations+-------------------------------------------------------------------------+-- | A Symbolic computation. Represented by a reader monad carrying the+-- state of the computation, layered on top of IO for creating unique+-- references to hold onto intermediate results.+newtype Symbolic a = Symbolic (ReaderT State IO a)+                   deriving (Monad, MonadIO, MonadReader State)++mkSymSBV :: (Bool, Size) -> Maybe String -> Symbolic (SBV a)+mkSymSBV sgnsz mbNm = do+        st <- ask+        ctr <- liftIO $ incCtr st+        let nm = maybe ('s':show ctr) id mbNm+            sw = SW sgnsz (NodeId ctr)+        liftIO $ modifyIORef (rinps st) ((sw, nm):)+        return $ SBV sgnsz $ Right $ cache (const (return sw))++sbvToSymSW :: SBV a -> Symbolic SW+sbvToSymSW sbv = do+        st <- ask+        liftIO $ sbvToSW st sbv++-- | Mark an interim result as an output. Useful when constructing Symbolic programs+-- that return multiple values, or when the result is programmatically computed.+class Outputtable a where+  output :: a -> Symbolic a++instance Outputtable (SBV a) where+  output i@(SBV _ (Left c)) = do+          st <- ask+          sw <- liftIO $ newConst st c+          liftIO $ modifyIORef (routs st) (sw:)+          return i+  output i@(SBV _ (Right f)) = do+          st <- ask+          sw <- liftIO $ uncache f st+          liftIO $ modifyIORef (routs st) (sw:)+          return i++instance (Outputtable a, Outputtable b) => Outputtable (a, b) where+  output = mlift2 (,) output output++instance (Outputtable a, Outputtable b, Outputtable c) => Outputtable (a, b, c) where+  output = mlift3 (,,) output output output++instance (Outputtable a, Outputtable b, Outputtable c, Outputtable d) => Outputtable (a, b, c, d) where+  output = mlift4 (,,,) output output output output++instance (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e) => Outputtable (a, b, c, d, e) where+  output = mlift5 (,,,,) output output output output output++instance (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e, Outputtable f) => Outputtable (a, b, c, d, e, f) where+  output = mlift6 (,,,,,) output output output output output output++instance (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e, Outputtable f, Outputtable g) => Outputtable (a, b, c, d, e, f, g) where+  output = mlift7 (,,,,,,) output output output output output output output++instance (Outputtable a, Outputtable b, Outputtable c, Outputtable d, Outputtable e, Outputtable f, Outputtable g, Outputtable h) => Outputtable (a, b, c, d, e, f, g, h) where+  output = mlift8 (,,,,,,,) output output output output output output output output++-- | Add a user specified axiom to the generated SMT-Lib file. Note that the input is a+-- mere string; we perform no checking on the input that it's well-formed or is sensical.+-- A separate formalization of SMT-Lib would be very useful here.+addAxiom :: String -> [String] -> Symbolic ()+addAxiom nm ax = do+        st <- ask+        liftIO $ modifyIORef (raxioms st) ((nm, ax) :)++-- | Run a symbolic computation and return a 'Result'+runSymbolic :: Symbolic a -> IO Result+runSymbolic c = do (_, r) <- runSymbolic' c+                   return r++-- | Run a symbolic computation, and return a extra value paired up with the 'Result'+runSymbolic' :: Symbolic a -> IO (a, Result)+runSymbolic' (Symbolic c) = do+   ctr     <- newIORef (-2) -- start from -2; False and True will always occupy the first two elements+   pgm     <- newIORef S.empty+   emap    <- newIORef Map.empty+   cmap    <- newIORef Map.empty+   inps    <- newIORef []+   outs    <- newIORef []+   tables  <- newIORef Map.empty+   arrays  <- newIORef IMap.empty+   uis     <- newIORef Map.empty+   axioms  <- newIORef []+   swCache <- newIORef IMap.empty+   aiCache <- newIORef IMap.empty+   let st = State { rctr      = ctr+                  , rinps     = inps+                  , routs     = outs+                  , rtblMap   = tables+                  , spgm      = pgm+                  , rconstMap = cmap+                  , rArrayMap = arrays+                  , rexprMap  = emap+                  , rUIMap    = uis+                  , raxioms   = axioms+                  , rSWCache  = swCache+                  , rAICache  = aiCache+                  }+   _ <- newConst st (mkConstCW (False,1) (0::Integer)) -- s(-2) == falseSW+   _ <- newConst st (mkConstCW (False,1) (1::Integer)) -- s(-1) == trueSW+   r <- runReaderT c st+   rpgm  <- readIORef pgm+   inpsR <- readIORef inps+   outsR <- readIORef outs+   let swap (a, b) = (b, a)+       cmp  (a, _) (b, _) = a `compare` b+   cnsts <- (sortBy cmp . map swap . Map.toList) `fmap` readIORef (rconstMap st)+   tbls  <- (sortBy (\((x, _, _), _) ((y, _, _), _) -> x `compare` y) . map swap . Map.toList) `fmap` readIORef tables+   arrs  <- IMap.toAscList `fmap` readIORef arrays+   unint <- Map.toList `fmap` readIORef uis+   axs   <- reverse `fmap` readIORef axioms+   return $ (r, Result (reverse inpsR) cnsts tbls arrs unint axs rpgm (reverse outsR))++-------------------------------------------------------------------------------+-- * Symbolic Words+-------------------------------------------------------------------------------+-- | A 'SymWord' is a potential symbolic bitvector that can be created instances of+-- to be fed to a symbolic program. Note that these methods are typically not needed+-- in casual uses with 'prove', 'sat', 'allSat' etc, as default instances automatically+-- provide the necessary bits.+--+-- Minimal complete definiton: free, free_, literal, fromCW+class (Bounded a, Ord a) => SymWord a where+  -- | Create a user named input+  free       :: String -> Symbolic (SBV a)+  -- | Create an automatically named input+  free_      :: Symbolic (SBV a)+  -- | Get a bunch of new words+  mkFreeVars   :: Int -> Symbolic [SBV a]+  -- | Turn a literal constant to symbolic+  literal    :: a -> SBV a+  -- | Extract a literal, if the value is concrete+  unliteral  :: SBV a -> Maybe a+  -- | Extract a literal, from a CW representation+  fromCW     :: CW -> a+  -- | Is the symbolic word concrete?+  isConcrete :: SBV a -> Bool+  -- | Is the symbolic word really symbolic?+  isSymbolic :: SBV a -> Bool+  -- | Does it concretely satisfy the given predicate?+  isConcretely :: SBV a -> (a -> Bool) -> Bool++  -- minimal complete definiton: free, free_, literal, fromCW+  mkFreeVars n = mapM (const free_) [1 .. n]+  unliteral (SBV _ (Left c))  = Just $ fromCW c+  unliteral _                 = Nothing+  isConcrete (SBV _ (Left _)) = True+  isConcrete _                = False+  isSymbolic = not . isConcrete+  isConcretely s p+    | Just i <- unliteral s = p i+    | True                  = False++---------------------------------------------------------------------------------+-- * Symbolic Arrays+---------------------------------------------------------------------------------++-- | 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. +--+-- While it's certainly possible for user to create instances of 'SymArray', the+-- 'SArray' and 'SFunArray' instances already provided should cover most use cases+-- in practice. (There are some differences between these models, however, see the corresponding+-- declaration.)+--+--+-- Minimal complete definition: All methods are required, no defaults.+class SymArray array where+  -- | Create a new array, with an optional initial value+  newArray_      :: (HasSignAndSize a, HasSignAndSize b) => Maybe (SBV b) -> Symbolic (array a b)+  -- | Create a named new array, with an optional initial value+  newArray       :: (HasSignAndSize a, HasSignAndSize b) => String -> Maybe (SBV b) -> 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+  -- Intuitively: @mergeArrays cond a b = if cond then a else b@.+  -- Merging pushes the if-then-else choice down on to elements+  mergeArrays    :: SymWord b => SBV Bool -> array a b -> array a b -> array a b++-- | Arrays implemented in terms of SMT-arrays: <http://goedel.cs.uiowa.edu/smtlib/theories/ArraysEx.smt2>+--+--   * Maps directly to SMT-lib arrays+--+--   * Reading from an unintialized value is OK and yields an uninterpreted result+--+--   * Can check for equality of these arrays+--+--   * Cannot quick-check theorems using @SArray@ values+--+--   * Typically slower as it heavily relies on SMT-solving for the array theory+--+data SArray a b = SArray ((Bool, Size), (Bool, Size)) (Cached ArrayIndex)+type ArrayIndex = Int++instance (HasSignAndSize a, HasSignAndSize b) => Show (SArray a b) where+  show (SArray{}) = "SArray<" ++ showType (undefined :: a) ++ ":" ++ showType (undefined :: b) ++ ">"++instance SymArray SArray where+  newArray_  = declNewSArray (\t -> "array_" ++ show t)+  newArray n = declNewSArray (const n)+  readArray (SArray (_, bsgnsz) f) a = SBV bsgnsz $ Right $ cache r+     where r st = do arr <- uncacheAI f st+                     i   <- sbvToSW st a+                     newExpr st bsgnsz (SBVApp (ArrRead arr) [i])+  resetArray (SArray ainfo f) b = SArray ainfo $ cache g+     where g st = do amap <- readIORef (rArrayMap st)+                     val <- sbvToSW 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+  writeArray (SArray ainfo f) a b = SArray ainfo $ cache g+     where g st = do arr  <- uncacheAI f st+                     addr <- sbvToSW st a+                     val  <- sbvToSW 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))+                     return j+  mergeArrays t (SArray ainfo a) (SArray _ b) = SArray ainfo $ cache h+    where h st = do ai <- uncacheAI a st+                    bi <- uncacheAI b st+                    ts <- sbvToSW 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))+                    return k++declNewSArray :: forall a b. (HasSignAndSize a, HasSignAndSize b) => (Int -> String) -> Maybe (SBV b) -> Symbolic (SArray a b)+declNewSArray mkNm mbInit = do+   let asgnsz = (hasSign (undefined :: a), sizeOf (undefined :: a))+       bsgnsz = (hasSign (undefined :: b), sizeOf (undefined :: b))+   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 -> sbvToSW st ival >>= \sw -> return $ ArrayFree (Just sw)+   liftIO $ modifyIORef (rArrayMap st) (IMap.insert i (nm, (asgnsz, bsgnsz), actx))+   return $ SArray (asgnsz, bsgnsz) $ cache $ const $ return i++-- | Arrays implemented internally as functions+--+--    * Internally handled by the library and not mapped to SMT-Lib+--+--    * Reading an uninitialized value is considered an error (will throw exception)+--+--    * Cannot check for equality (internally represented as functions)+--+--    * Can quick-check+--+--    * Typically faster as it gets compiled away during translation+--+data SFunArray a b = SFunArray (SBV a -> SBV b)++instance (HasSignAndSize a, HasSignAndSize b) => Show (SFunArray a b) where+  show (SFunArray _) = "SFunArray<" ++ showType (undefined :: a) ++ ":" ++ showType (undefined :: b) ++ ">"++-- | Make a constant fun-array always returning a fixed value.+-- Useful for creating arrays in a pure context. (Otherwise use `newArray`.)+mkSFunArray :: SBV b -> SFunArray a b+mkSFunArray i = SFunArray (const i)++---------------------------------------------------------------------------------+-- * Cached values+---------------------------------------------------------------------------------++-- We implement a peculiar caching mechanism, applicable to the use case in+-- implementation of SBV's.  Whenever we do a state based computation, we do+-- not want to keep on evaluating it in the then-current state. That will+-- produce essentially a semantically equivalent value. Thus, we want to run+-- it only once, and reuse that result, capturing the sharing at the Haskell+-- level. This is similar to the "type-safe observable sharing" work, but also+-- takes into the account of how symbolic simulation executes.+--+-- Note that this is *not* a general memo utility!++newtype Cached a = Cached (State -> IO a)++cache :: (State -> IO a) -> Cached a+cache = Cached++uncache :: Cached SW -> State -> IO SW+uncache = uncacheGen rSWCache++uncacheAI :: Cached ArrayIndex -> State -> IO ArrayIndex+uncacheAI = uncacheGen rAICache++uncacheGen :: (State -> IORef (Cache a)) -> Cached a -> State -> IO a+uncacheGen getCache (Cached f) st = do+        let rCache = getCache st+        stored <- readIORef rCache+        sn <- f `seq` makeStableName f+        let h = hashStableName sn+        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)])+                        return r++-- Technicalities..+instance NFData CW where+  rnf (CW x y z) = x `seq` y `seq` z `seq` ()++instance NFData Result where+  rnf (Result inps consts tbls arrs uis axs pgm outs)+        = rnf inps `seq` rnf consts `seq` rnf tbls `seq` rnf arrs `seq` rnf uis `seq` rnf axs `seq` rnf pgm `seq` rnf outs++instance NFData ArrayContext+instance NFData Pgm+instance NFData SW+instance NFData SBVType+instance NFData UnintKind++-- Quickcheck interface on symbolic-booleans..+instance Testable SBool where+  property (SBV _ (Left b)) = property (cwToBool b)+  property s                = error $ "Cannot quick-check in the presence of uninterpreted constants! (" ++ show s ++ ")"
+ Temp/sbv-0.9.18/Data/SBV/BitVectors/Model.hs view
@@ -0,0 +1,965 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.BitVectors.Model+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Instance declarations for our symbolic world+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -fno-warn-orphans   #-}+{-# LANGUAGE TypeSynonymInstances   #-}+{-# LANGUAGE PatternGuards          #-}+{-# LANGUAGE FlexibleInstances      #-}+{-# LANGUAGE MultiParamTypeClasses  #-}+{-# LANGUAGE ScopedTypeVariables    #-}+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE Rank2Types             #-}++module Data.SBV.BitVectors.Model (+    Mergeable(..), EqSymbolic(..), OrdSymbolic(..), BVDivisible(..), Uninterpreted(..)+  , bitValue, setBitTo, allEqual, allDifferent, oneIf, blastBE, blastLE+  , lsb, msb, SBVUF, sbvUFName, genFree, genFree_+  )+  where++import Data.Array      (Array, Ix, listArray, elems, bounds, rangeSize)+import Data.Bits       (Bits(..))+import Data.Int        (Int8, Int16, Int32, Int64)+import Data.List       (genericLength, genericIndex, genericSplitAt, unzip4, unzip5, unzip6, unzip7)+import Data.Word       (Word8, Word16, Word32, Word64)+import Test.QuickCheck (Arbitrary(..))++import Data.SBV.BitVectors.Data+import Data.SBV.Utils.Boolean++liftSym1 :: (State -> (Bool, Size) -> SW -> IO SW) ->+            (Integer -> Integer) -> SBV b -> SBV b+liftSym1 _   opC (SBV sgnsz (Left a))  = SBV sgnsz $ Left  $ mapCW opC a+liftSym1 opS _   a@(SBV sgnsz _)       = SBV sgnsz $ Right $ cache c+   where c st = do swa <- sbvToSW st a+                   opS st sgnsz swa++liftSym2 :: (State -> (Bool, Size) -> SW -> SW -> IO SW) ->+            (Integer -> Integer -> Integer) -> SBV b -> SBV b -> SBV b+liftSym2 _   opC (SBV sgnsz (Left a)) (SBV _ (Left b)) = SBV sgnsz $ Left  $ mapCW2 opC a b+liftSym2 opS _   a@(SBV sgnsz _)      b                = SBV sgnsz $ Right $ cache c+  where c st = do sw1 <- sbvToSW st a+                  sw2 <- sbvToSW st b+                  opS st sgnsz sw1 sw2++liftSym2B :: (State -> (Bool, Size) -> SW -> SW -> IO SW)+          -> (Integer -> Integer -> Bool)+          -> SBV b -> SBV b -> SBool+liftSym2B _   opC (SBV _ (Left a)) (SBV _ (Left b)) = literal (liftCW2 opC a b)+liftSym2B opS _   a                b                = SBV (False, 1) $ Right $ cache c+  where c st = do sw1 <- sbvToSW st a+                  sw2 <- sbvToSW st b+                  opS st (False, 1) sw1 sw2++liftSym1Bool :: (State -> (Bool, Size) -> SW -> IO SW)+             -> (Bool -> Bool)+             -> SBool -> SBool+liftSym1Bool _   opC (SBV _ (Left a)) = literal $ opC $ cwToBool a+liftSym1Bool opS _   a                = SBV (False, 1) $ Right $ cache c+  where c st = do sw <- sbvToSW st a+                  opS st (False, 1) sw++liftSym2Bool :: (State -> (Bool, Size) -> SW -> SW -> IO SW)+             -> (Bool -> Bool -> Bool)+             -> SBool -> SBool -> SBool+liftSym2Bool _   opC (SBV _ (Left a)) (SBV _ (Left b)) = literal (cwToBool a `opC` cwToBool b)+liftSym2Bool opS _   a                b                = SBV (False, 1) $ Right $ cache c+  where c st = do sw1 <- sbvToSW st a+                  sw2 <- sbvToSW st b+                  opS st (False, 1) sw1 sw2++mkSymOpSC :: (SW -> SW -> Maybe SW) -> Op -> State -> (Bool, Size) -> SW -> SW -> IO SW+mkSymOpSC shortCut op st sgnsz a b = maybe (newExpr st sgnsz (SBVApp op [a, b])) return (shortCut a b)++mkSymOp :: Op -> State -> (Bool, Size) -> SW -> SW -> IO SW+mkSymOp = mkSymOpSC (const (const Nothing))++mkSymOp1SC :: (SW -> Maybe SW) -> Op -> State -> (Bool, Size) -> SW -> IO SW+mkSymOp1SC shortCut op st sgnsz a = maybe (newExpr st sgnsz (SBVApp op [a])) return (shortCut a)++mkSymOp1 :: Op -> State -> (Bool, Size) -> SW -> IO SW+mkSymOp1 = mkSymOp1SC (const Nothing)++-- Symbolic-Word class instances++genFree :: (Bool, Size) -> String -> Symbolic (SBV a)+genFree s = mkSymSBV s . Just++genFree_ :: (Bool, Size) -> Symbolic (SBV a)+genFree_ s = mkSymSBV s Nothing++genLiteral :: Integral a => (Bool,Size) -> a -> SBV b+genLiteral s  = SBV s . Left . mkConstCW s++genFromCW :: Integral a => CW -> a+genFromCW x = fromInteger (cwVal x)++instance SymWord Bool where+  free      = genFree    (False, 1)+  free_     = genFree_   (False, 1)+  literal x = genLiteral (False, 1) (if x then (1::Integer) else 0)+  fromCW    = cwToBool++instance SymWord Word8 where+  free    = genFree    (False, 8)+  free_   = genFree_   (False, 8)+  literal = genLiteral (False, 8)+  fromCW  = genFromCW++instance SymWord Int8 where+  free    = genFree    (True, 8)+  free_   = genFree_   (True, 8)+  literal = genLiteral (True, 8)+  fromCW  = genFromCW++instance SymWord Word16 where+  free    = genFree    (False, 16)+  free_   = genFree_   (False, 16)+  literal = genLiteral (False, 16)+  fromCW  = genFromCW++instance SymWord Int16 where+  free    = genFree    (True, 16)+  free_   = genFree_   (True, 16)+  literal = genLiteral (True, 16)+  fromCW  = genFromCW++instance SymWord Word32 where+  free    = genFree    (False, 32)+  free_   = genFree_   (False, 32)+  literal = genLiteral (False, 32)+  fromCW  = genFromCW++instance SymWord Int32 where+  free    = genFree    (True, 32)+  free_   = genFree_   (True, 32)+  literal = genLiteral (True, 32)+  fromCW  = genFromCW++instance SymWord Word64 where+  free    = genFree    (False, 64)+  free_   = genFree_   (False, 64)+  literal = genLiteral (False, 64)+  fromCW  = genFromCW++instance SymWord Int64 where+  free    = genFree    (True, 64)+  free_   = genFree_   (True, 64)+  literal = genLiteral (True, 64)+  fromCW  = genFromCW++-- | Symbolic Equality. Note that we can't use Haskell's 'Eq' class since Haskell insists on returning Bool+-- Comparing symbolic values will necessarily return a symbolic value.+--+-- Minimal complete definition: '.=='+infix 4 .==, ./=+class EqSymbolic a where+  (.==), (./=) :: a -> a -> SBool+  -- minimal complete definition: .==+  x ./= y = bnot (x .== y)++-- | Symbolic Comparisons. Similar to 'Eq', we cannot implement Haskell's 'Ord' class+-- since there is no way to return an 'Ordering' value from a symbolic comparison.+-- Furthermore, 'OrdSymbolic' requires 'Mergeable' to implement if-then-else, for the+-- benefit of implementing symbolic versions of 'max' and 'min' functions.+--+-- Minimal complete definition: '.<'+infix 4 .<, .<=, .>, .>=+class (Mergeable a, EqSymbolic a) => OrdSymbolic a where+  (.<), (.<=), (.>), (.>=) :: a -> a -> SBool+  smin, smax :: a -> a -> a+  -- minimal complete definition: .<+  a .<= b    = a .< b ||| a .== b+  a .>  b    = b .<  a+  a .>= b    = b .<= a+  a `smin` b = ite (a .<= b) a b+  a `smax` b = ite (a .<= b) b a++{- We can't have a generic instance of the form:++instance Eq a => EqSymbolic a where+  x .== y = if x == y then true else false++even if we're willing to allow Flexible/undecidable instances..+This is because if we allow this it would imply EqSymbolic (SBV a);+since (SBV a) has to be Eq as it must be a Num. But this wouldn't be+the right choice obviously; as the Eq instance is bogus for SBV+for natural reasons..+-}++instance EqSymbolic (SBV a) where+  (.==) = liftSym2B (mkSymOpSC (eqOpt trueSW) Equal)    (==)+  (./=) = liftSym2B (mkSymOpSC (eqOpt falseSW) NotEqual) (/=)++eqOpt :: SW -> SW -> SW -> Maybe SW+eqOpt w x y = if x == y then Just w else Nothing++instance SymWord a => OrdSymbolic (SBV a) where+  x .< y+    | x `isConcretely` (== maxBound) = false+    | y `isConcretely` (== minBound) = false+    | True                           = liftSym2B (mkSymOpSC (eqOpt falseSW) LessThan)    (<)  x y+  x .<= y+    | x `isConcretely` (== minBound) = true+    | y `isConcretely` (== maxBound) = true+    | True                           = liftSym2B (mkSymOpSC (eqOpt trueSW) LessEq)       (<=) x y+  x .> y+    | x `isConcretely` (== minBound) = false+    | y `isConcretely` (== maxBound) = false+    | True                           = liftSym2B (mkSymOpSC (eqOpt falseSW) GreaterThan) (>)  x y+  x .>= y+    | x `isConcretely` (== maxBound) = true+    | y `isConcretely` (== minBound) = true+    | True                           = liftSym2B (mkSymOpSC (eqOpt trueSW) GreaterEq)    (>=) x y++-- Bool+instance EqSymbolic Bool where+  x .== y = if x == y then true else false++-- Lists+instance EqSymbolic a => EqSymbolic [a] where+  []     .== []     = true+  (x:xs) .== (y:ys) = x .== y &&& xs .== ys+  _      .== _      = false++instance OrdSymbolic a => OrdSymbolic [a] where+  []     .< []     = false+  []     .< _      = true+  _      .< []     = false+  (x:xs) .< (y:ys) = x .< y ||| (x .== y &&& xs .< ys)++-- Maybe+instance EqSymbolic a => EqSymbolic (Maybe a) where+  Nothing .== Nothing = true+  Just a  .== Just b  = a .== b+  _       .== _       = false++instance (OrdSymbolic a) => OrdSymbolic (Maybe a) where+  Nothing .<  Nothing = false+  Nothing .<  _       = true+  Just _  .<  Nothing = false+  Just a  .<  Just b  = a .< b++-- Either+instance (EqSymbolic a, EqSymbolic b) => EqSymbolic (Either a b) where+  Left a  .== Left b  = a .== b+  Right a .== Right b = a .== b+  _       .== _       = false++instance (OrdSymbolic a, OrdSymbolic b) => OrdSymbolic (Either a b) where+  Left a  .< Left b  = a .< b+  Left _  .< Right _ = true+  Right _ .< Left _  = false+  Right a .< Right b = a .< b++-- 2-Tuple+instance (EqSymbolic a, EqSymbolic b) => EqSymbolic (a, b) where+  (a0, b0) .== (a1, b1) = a0 .== a1 &&& b0 .== b1++instance (OrdSymbolic a, OrdSymbolic b) => OrdSymbolic (a, b) where+  (a0, b0) .< (a1, b1) = a0 .< a1 ||| (a0 .== a1 &&& b0 .< b1)++-- 3-Tuple+instance (EqSymbolic a, EqSymbolic b, EqSymbolic c) => EqSymbolic (a, b, c) where+  (a0, b0, c0) .== (a1, b1, c1) = (a0, b0) .== (a1, b1) &&& c0 .== c1++instance (OrdSymbolic a, OrdSymbolic b, OrdSymbolic c) => OrdSymbolic (a, b, c) where+  (a0, b0, c0) .< (a1, b1, c1) = (a0, b0) .< (a1, b1) ||| ((a0, b0) .== (a1, b1) &&& c0 .< c1)++-- 4-Tuple+instance (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d) => EqSymbolic (a, b, c, d) where+  (a0, b0, c0, d0) .== (a1, b1, c1, d1) = (a0, b0, c0) .== (a1, b1, c1) &&& d0 .== d1++instance (OrdSymbolic a, OrdSymbolic b, OrdSymbolic c, OrdSymbolic d) => OrdSymbolic (a, b, c, d) where+  (a0, b0, c0, d0) .< (a1, b1, c1, d1) = (a0, b0, c0) .< (a1, b1, c1) ||| ((a0, b0, c0) .== (a1, b1, c1) &&& d0 .< d1)++-- 5-Tuple+instance (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d, EqSymbolic e) => EqSymbolic (a, b, c, d, e) where+  (a0, b0, c0, d0, e0) .== (a1, b1, c1, d1, e1) = (a0, b0, c0, d0) .== (a1, b1, c1, d1) &&& e0 .== e1++instance (OrdSymbolic a, OrdSymbolic b, OrdSymbolic c, OrdSymbolic d, OrdSymbolic e) => OrdSymbolic (a, b, c, d, e) where+  (a0, b0, c0, d0, e0) .< (a1, b1, c1, d1, e1) = (a0, b0, c0, d0) .< (a1, b1, c1, d1) ||| ((a0, b0, c0, d0) .== (a1, b1, c1, d1) &&& e0 .< e1)++-- 6-Tuple+instance (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d, EqSymbolic e, EqSymbolic f) => EqSymbolic (a, b, c, d, e, f) where+  (a0, b0, c0, d0, e0, f0) .== (a1, b1, c1, d1, e1, f1) = (a0, b0, c0, d0, e0) .== (a1, b1, c1, d1, e1) &&& f0 .== f1++instance (OrdSymbolic a, OrdSymbolic b, OrdSymbolic c, OrdSymbolic d, OrdSymbolic e, OrdSymbolic f) => OrdSymbolic (a, b, c, d, e, f) where+  (a0, b0, c0, d0, e0, f0) .< (a1, b1, c1, d1, e1, f1) =    (a0, b0, c0, d0, e0) .<  (a1, b1, c1, d1, e1)+                                                       ||| ((a0, b0, c0, d0, e0) .== (a1, b1, c1, d1, e1) &&& f0 .< f1)++-- 7-Tuple+instance (EqSymbolic a, EqSymbolic b, EqSymbolic c, EqSymbolic d, EqSymbolic e, EqSymbolic f, EqSymbolic g) => EqSymbolic (a, b, c, d, e, f, g) where+  (a0, b0, c0, d0, e0, f0, g0) .== (a1, b1, c1, d1, e1, f1, g1) = (a0, b0, c0, d0, e0, f0) .== (a1, b1, c1, d1, e1, f1) &&& g0 .== g1++instance (OrdSymbolic a, OrdSymbolic b, OrdSymbolic c, OrdSymbolic d, OrdSymbolic e, OrdSymbolic f, OrdSymbolic g) => OrdSymbolic (a, b, c, d, e, f, g) where+  (a0, b0, c0, d0, e0, f0, g0) .< (a1, b1, c1, d1, e1, f1, g1) =    (a0, b0, c0, d0, e0, f0) .<  (a1, b1, c1, d1, e1, f1)+                                                               ||| ((a0, b0, c0, d0, e0, f0) .== (a1, b1, c1, d1, e1, f1) &&& g0 .< g1)++-- Boolean combinators+instance Boolean SBool where+  true  = literal True+  false = literal False+  bnot  b | b `isConcretely` (== False) = true+          | b `isConcretely` (== True)  = false+          | True                        = liftSym1Bool (mkSymOp1 Not) not b+  a &&& b | a `isConcretely` (== False) || b `isConcretely` (== False) = false+          | a `isConcretely` (== True)                                 = b+          | b `isConcretely` (== True)                                 = a+          | True                                                       = liftSym2Bool (mkSymOpSC opt And) (&&) a b+          where opt x y+                 | x == falseSW || y == falseSW = Just falseSW+                 | x == trueSW                  = Just y+                 | y == trueSW                  = Just x+                 | True                         = Nothing+  a ||| b | a `isConcretely` (== True)  || b `isConcretely` (== True) = true+          | a `isConcretely` (== False)                               = b+          | b `isConcretely` (== False)                               = a+          | True                                                      = liftSym2Bool (mkSymOpSC opt Or)  (||) a b+          where opt x y+                 | x == trueSW || y == trueSW = Just trueSW+                 | x == falseSW               = Just y+                 | y == falseSW               = Just x+                 | True                       = Nothing+  a <+> b | a `isConcretely` (== False) = b+          | b `isConcretely` (== False) = a+          | a `isConcretely` (== True)  = bnot b+          | b `isConcretely` (== True)  = bnot a+          | True                        = liftSym2Bool (mkSymOpSC opt XOr) (<+>) a b+          where opt x y+                 | x == y       = Just falseSW+                 | x == falseSW = Just y+                 | y == falseSW = Just x+                 | True         = Nothing++-- | Returns (symbolic) true if all the elements of the given list are different+allDifferent :: (Eq a, SymWord a) => [SBV a] -> SBool+allDifferent (x:xs@(_:_)) = bAll ((./=) x) xs &&& allDifferent xs+allDifferent _            = true++-- | Returns (symbolic) true if all the elements of the given list are the same+allEqual :: (Eq a, SymWord a) => [SBV a] -> SBool+allEqual (x:xs@(_:_))     = bAll ((.==) x) xs+allEqual _                = true++-- | Returns 1 if the boolean is true, otherwise 0+oneIf :: (Num a, SymWord a) => SBool -> SBV a+oneIf t = ite t 1 0++-- Num instance for symbolic words+instance (Ord a, Num a, SymWord a) => Num (SBV a) where+  fromInteger = literal . fromIntegral+  x + y+    | x `isConcretely` (== 0) = y+    | y `isConcretely` (== 0) = x+    | True                    = liftSym2 (mkSymOp Plus)  (+) x y+  x * y+    | x `isConcretely` (== 0) = 0+    | y `isConcretely` (== 0) = 0+    | x `isConcretely` (== 1) = y+    | y `isConcretely` (== 1) = x+    | True                    = liftSym2 (mkSymOp Times) (*) x y+  x - y+    | y `isConcretely` (== 0) = x+    | True                    = liftSym2 (mkSymOp Minus) (-) x y+  abs a+   | hasSign a = ite (a .< 0) (-a) a+   | True      = a+  signum a+   | hasSign a = ite (a .< 0) (-1) (ite (a .== 0) 0 1)+   | True      = oneIf (a ./= 0)++-- NB. The default definition of "testBit" relies on equality,+-- which is not available for symbolic SBV's. There is no+-- way to implement testBit to return Bool, obviously; instead use bitValue+-- Also, in the optimizations below, use of -1 is valid as+-- -1 has all bits set to True for both signed and unsigned values+instance (Bits a, SymWord a) => Bits (SBV a) where+  x .&. y+    | x `isConcretely` (== 0)  = 0+    | x `isConcretely` (== -1) = y+    | y `isConcretely` (== 0)  = 0+    | y `isConcretely` (== -1) = x+    | True                     = liftSym2 (mkSymOp  And) (.&.) x y+  x .|. y+    | x `isConcretely` (== 0)  = y+    | x `isConcretely` (== -1) = -1+    | y `isConcretely` (== 0)  = x+    | y `isConcretely` (== -1) = -1+    | True                     = liftSym2 (mkSymOp  Or)  (.|.) x y+  x `xor` y+    | x `isConcretely` (== 0)  = y+    | y `isConcretely` (== 0)  = x+    | True                     = liftSym2 (mkSymOp  XOr) xor x y+  complement               = liftSym1 (mkSymOp1 Not) complement+  bitSize  (SBV (_ ,s) _)  = s+  isSigned (SBV (b, _) _)  = b+  shiftL x y+    | y < 0                = shiftR x (-y)+    | y == 0               = x+    | True                 = liftSym1 (mkSymOp1 (Shl y)) (`shiftL` y) x+  shiftR x y+    | y < 0                = shiftL x (-y)+    | y == 0               = x+    | True                 = liftSym1 (mkSymOp1 (Shr y)) (`shiftR` y) x+  rotateL x y+    | y < 0                = rotateR x (-y)+    | y == 0               = x+    | True                 = liftSym1 (mkSymOp1 (Rol y)) (rot True (bitSize x) y) x+  rotateR x y+    | y < 0                = rotateL x (-y)+    | y == 0               = x+    | True                 = liftSym1 (mkSymOp1 (Ror y)) (rot False (bitSize x) y) x++-- Since the underlying representation is just Integers, rotations has to be careful on the bit-size+rot :: Bool -> Int -> Int -> Integer -> Integer+rot toLeft sz amt x+  | sz < 2 = x+  | True   = (norm x y') `shiftL` y  .|. norm (x `shiftR` y') y+  where (y, y') | toLeft = (amt `mod` sz, sz - y)+                | True   = (sz - y', amt `mod` sz)+        norm v s = v .&. ((1 `shiftL` s) - 1)++-- | Replacement for 'testBit'. Since 'testBit' requires a 'Bool' to be returned,+-- we cannot implement it for symbolic words. Index 0 is the least-significant bit.+bitValue :: (Bits a, SymWord a) => SBV a -> Int -> SBool+bitValue x i = (x .&. bit i) ./= 0++-- | Generalization of 'setBit' based on a symbolic boolean. Note that 'setBit' and+-- 'clearBit' are still available on Symbolic words, this operation comes handy when+-- the condition to set/clear happens to be symbolic+setBitTo :: (Bits a, SymWord a) => SBV a -> Int -> SBool -> SBV a+setBitTo x i b = ite b (setBit x i) (clearBit x i)++-- | Little-endian blasting of a word into its bits. Also see the 'FromBits' class+blastLE :: (Bits a, SymWord a) => SBV a -> [SBool]+blastLE x = map (bitValue x) [0 .. (sizeOf x)-1]++-- | Big-endian blasting of a word into its bits. Also see the 'FromBits' class+blastBE :: (Bits a, SymWord a) => SBV a -> [SBool]+blastBE = reverse . blastLE++-- | Least significant bit of a word, always stored at index 0+lsb :: (Bits a, SymWord a) => SBV a -> SBool+lsb x = bitValue x 0++-- | Most significant bit of a word, always stored at the last position+msb :: (Bits a, SymWord a) => SBV a -> SBool+msb x = bitValue x ((sizeOf x) - 1)++-- Enum instance. These instances are suitable for use with concrete values,+-- and will be less useful for symbolic values around. Note that `fromEnum` requires+-- a concrete argument for obvious reasons. Other variants (succ, pred, [x..]) etc are similarly+-- limited. While symbolic variants can be defined for many of these, they will just diverge+-- as final sizes cannot be determined statically.+instance (Bounded a, Integral a, Num a, SymWord a) => Enum (SBV a) where+  succ x+    | v == (maxBound :: a) = error $ "Enum.succ{" ++ showType x ++ "}: tried to take `succ' of maxBound"+    | True                 = fromIntegral $ v + 1+    where v = enumCvt "succ" x+  pred x+    | v == (minBound :: a) = error $ "Enum.pred{" ++ showType x ++ "}: tried to take `pred' of minBound"+    | True                 = fromIntegral $ v - 1+    where v = enumCvt "pred" x+  toEnum x+    | xi < fromIntegral (minBound :: a) || xi > fromIntegral (maxBound :: a)+    = error $ "Enum.toEnum{" ++ showType r ++ "}: " ++ show x ++ " is out-of-bounds " ++ show (minBound :: a, maxBound :: a)+    | True+    = r+    where xi :: Integer+          xi = fromIntegral x+          r  :: SBV a+          r  = fromIntegral x+  fromEnum x+     | r < fromIntegral (minBound :: Int) || r > fromIntegral (maxBound :: Int)+     = error $ "Enum.fromEnum{" ++ showType x ++ "}:  value " ++ show r ++ " is outside of Int's bounds " ++ show (minBound :: Int, maxBound :: Int)+     | True+     = fromIntegral r+    where r :: Integer+          r = enumCvt "fromEnum" x+  enumFrom x = map fromIntegral [xi .. fromIntegral (maxBound :: a)]+     where xi :: Integer+           xi = enumCvt "enumFrom" x+  enumFromThen x y+     | yi >= xi  = map fromIntegral [xi, yi .. fromIntegral (maxBound :: a)]+     | True      = map fromIntegral [xi, yi .. fromIntegral (minBound :: a)]+       where xi, yi :: Integer+             xi = enumCvt "enumFromThen.x" x+             yi = enumCvt "enumFromThen.y" y+  enumFromThenTo x y z = map fromIntegral [xi, yi .. zi]+       where xi, yi, zi :: Integer+             xi = enumCvt "enumFromThenTo.x" x+             yi = enumCvt "enumFromThenTo.y" y+             zi = enumCvt "enumFromThenTo.z" z++-- | Helper function for use in enum operations+enumCvt :: (SymWord a, Integral a, Num b) => String -> SBV a -> b+enumCvt w x = case unliteral x of+                Nothing -> error $ "Enum." ++ w ++ "{" ++ showType x ++ "}: Called on symbolic value " ++ show x+                Just v  -> fromIntegral v++-- | The 'BVDivisible' class captures the essence of division of words.+-- Unfortunately we cannot use Haskell's 'Integral' class since the 'Real'+-- and 'Enum' superclasses are not implementable for symbolic bit-vectors.+-- However, 'quotRem' makes perfect sense, and the 'BVDivisible' class captures+-- this operation. One issue is how division by 0 behaves. The verification+-- technology requires total functions, and there are several design choices+-- here. We follow Isabelle/HOL approach of assigning the value 0 for division+-- by 0. Therefore, we impose the following law:+--+--     @ x `bvQuotRem` 0 = (0, x) @+--+-- Note that our instances implement this law even when @x@ is @0@ itself.+--+-- Minimal complete definition: 'bvQuotRem'+class BVDivisible a where+  bvQuotRem :: a -> a -> (a, a)++instance BVDivisible Word64 where+  bvQuotRem x 0 = (0, x)+  bvQuotRem x y = x `quotRem` y++instance BVDivisible Word32 where+  bvQuotRem x 0 = (0, x)+  bvQuotRem x y = x `quotRem` y++instance BVDivisible Word16 where+  bvQuotRem x 0 = (0, x)+  bvQuotRem x y = x `quotRem` y++instance BVDivisible Word8 where+  bvQuotRem x 0 = (0, x)+  bvQuotRem x y = x `quotRem` y++instance BVDivisible Integer where+  bvQuotRem x 0 = (0, x)+  bvQuotRem x y = x `quotRem` y++instance BVDivisible CW where+  bvQuotRem x y+    | cwSameType x y = let (r1, r2) = bvQuotRem (cwVal x) (cwVal y)+                       in (x { cwVal = r1 }, y { cwVal = r2 })+  bvQuotRem x y = error $ "SBV.liftQRem: impossible, unexpected args received: " ++ show (x, y)++instance BVDivisible SWord64 where+  bvQuotRem = liftQRem++instance BVDivisible SWord32 where+  bvQuotRem = liftQRem++instance BVDivisible SWord16 where+  bvQuotRem = liftQRem++instance BVDivisible SWord8 where+  bvQuotRem = liftQRem++liftQRem :: (SymWord a, Num a, BVDivisible a) => SBV a -> SBV a -> (SBV a, SBV a)+liftQRem x y = ite (y .== 0) (0, x) (qr x y)+  where qr (SBV sgnsz (Left a)) (SBV _ (Left b)) = let (q, r) = bvQuotRem a b in (SBV sgnsz (Left q), SBV sgnsz (Left r))+        qr a@(SBV sgnsz _)      b                = (SBV sgnsz (Right (cache (mk Quot))), SBV sgnsz (Right (cache (mk Rem))))+                where mk o st = do sw1 <- sbvToSW st a+                                   sw2 <- sbvToSW st b+                                   mkSymOp o st sgnsz sw1 sw2++-- Quickcheck interface++-- The Arbitrary instance for SFunArray returns an array initialized+-- to an arbitrary element+instance (SymWord b, Arbitrary b) => Arbitrary (SFunArray a b) where+  arbitrary = arbitrary >>= \r -> return $ SFunArray (const r)++instance (SymWord a, Arbitrary a) => Arbitrary (SBV a) where+  arbitrary = arbitrary >>= return . literal++-- |  Symbolic choice operator, parameterized via a class+-- 'select' is a total-indexing function, with the default.+--+-- Minimal complete definition: 'symbolicMerge'+class Mergeable a where+   -- | Merge two values based on the condition+   symbolicMerge :: SBool -> a -> a -> a+   -- | Choose one or the other element, based on the condition.+   -- This is similar to 'symbolicMerge', but it has a default+   -- implementation that makes sure it's short-cut if the condition is concrete+   ite           :: SBool -> a -> a -> a+   -- | Total indexing operation. @select xs default index@ is intuitively+   -- the same as @xs !! index@, except it evaluates to @default@ if @index@+   -- overflows+   select        :: (Bits b, SymWord b, Integral b) => [a] -> a -> SBV b -> a+   -- default definitions+   ite s a b+    | Just t <- unliteral s = if t then a else b+    | True                  = symbolicMerge s a b+   select [] err _   = err+   select xs err ind+    | hasSign ind    = ite (ind .< 0) err $ result+    | True           = result+    where result = go xs $ reverse (zip [(0::Integer)..] bits)+          bits   = map (ind `bitValue`) [0 .. bitSize ind - 1]+          go []    _            = err+          go (x:_) []           = x+          go elts  ((n, b):nbs) = let (ys, zs) = genericSplitAt ((2::Integer) ^ n) elts+                                  in ite b (go zs nbs) (go ys nbs)++-- SBV+instance SymWord a => Mergeable (SBV a) where+  symbolicMerge t a b+   | Just c1 <- unliteral a, Just c2 <- unliteral b, c1 == c2+   = a+   | True+   = SBV sgnsz $ Right $ cache c+    where sgnsz = (hasSign a, sizeOf a)+          c st = do swt <- sbvToSW st t+                    case () of+                      () | swt == trueSW  -> sbvToSW st a+                      () | swt == falseSW -> sbvToSW st b+                      () -> do swa <- sbvToSW st a+                               swb <- sbvToSW st b+                               if swa == swb+                                  then return swa+                                  else newExpr st sgnsz (SBVApp Ite [swt, swa, swb])+  -- Custom version of select that translates to SMT-Lib tables at the base type of words+  select xs err ind+    | Just i <- unliteral ind+    = let i' :: Integer+          i' = fromIntegral i+      in if i' < 0 || i' >= genericLength xs then err else genericIndex xs i'+  select [] err _   = err+  select xs err ind = SBV sgnszElt $ Right $ cache r+     where sgnszInd = (hasSign ind, sizeOf ind)+           sgnszElt = (hasSign err, sizeOf err)+           r st  = do sws <- mapM (sbvToSW st) xs+                      swe <- sbvToSW st err+                      if all (== swe) sws  -- off-chance that all elts are the same+                         then return swe+                         else do idx <- getTableIndex st sgnszInd sgnszElt sws+                                 swi <- sbvToSW st ind+                                 let len = length xs+                                 newExpr st sgnszElt (SBVApp (LkUp (idx, sgnszInd, sgnszElt, len) swi swe) [])++-- Unit+instance Mergeable () where+   symbolicMerge _ _ _ = ()+   select _ _ _ = ()++-- Mergeable instances for List/Maybe/Either/Array are useful, but can+-- throw exceptions if there is no structural matching of the results+-- It's a question whether we should really keep them..++-- Lists+instance Mergeable a => Mergeable [a] where+  symbolicMerge t xs ys+    | lxs == lys = zipWith (symbolicMerge t) xs ys+    | True       = error $ "SBV.Mergeable.List: No least-upper-bound for lists of differing size " ++ show (lxs, lys)+    where (lxs, lys) = (length xs, length ys)++-- Maybe+instance Mergeable a => Mergeable (Maybe a) where+  symbolicMerge _ Nothing  Nothing  = Nothing+  symbolicMerge t (Just a) (Just b) = Just $ symbolicMerge t a b+  symbolicMerge _ a b = error $ "SBV.Mergeable.Maybe: No least-upper-bound for " ++ show (k a, k b)+      where k Nothing = "Nothing"+            k _       = "Just"++-- Either+instance (Mergeable a, Mergeable b) => Mergeable (Either a b) where+  symbolicMerge t (Left a)  (Left b)  = Left  $ symbolicMerge t a b+  symbolicMerge t (Right a) (Right b) = Right $ symbolicMerge t a b+  symbolicMerge _ a b = error $ "SBV.Mergeable.Either: No least-upper-bound for " ++ show (k a, k b)+     where k (Left _)  = "Left"+           k (Right _) = "Right"++-- Arrays+instance (Ix a, Mergeable b) => Mergeable (Array a b) where+  symbolicMerge t a b+    | ba == bb = listArray ba (zipWith (symbolicMerge t) (elems a) (elems b))+    | True     = error $ "SBV.Mergeable.Array: No least-upper-bound for rangeSizes" ++ show (k ba, k bb)+    where [ba, bb] = map bounds [a, b]+          k = rangeSize++-- Functions+instance Mergeable b => Mergeable (a -> b) where+  symbolicMerge t f g = \x -> symbolicMerge t (f x) (g x)+  select xs err ind   = \x -> select (map ($ x) xs) (err x) ind++-- 2-Tuple+instance (Mergeable a, Mergeable b) => Mergeable (a, b) where+  symbolicMerge t (i0, i1) (j0, j1) = (i i0 j0, i i1 j1)+    where i a b = symbolicMerge t a b+  select xs (err1, err2) ind = (select as err1 ind, select bs err2 ind)+    where (as, bs) = unzip xs++-- 3-Tuple+instance (Mergeable a, Mergeable b, Mergeable c) => Mergeable (a, b, c) where+  symbolicMerge t (i0, i1, i2) (j0, j1, j2) = (i i0 j0, i i1 j1, i i2 j2)+    where i a b = symbolicMerge t a b+  select xs (err1, err2, err3) ind = (select as err1 ind, select bs err2 ind, select cs err3 ind)+    where (as, bs, cs) = unzip3 xs++-- 4-Tuple+instance (Mergeable a, Mergeable b, Mergeable c, Mergeable d) => Mergeable (a, b, c, d) where+  symbolicMerge t (i0, i1, i2, i3) (j0, j1, j2, j3) = (i i0 j0, i i1 j1, i i2 j2, i i3 j3)+    where i a b = symbolicMerge t a b+  select xs (err1, err2, err3, err4) ind = (select as err1 ind, select bs err2 ind, select cs err3 ind, select ds err4 ind)+    where (as, bs, cs, ds) = unzip4 xs++-- 5-Tuple+instance (Mergeable a, Mergeable b, Mergeable c, Mergeable d, Mergeable e) => Mergeable (a, b, c, d, e) where+  symbolicMerge t (i0, i1, i2, i3, i4) (j0, j1, j2, j3, j4) = (i i0 j0, i i1 j1, i i2 j2, i i3 j3, i i4 j4)+    where i a b = symbolicMerge t a b+  select xs (err1, err2, err3, err4, err5) ind = (select as err1 ind, select bs err2 ind, select cs err3 ind, select ds err4 ind, select es err5 ind)+    where (as, bs, cs, ds, es) = unzip5 xs++-- 6-Tuple+instance (Mergeable a, Mergeable b, Mergeable c, Mergeable d, Mergeable e, Mergeable f) => Mergeable (a, b, c, d, e, f) where+  symbolicMerge t (i0, i1, i2, i3, i4, i5) (j0, j1, j2, j3, j4, j5) = (i i0 j0, i i1 j1, i i2 j2, i i3 j3, i i4 j4, i i5 j5)+    where i a b = symbolicMerge t a b+  select xs (err1, err2, err3, err4, err5, err6) ind = (select as err1 ind, select bs err2 ind, select cs err3 ind, select ds err4 ind, select es err5 ind, select fs err6 ind)+    where (as, bs, cs, ds, es, fs) = unzip6 xs++-- 7-Tuple+instance (Mergeable a, Mergeable b, Mergeable c, Mergeable d, Mergeable e, Mergeable f, Mergeable g) => Mergeable (a, b, c, d, e, f, g) where+  symbolicMerge t (i0, i1, i2, i3, i4, i5, i6) (j0, j1, j2, j3, j4, j5, j6) = (i i0 j0, i i1 j1, i i2 j2, i i3 j3, i i4 j4, i i5 j5, i i6 j6)+    where i a b = symbolicMerge t a b+  select xs (err1, err2, err3, err4, err5, err6, err7) ind = (select as err1 ind, select bs err2 ind, select cs err3 ind, select ds err4 ind, select es err5 ind, select fs err6 ind, select gs err7 ind)+    where (as, bs, cs, ds, es, fs, gs) = unzip7 xs++-- Bounded instances+instance (SymWord a, Bounded a) => Bounded (SBV a) where+  minBound = literal minBound+  maxBound = literal maxBound++-- Arrays++-- SArrays are both "EqSymbolic" and "Mergeable"+instance EqSymbolic (SArray a b) where+  (SArray _ a) .== (SArray _ b) = SBV (False, 1) $ Right $ cache c+    where c st = do ai <- uncacheAI a st+                    bi <- uncacheAI b st+                    newExpr st (False, 1) (SBVApp (ArrEq ai bi) [])++instance SymWord b => Mergeable (SArray a b) where+  symbolicMerge = mergeArrays++-- SFunArrays are only "Mergeable". Although a brute+-- 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 = return $ SFunArray $ const $ maybe (error "Reading from an uninitialized array entry") id mbiVal+  readArray  (SFunArray f) a   = f a+  resetArray (SFunArray _) a   = SFunArray $ const a+  writeArray (SFunArray f) a b = SFunArray (\a' -> ite (a .== a') b (f a'))+  mergeArrays t (SFunArray f) (SFunArray g) = SFunArray (\x -> ite t (f x) (g x))++instance SymWord b => Mergeable (SFunArray a b) where+  symbolicMerge = mergeArrays++-- | An uninterpreted function handle. This is the handle to be used for+-- adding axioms about uninterpreted constants/functions. Note that+-- we will leave this abstract for safety purposes+newtype SBVUF = SBVUF String++-- | Get the name associated with the uninterpreted-value; useful when+-- constructing axioms about this UI.+sbvUFName :: SBVUF -> String+sbvUFName (SBVUF s) = s++-- The name we use for translating the UF constants to SMT-Lib..+mkUFName :: String -> SBVUF+mkUFName nm = SBVUF $ "uninterpreted_" ++ nm++-- | Uninterpreted constants and functions. An uninterpreted constant is+-- a value that is indexed by its name. The only property the prover assumes+-- about these values are that they are equivalent to themselves; i.e., (for+-- functions) they return the same results when applied to same arguments.+-- We support uninterpreted-functions as a general means of black-box'ing+-- operations that are /irrelevant/ for the purposes of the proof; i.e., when+-- the proofs can be performed without any knowledge about the function itself.+--+-- Minimal complete definition: 'uninterpretWithHandle'. However, most instances in+-- practice are already provided by SBV, so end-users should not need to define their+-- own instances.+class Uninterpreted a where+  -- | Uninterpret a value, receiving an object that can be used instead. Use this version+  -- when you do not need to add an axiom about this value.+  uninterpret :: String -> a+  -- | Uninterpret a value, but also get a handle to the resulting object. This handle+  -- can be used to add axioms for this object. (See 'addAxiom'.)+  uninterpretWithHandle :: String -> (SBVUF, a)++  -- minimal complete definition: 'uninterpretWithHandle'+  uninterpret = snd . uninterpretWithHandle++-- Plain constants+instance HasSignAndSize a => Uninterpreted (SBV a) where+  uninterpretWithHandle nm = (mkUFName nm, SBV sgnsza $ Right $ cache result)+    where sgnsza = (hasSign (undefined :: a), sizeOf (undefined :: a))+          result st = do newUninterpreted st nm (SBVType [sgnsza])+                         newExpr st sgnsza $ SBVApp (Uninterpreted nm) []++-- Forcing an argument; this is a necessary evil to make sure all the arguments+-- to an uninterpreted function are evaluated before called; the semantics of+-- such functions is necessarily strict; deviating from Haskell's+forceArg :: SW -> IO ()+forceArg (SW (b, s) n) = b `seq` s `seq` n `seq` return ()++-- Functions of one argument+instance (HasSignAndSize b, HasSignAndSize a) => Uninterpreted (SBV b -> SBV a) where+  uninterpretWithHandle nm = (mkUFName nm, f)+    where f arg0 = SBV sgnsza $ Right $ cache result+           where sgnsza = (hasSign (undefined :: a), sizeOf (undefined :: a))+                 sgnszb = (hasSign (undefined :: b), sizeOf (undefined :: b))+                 result st = do newUninterpreted st nm (SBVType [sgnszb, sgnsza])+                                sw0 <- sbvToSW st arg0+                                mapM_ forceArg [sw0]+                                newExpr st sgnsza $ SBVApp (Uninterpreted nm) [sw0]++-- Functions of two arguments+instance (HasSignAndSize c, HasSignAndSize b, HasSignAndSize a) => Uninterpreted (SBV c -> SBV b -> SBV a) where+  uninterpretWithHandle nm = (mkUFName nm, f)+    where f arg0 arg1 = SBV sgnsza $ Right $ cache result+           where sgnsza = (hasSign (undefined :: a), sizeOf (undefined :: a))+                 sgnszb = (hasSign (undefined :: b), sizeOf (undefined :: b))+                 sgnszc = (hasSign (undefined :: c), sizeOf (undefined :: c))+                 result st = do newUninterpreted st nm (SBVType [sgnszc, sgnszb, sgnsza])+                                sw0 <- sbvToSW st arg0+                                sw1 <- sbvToSW st arg1+                                mapM_ forceArg [sw0, sw1]+                                newExpr st sgnsza $ SBVApp (Uninterpreted nm) [sw0, sw1]++-- Functions of three arguments+instance (HasSignAndSize d, HasSignAndSize c, HasSignAndSize b, HasSignAndSize a) => Uninterpreted (SBV d -> SBV c -> SBV b -> SBV a) where+  uninterpretWithHandle nm = (mkUFName nm, f)+    where f arg0 arg1 arg2 = SBV sgnsza $ Right $ cache result+           where sgnsza = (hasSign (undefined :: a), sizeOf (undefined :: a))+                 sgnszb = (hasSign (undefined :: b), sizeOf (undefined :: b))+                 sgnszc = (hasSign (undefined :: c), sizeOf (undefined :: c))+                 sgnszd = (hasSign (undefined :: d), sizeOf (undefined :: d))+                 result st = do newUninterpreted st nm (SBVType [sgnszd, sgnszc, sgnszb, sgnsza])+                                sw0 <- sbvToSW st arg0+                                sw1 <- sbvToSW st arg1+                                sw2 <- sbvToSW st arg2+                                mapM_ forceArg [sw0, sw1, sw2]+                                newExpr st sgnsza $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2]++-- Functions of four arguments+instance (HasSignAndSize e, HasSignAndSize d, HasSignAndSize c, HasSignAndSize b, HasSignAndSize a)+            => Uninterpreted (SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where+  uninterpretWithHandle nm = (mkUFName nm, f)+    where f arg0 arg1 arg2 arg3 = SBV sgnsza $ Right $ cache result+           where sgnsza = (hasSign (undefined :: a), sizeOf (undefined :: a))+                 sgnszb = (hasSign (undefined :: b), sizeOf (undefined :: b))+                 sgnszc = (hasSign (undefined :: c), sizeOf (undefined :: c))+                 sgnszd = (hasSign (undefined :: d), sizeOf (undefined :: d))+                 sgnsze = (hasSign (undefined :: e), sizeOf (undefined :: e))+                 result st = do newUninterpreted st nm (SBVType [sgnsze, sgnszd, sgnszc, sgnszb, sgnsza])+                                sw0 <- sbvToSW st arg0+                                sw1 <- sbvToSW st arg1+                                sw2 <- sbvToSW st arg2+                                sw3 <- sbvToSW st arg3+                                mapM_ forceArg [sw0, sw1, sw2, sw3]+                                newExpr st sgnsza $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3]++-- Functions of five arguments+instance (HasSignAndSize f, HasSignAndSize e, HasSignAndSize d, HasSignAndSize c, HasSignAndSize b, HasSignAndSize a)+            => Uninterpreted (SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where+  uninterpretWithHandle nm = (mkUFName nm, f)+    where f arg0 arg1 arg2 arg3 arg4 = SBV sgnsza $ Right $ cache result+           where sgnsza = (hasSign (undefined :: a), sizeOf (undefined :: a))+                 sgnszb = (hasSign (undefined :: b), sizeOf (undefined :: b))+                 sgnszc = (hasSign (undefined :: c), sizeOf (undefined :: c))+                 sgnszd = (hasSign (undefined :: d), sizeOf (undefined :: d))+                 sgnsze = (hasSign (undefined :: e), sizeOf (undefined :: e))+                 sgnszf = (hasSign (undefined :: f), sizeOf (undefined :: f))+                 result st = do newUninterpreted st nm (SBVType [sgnszf, sgnsze, sgnszd, sgnszc, sgnszb, sgnsza])+                                sw0 <- sbvToSW st arg0+                                sw1 <- sbvToSW st arg1+                                sw2 <- sbvToSW st arg2+                                sw3 <- sbvToSW st arg3+                                sw4 <- sbvToSW st arg4+                                mapM_ forceArg [sw0, sw1, sw2, sw3, sw4]+                                newExpr st sgnsza $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4]++-- Functions of six arguments+instance (HasSignAndSize g, HasSignAndSize f, HasSignAndSize e, HasSignAndSize d, HasSignAndSize c, HasSignAndSize b, HasSignAndSize a)+            => Uninterpreted (SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where+  uninterpretWithHandle nm = (mkUFName nm, f)+    where f arg0 arg1 arg2 arg3 arg4 arg5 = SBV sgnsza $ Right $ cache result+           where sgnsza = (hasSign (undefined :: a), sizeOf (undefined :: a))+                 sgnszb = (hasSign (undefined :: b), sizeOf (undefined :: b))+                 sgnszc = (hasSign (undefined :: c), sizeOf (undefined :: c))+                 sgnszd = (hasSign (undefined :: d), sizeOf (undefined :: d))+                 sgnsze = (hasSign (undefined :: e), sizeOf (undefined :: e))+                 sgnszf = (hasSign (undefined :: f), sizeOf (undefined :: f))+                 sgnszg = (hasSign (undefined :: g), sizeOf (undefined :: g))+                 result st = do newUninterpreted st nm (SBVType [sgnszg, sgnszf, sgnsze, sgnszd, sgnszc, sgnszb, sgnsza])+                                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_ forceArg [sw0, sw1, sw2, sw3, sw4, sw5]+                                newExpr st sgnsza $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5]++-- Functions of seven arguments+instance (HasSignAndSize h, HasSignAndSize g, HasSignAndSize f, HasSignAndSize e, HasSignAndSize d, HasSignAndSize c, HasSignAndSize b, HasSignAndSize a)+            => Uninterpreted (SBV h -> SBV g -> SBV f -> SBV e -> SBV d -> SBV c -> SBV b -> SBV a) where+  uninterpretWithHandle nm = (mkUFName nm, f)+    where f arg0 arg1 arg2 arg3 arg4 arg5 arg6 = SBV sgnsza $ Right $ cache result+           where sgnsza = (hasSign (undefined :: a), sizeOf (undefined :: a))+                 sgnszb = (hasSign (undefined :: b), sizeOf (undefined :: b))+                 sgnszc = (hasSign (undefined :: c), sizeOf (undefined :: c))+                 sgnszd = (hasSign (undefined :: d), sizeOf (undefined :: d))+                 sgnsze = (hasSign (undefined :: e), sizeOf (undefined :: e))+                 sgnszf = (hasSign (undefined :: f), sizeOf (undefined :: f))+                 sgnszg = (hasSign (undefined :: g), sizeOf (undefined :: g))+                 sgnszh = (hasSign (undefined :: h), sizeOf (undefined :: h))+                 result st = do newUninterpreted st nm (SBVType [sgnszh, sgnszg, sgnszf, sgnsze, sgnszd, sgnszc, sgnszb, sgnsza])+                                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_ forceArg [sw0, sw1, sw2, sw3, sw4, sw5, sw6]+                                newExpr st sgnsza $ SBVApp (Uninterpreted nm) [sw0, sw1, sw2, sw3, sw4, sw5, sw6]++-- Uncurried functions of two arguments+instance (HasSignAndSize c, HasSignAndSize b, HasSignAndSize a) => Uninterpreted ((SBV c, SBV b) -> SBV a) where+  uninterpretWithHandle nm = let (h, f) = uninterpretWithHandle nm in (h, \(arg0, arg1) -> f arg0 arg1)++-- Uncurried functions of three arguments+instance (HasSignAndSize d, HasSignAndSize c, HasSignAndSize b, HasSignAndSize a) => Uninterpreted ((SBV d, SBV c, SBV b) -> SBV a) where+  uninterpretWithHandle nm = let (h, f) = uninterpretWithHandle nm in (h, \(arg0, arg1, arg2) -> f arg0 arg1 arg2)++-- Uncurried functions of four arguments+instance (HasSignAndSize e, HasSignAndSize d, HasSignAndSize c, HasSignAndSize b, HasSignAndSize a)+            => Uninterpreted ((SBV e, SBV d, SBV c, SBV b) -> SBV a) where+  uninterpretWithHandle nm = let (h, f) = uninterpretWithHandle nm in (h, \(arg0, arg1, arg2, arg3) -> f arg0 arg1 arg2 arg3)++-- Uncurried functions of five arguments+instance (HasSignAndSize f, HasSignAndSize e, HasSignAndSize d, HasSignAndSize c, HasSignAndSize b, HasSignAndSize a)+            => Uninterpreted ((SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where+  uninterpretWithHandle nm = let (h, f) = uninterpretWithHandle nm in (h, \(arg0, arg1, arg2, arg3, arg4) -> f arg0 arg1 arg2 arg3 arg4)++-- Uncurried functions of six arguments+instance (HasSignAndSize g, HasSignAndSize f, HasSignAndSize e, HasSignAndSize d, HasSignAndSize c, HasSignAndSize b, HasSignAndSize a)+            => Uninterpreted ((SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where+  uninterpretWithHandle nm = let (h, f) = uninterpretWithHandle nm in (h, \(arg0, arg1, arg2, arg3, arg4, arg5) -> f arg0 arg1 arg2 arg3 arg4 arg5)++-- Uncurried functions of seven arguments+instance (HasSignAndSize h, HasSignAndSize g, HasSignAndSize f, HasSignAndSize e, HasSignAndSize d, HasSignAndSize c, HasSignAndSize b, HasSignAndSize a)+            => Uninterpreted ((SBV h, SBV g, SBV f, SBV e, SBV d, SBV c, SBV b) -> SBV a) where+  uninterpretWithHandle nm = let (h, f) = uninterpretWithHandle nm in (h, \(arg0, arg1, arg2, arg3, arg4, arg5, arg6) -> f arg0 arg1 arg2 arg3 arg4 arg5 arg6)
+ Temp/sbv-0.9.18/Data/SBV/BitVectors/Polynomial.hs view
@@ -0,0 +1,173 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.BitVectors.Polynomials+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Implementation of polynomial arithmetic+-----------------------------------------------------------------------------++{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE PatternGuards #-}++module Data.SBV.BitVectors.Polynomial (Polynomial(..)) where++import Data.Bits  (Bits(..))+import Data.List  (genericTake)+import Data.Maybe (fromJust)+import Data.Word  (Word8, Word16, Word32, Word64)++import Data.SBV.BitVectors.Data+import Data.SBV.BitVectors.Model+import Data.SBV.BitVectors.Splittable+import Data.SBV.Utils.Boolean++-- | Implements polynomial addition, multiplication, division, and modulus operations+-- over GF(2^n).  NB. Similar to 'bvQuotRem', division by @0@ is interpreted as follows:+--+--     @x `pDivMod` 0 = (0, x)@+--+-- for all @x@ (including @0@)+--+-- Minimal complete definiton: 'pMult', 'pDivMod', 'showPoly'+class Bits a => Polynomial a where+ -- | Given bit-positions to be set, create a polynomial+ -- For instance+ --+ --     @polynomial [0, 1, 3] :: SWord8@+ -- + -- will evaluate to @11@, since it sets the bits @0@, @1@, and @3@. Mathematicans would write this polynomial+ -- as @x^3 + x + 1@. And in fact, 'showPoly' will show it like that.+ polynomial :: [Int] -> a+ -- | Add two polynomials in GF(2^n)+ pAdd  :: a -> a -> a+ -- | Multiply two polynomials in GF(2^n), and reduce it by the irreducible specified by+ -- the polynomial as specified by coefficients of the third argument. Note that the third+ -- argument is specifically left in this form as it is usally in GF(2^(n+1)), which is not available in our+ -- formalism. (That is, we would need SWord9 for SWord8 multiplication, etc.) Also note that we do not+ -- support symbolic irreducibles, which is a minor shortcoming. (Most GF's will come with fixed irreducibles,+ -- so this should not be a problem in practice.)+ --+ -- Passing [] for the third argument will multiply the polynomials and then ignore the higher bits that won't+ -- fit into the resulting size.+ pMult :: (a, a, [Int]) -> a+ -- | Divide two polynomials in GF(2^n), see above note for division by 0+ pDiv  :: a -> a -> a+ -- | Compute modulus of two polynomials in GF(2^n), see above note for modulus by 0+ pMod  :: a -> a -> a+ -- | Division and modulus packed together+ pDivMod :: a -> a -> (a, a)+ -- | Display a polynomial like a mathematician would (over the monomial @x@)+ showPoly :: a -> String++ -- defaults.. Minumum complete definition: pMult, pDivMod, showPoly+ polynomial = foldr (flip setBit) 0+ pAdd       = xor+ pDiv x y   = fst (pDivMod x y)+ pMod x y   = snd (pDivMod x y)++instance Polynomial Word8   where {showPoly = sp;       pMult = lift polyMult; pDivMod = liftC polyDivMod}+instance Polynomial Word16  where {showPoly = sp;       pMult = lift polyMult; pDivMod = liftC polyDivMod}+instance Polynomial Word32  where {showPoly = sp;       pMult = lift polyMult; pDivMod = liftC polyDivMod}+instance Polynomial Word64  where {showPoly = sp;       pMult = lift polyMult; pDivMod = liftC polyDivMod}+instance Polynomial SWord8  where {showPoly = liftS sp; pMult = polyMult;      pDivMod = polyDivMod}+instance Polynomial SWord16 where {showPoly = liftS sp; pMult = polyMult;      pDivMod = polyDivMod}+instance Polynomial SWord32 where {showPoly = liftS sp; pMult = polyMult;      pDivMod = polyDivMod}+instance Polynomial SWord64 where {showPoly = liftS sp; pMult = polyMult;      pDivMod = polyDivMod}++lift :: SymWord a => ((SBV a, SBV a, [Int]) -> SBV a) -> (a, a, [Int]) -> a+lift f (x, y, z) = fromJust $ unliteral $ f (literal x, literal y, z)+liftC :: SymWord a => (SBV a -> SBV a -> (SBV a, SBV a)) -> a -> a -> (a, a)+liftC f x y = let (a, b) = f (literal x) (literal y) in (fromJust (unliteral a), fromJust (unliteral b))+liftS :: SymWord a => (a -> String) -> SBV a -> String+liftS f s+  | Just x <- unliteral s = f x+  | True                  = show s++-- | Pretty print as a polynomial+sp :: Bits a => a -> String+sp a+ | null cs = "0" ++ t+ | True    = foldr (\x y -> sh x ++ " + " ++ y) (sh (last cs)) (init cs) ++ t+ where t  = " :: GF(2^" ++ show n ++ ")"+       n  = bitSize a+       is = [n-1, n-2 .. 0]+       cs = map fst $ filter snd $ zip is (map (testBit a) is)+       sh 0 = "1"+       sh 1 = "x"+       sh i = "x^" ++ show i++-- | Add two polynomials+addPoly :: [SBool] -> [SBool] -> [SBool]+addPoly xs    []      = xs+addPoly []    ys      = ys+addPoly (x:xs) (y:ys) = x <+> y : addPoly xs ys++ites :: SBool -> [SBool] -> [SBool] -> [SBool]+ites s xs ys+ | Just t <- unliteral s+ = if t then xs else ys+ | True+ = go xs ys+ where go [] []         = []+       go []     (b:bs) = ite s false b : go [] bs+       go (a:as) []     = ite s a false : go as []+       go (a:as) (b:bs) = ite s a b : go as bs++-- | Multiply two polynomials and reduce by the third (concrete) irreducible, given by its coefficients.+-- See the remarks for the 'pMult' function for this design choice+polyMult :: (Bits a, SymWord a, FromBits (SBV a)) => (SBV a, SBV a, [Int]) -> SBV a+polyMult (x, y, red) = fromBitsLE $ genericTake sz $ r ++ repeat false+  where (_, r) = mdp ms rs+        ms = genericTake (2*sz) $ mul (blastLE x) (blastLE y) [] ++ repeat false+        rs = genericTake (2*sz) $ [if i `elem` red then true else false |  i <- [0 .. foldr max 0 red] ] ++ repeat false+        sz = sizeOf x+        mul _  []     ps = ps+        mul as (b:bs) ps = mul (false:as) bs (ites b (as `addPoly` ps) ps)++polyDivMod :: (Bits a, SymWord a, FromBits (SBV a)) => SBV a -> SBV a -> (SBV a, SBV a)+polyDivMod x y = ite (y .== 0) (0, x) (adjust d, adjust r)+   where adjust xs = fromBitsLE $ genericTake sz $ xs ++ repeat false+         sz     = sizeOf x+         (d, r) = mdp (blastLE x) (blastLE y)++-- conservative over-approximation of the degree+degree :: [SBool] -> Int+degree xs = walk (length xs - 1) $ reverse xs+  where walk n []     = n+        walk n (b:bs)+         | Just t <- unliteral b+         = if t then n else walk (n-1) bs+         | True+         = n -- over-estimate++mdp :: [SBool] -> [SBool] -> ([SBool], [SBool])+mdp xs ys = go (length ys - 1) (reverse ys)+  where degTop  = degree xs+        go _ []     = error "SBV.Polynomial.mdp: Impossible happened; exhausted ys before hitting 0"+        go n (b:bs)+         | n == 0   = (reverse qs, rs)+         | True     = let (rqs, rrs) = go (n-1) bs+                      in (ites b (reverse qs) rqs, ites b rs rrs)+         where degQuot = degTop - n+               ys' = replicate degQuot false ++ ys+               (qs, rs) = divx (degQuot+1) degTop xs ys'++-- return the element at index i; if not enough elements, return false+-- N.B. equivalent to '(xs ++ repeat false) !! i', but more efficient+idx :: [SBool] -> Int -> SBool+idx []     _ = false+idx (x:_)  0 = x+idx (_:xs) i = idx xs (i-1)++divx :: Int -> Int -> [SBool] -> [SBool] -> ([SBool], [SBool])+divx n _ xs _ | n <= 0 = ([], xs)+divx n i xs ys'        = (q:qs, rs)+  where q        = xs `idx` i+        xs'      = ites q (xs `addPoly` ys') xs+        (qs, rs) = divx (n-1) (i-1) xs' (tail ys')
+ Temp/sbv-0.9.18/Data/SBV/BitVectors/PrettyNum.hs view
@@ -0,0 +1,120 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.BitVectors.PrettyNum+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Number representations in hex/bin+-----------------------------------------------------------------------------++{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE PatternGuards #-}++module Data.SBV.BitVectors.PrettyNum (PrettyNum(..), readBin, shex, sbin) where++import Data.Char  (ord)+import Data.Int   (Int8, Int16, Int32, Int64)+import Data.List  (isPrefixOf)+import Data.Maybe (fromJust)+import Data.Word  (Word8, Word16, Word32, Word64)+import Numeric    (showIntAtBase, showHex, readInt)++import Data.SBV.BitVectors.Data+import Data.SBV.BitVectors.Model () -- instances only++-- | PrettyNum class captures printing of numbers in hex and binary formats; also supporting negative numbers.+--+-- Minimal complete definition: 'hexS' and 'binS'+class PrettyNum a where+  -- | Show a number in hexadecimal (starting with @0x@ and type.)+  hexS :: a -> String+  -- | Show a number in binary (starting with @0b@ and type.)+  binS :: a -> String+  -- | Show a number in hex, without prefix, or types.+  hex :: a -> String+  -- | Show a number in bin, without prefix, or types.+  bin :: a -> String++-- Why not default methods? Because defaults need "Integral a" but Bool is not..+instance PrettyNum Bool where+  {hexS = show; binS = show; hex = show; bin = show}+instance PrettyNum Word8 where+  {hexS = shex True True (False,8) ; binS = sbin True True (False,8) ; hex = shex False False (False,8) ; bin = sbin False False (False,8) ;}+instance PrettyNum Int8 where+  {hexS = shex True True (True,8)  ; binS = sbin True True (True,8)  ; hex = shex False False (True,8)  ; bin = sbin False False (True,8)  ;}+instance PrettyNum Word16 where+  {hexS = shex True True (False,16); binS = sbin True True (False,16); hex = shex False False (False,16); bin = sbin False False (False,16);}+instance PrettyNum Int16  where+  {hexS = shex True True (True,16);  binS = sbin True True (True,16) ; hex = shex False False (True,16);  bin = sbin False False (True,16) ;}+instance PrettyNum Word32 where+  {hexS = shex True True (False,32); binS = sbin True True (False,32); hex = shex False False (False,32); bin = sbin False False (False,32);}+instance PrettyNum Int32  where+  {hexS = shex True True (True,32);  binS = sbin True True (True,32) ; hex = shex False False (True,32);  bin = sbin False False (True,32) ;}+instance PrettyNum Word64 where+  {hexS = shex True True (False,64); binS = sbin True True (False,64); hex = shex False False (False,64); bin = sbin False False (False,64);}+instance PrettyNum Int64  where+  {hexS = shex True True (True,64);  binS = sbin True True (True,64) ; hex = shex False False (True,64);  bin = sbin False False (True,64) ;}++instance PrettyNum CW where+  hexS cw | cwIsBit cw  = hexS (cwToBool cw)+  hexS cw               = shex True True (hasSign cw, sizeOf cw) (cwVal cw)++  binS cw | cwIsBit cw  = binS (cwToBool cw)+  binS cw               = sbin True True (hasSign cw, sizeOf cw) (cwVal cw)++  hex cw | cwIsBit cw   = hexS (cwToBool cw)+  hex cw                = shex False False (hasSign cw, sizeOf cw) (cwVal cw)++  bin cw | cwIsBit cw   = binS (cwToBool cw)+  bin cw                = sbin False False (hasSign cw, sizeOf cw) (cwVal cw)++instance (SymWord a, PrettyNum a) => PrettyNum (SBV a) where+  hexS s = maybe (show s) (hexS :: a -> String) $ unliteral s+  binS s = maybe (show s) (binS :: a -> String) $ unliteral s+  hex  s = maybe (show s) (hex :: a -> String)  $ unliteral s+  bin  s = maybe (show s) (bin :: a -> String)  $ unliteral s++shex :: (Integral a) => Bool -> Bool -> (Bool, Size) -> a -> String+shex shType shPre (signed, size) a+ | a < 0+ = "-" ++ pre ++ pad l (s16 (abs ((fromIntegral a) :: Integer)))  ++ t+ | True+ =  pre ++ pad l (s16 a) ++ t+ where t | shType = " :: " ++ (if signed then "Int" else "Word") ++ show size+         | True   = ""+       pre | shPre = "0x"+           | True  = ""+       l = (size + 3) `div` 4++sbin :: (Integral a) => Bool -> Bool -> (Bool, Size) -> a -> String+sbin shType shPre (signed,size) a+ | a < 0+ = "-" ++ pre ++ pad size (s2 (abs ((fromIntegral a) :: Integer)))  ++ t+ | True+ =  pre ++ pad size (s2 a) ++ t+ where t | shType = " :: " ++ (if signed then "Int" else "Word") ++ show size+         | True   = ""+       pre | shPre = "0b"+           | True  = ""++pad :: Int -> String -> String+pad l s = replicate (l - length s) '0' ++ s++s2, s16 :: Integral a => a -> String+s2  v = showIntAtBase 2 dig v "" where dig = fromJust . flip lookup [(0, '0'), (1, '1')]+s16 v = showHex v ""++-- | A more convenient interface for reading binary numbers, also supports negative numbers+readBin :: Num a => String -> a+readBin ('-':s) = -(readBin s)+readBin s = case readInt 2 isDigit cvt s' of+              [(a, "")] -> a+              _         -> error $ "SBV.readBin: Cannot read a binary number from: " ++ show s+  where cvt c = ord c - ord '0'+        isDigit = (`elem` "01")+        s' | "0b" `isPrefixOf` s = drop 2 s+           | True                = s
+ Temp/sbv-0.9.18/Data/SBV/BitVectors/Splittable.hs view
@@ -0,0 +1,153 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.BitVectors.Splittable+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Implementation of bit-vector concatanetation and splits+-----------------------------------------------------------------------------++{-# LANGUAGE MultiParamTypeClasses #-}+{-# LANGUAGE FunctionalDependencies #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE BangPatterns #-}++module Data.SBV.BitVectors.Splittable (Splittable(..), FromBits(..)) where++import Data.Bits (Bits(..))+import Data.Word (Word8, Word16, Word32, Word64)++import Data.SBV.BitVectors.Data+import Data.SBV.BitVectors.Model++infixr 5 #+-- | Splitting an @a@ into two @b@'s and joining back.+-- Intuitively, @a@ is a larger bit-size word than @b@, typically double.+-- The 'extend' operation captures embedding of a @b@ value into an @a@+-- without changing its semantic value.+--+-- Minimal complete definition: All, no defaults.+class Splittable a b | b -> a where+  split  :: a -> (b, b)+  (#)    :: b -> b -> a+  extend :: b -> a++genSplit :: (Integral a, Num b) => Int -> a -> (b, b)+genSplit ss x = (fromIntegral ((ix `shiftR` ss) .&. mask), fromIntegral (ix .&. mask))+  where ix = toInteger x+        mask = 2 ^ ss - 1++genJoin :: (Integral b, Num a) => Int -> b -> b -> a+genJoin ss x y = fromIntegral ((ix `shiftL` ss) .|. iy)+  where ix = toInteger x+        iy = toInteger y++-- concrete instances+instance Splittable Word64 Word32 where+  split = genSplit 32+  (#)   = genJoin  32+  extend b = 0 # b++instance Splittable Word32 Word16 where+  split = genSplit 16+  (#)   = genJoin  16+  extend b = 0 # b++instance Splittable Word16 Word8 where+  split = genSplit 8+  (#)   = genJoin  8+  extend b = 0 # b++cwSplit :: (SymWord a, Num a) => CW -> (SBV a, SBV a)+cwSplit z = (literal x, literal y)+  where (x,y) = genSplit (sizeOf z `div` 2) (cwVal z)++cwJoin :: (SymWord a, Num a) => CW -> CW -> SBV a+cwJoin x y = literal (genJoin (sizeOf x) (cwVal x) (cwVal y))++-- symbolic instances+instance Splittable SWord64 SWord32 where+  split (SBV _ (Left z)) = cwSplit z+  split z = (SBV (False, 32) (Right (cache x)), SBV (False, 32) (Right (cache y)))+    where x st = do zsw <- sbvToSW st z+                    newExpr st (False, 32) (SBVApp (Extract 63 32) [zsw])+          y st = do zsw <- sbvToSW st z+                    newExpr st (False, 32) (SBVApp (Extract 31  0) [zsw])+  (SBV _ (Left a)) # (SBV _ (Left b)) = cwJoin a b+  a # b = SBV (False, 64) (Right (cache c))+    where c st = do asw <- sbvToSW st a+                    bsw <- sbvToSW st b+                    newExpr st (False, 64) (SBVApp Join [asw, bsw])+  extend b = 0 # b++instance Splittable SWord32 SWord16 where+  split (SBV _ (Left z)) = cwSplit z+  split z                      = (SBV (False, 16) (Right (cache x)), SBV (False, 16) (Right (cache y)))+    where x st = do zsw <- sbvToSW st z+                    newExpr st (False, 16) (SBVApp (Extract 31 16) [zsw])+          y st = do zsw <- sbvToSW st z+                    newExpr st (False, 16) (SBVApp (Extract 15  0) [zsw])+  (SBV _ (Left a)) # (SBV _ (Left b)) = cwJoin a b+  a # b = SBV (False, 32) (Right (cache c))+    where c st = do asw <- sbvToSW st a+                    bsw <- sbvToSW st b+                    newExpr st (False, 32) (SBVApp Join [asw, bsw])+  extend b = 0 # b++instance Splittable SWord16 SWord8 where+  split (SBV _ (Left z)) = cwSplit z+  split z                = (SBV (False, 8) (Right (cache x)), SBV (False, 8) (Right (cache y)))+    where x st = do zsw <- sbvToSW st z+                    newExpr st (False, 8) (SBVApp (Extract 15 8) [zsw])+          y st = do zsw <- sbvToSW st z+                    newExpr st (False, 8) (SBVApp (Extract  7 0) [zsw])+  (SBV _ (Left a)) # (SBV _ (Left b)) = cwJoin a b+  a # b = SBV (False, 16) (Right (cache c))+    where c st = do asw <- sbvToSW st a+                    bsw <- sbvToSW st b+                    newExpr st (False, 16) (SBVApp Join [asw, bsw])+  extend b = 0 # b++-- | Unblasting a value from symbolic-bits. The bits can be given little-endian+-- or big-endian. For a signed number in little-endian, we assume the very last bit+-- is the sign digit. This is a bit awkward, but it is more consistent with the "reverse" view of+-- little-big-endian representations+--+-- Minimal complete definiton: 'fromBitsLE'+class FromBits a where+ fromBitsLE, fromBitsBE :: [SBool] -> a+ fromBitsBE = fromBitsLE . reverse++-- | Construct a symbolic word from its bits given in little-endian+fromBinLE :: (Bits a, SymWord a) => [SBool] -> SBV a+fromBinLE = go 0 0+  where go !acc _  []     = acc+        go !acc !i (x:xs) = go (ite x (setBit acc i) acc) (i+1) xs++-- | Perform a sanity check that we should receive precisely the same+-- number of bits as required by the resulting type. The input is little-endian+checkAndConvert :: (Bits a, SymWord a) => Int -> [SBool] -> SBV a+checkAndConvert sz xs+  | sz /= l+  = error $ "SBV.fromBits.SWord" ++ ssz ++ ": Expected " ++ ssz ++ " elements, got: " ++ show l+  | True+  = fromBinLE xs+  where l   = length xs+        ssz = show sz++instance FromBits SBool where+ fromBitsLE [x] = x+ fromBitsLE xs  = error $ "SBV.fromBits.SBool: Expected 1 element, got: " ++ show (length xs)++instance FromBits SWord8  where fromBitsLE = checkAndConvert  8+instance FromBits SInt8   where fromBitsLE = checkAndConvert  8+instance FromBits SWord16 where fromBitsLE = checkAndConvert 16+instance FromBits SInt16  where fromBitsLE = checkAndConvert 16+instance FromBits SWord32 where fromBitsLE = checkAndConvert 32+instance FromBits SInt32  where fromBitsLE = checkAndConvert 32+instance FromBits SWord64 where fromBitsLE = checkAndConvert 64+instance FromBits SInt64  where fromBitsLE = checkAndConvert 64
+ Temp/sbv-0.9.18/Data/SBV/Compilers/C.hs view
@@ -0,0 +1,568 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Compilers.C+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Compilation of symbolic programs to C+-----------------------------------------------------------------------------++{-# LANGUAGE PatternGuards #-}++module Data.SBV.Compilers.C(compileToC, compileToCLib, compileToC', compileToCLib') where++import Data.Char (isSpace)+import Data.Maybe (isJust)+import qualified Data.Foldable as F (toList)+import Text.PrettyPrint.HughesPJ+import System.FilePath (takeBaseName, replaceExtension)+import System.Random++import Data.SBV.BitVectors.Data+import Data.SBV.BitVectors.PrettyNum(shex)+import Data.SBV.Compilers.CodeGen++---------------------------------------------------------------------------+-- * API+---------------------------------------------------------------------------++-- | Given a symbolic computation, render it as an equivalent collection of files+-- that make up a C program:+--+--   * The first argument is the directory name under which the files will be saved. To save+--     files in the current directory pass @'Just' \".\"@. Use 'Nothing' for printing to stdout.+--+--   * The second argument is the name of the C function to generate.+--+--   * The final argument is the function to be compiled.+--+-- Compilation will also generate a @Makefile@,  a header file, and a driver (test) program, etc.+compileToC :: Maybe FilePath -> String -> SBVCodeGen () -> IO ()+compileToC mbDirName nm f = compileToC' nm f >>= renderCgPgmBundle mbDirName++-- | Lower level version of 'compileToC', producing a 'CgPgmBundle'+compileToC' :: String -> SBVCodeGen () -> IO CgPgmBundle+compileToC' nm f = do rands <- newStdGen >>= return . randoms+                      codeGen SBVToC (defaultCgConfig { cgDriverVals = rands }) nm f++-- | Create code to generate a library archive (.a) from given symbolic functions. Useful when generating code+-- from multiple functions that work together as a library.+--+--   * The first argument is the directory name under which the files will be saved. To save+--     files in the current directory pass @'Just' \".\"@. Use 'Nothing' for printing to stdout.+--+--   * The second argument is the name of the archive to generate.+--+--   * The third argument is the list of functions to include, in the form of function-name/code pairs, similar+--     to the second and third arguments of 'compileToC', except in a list.+compileToCLib :: Maybe FilePath -> String -> [(String, SBVCodeGen ())] -> IO ()+compileToCLib mbDirName libName comps = compileToCLib' libName comps >>= renderCgPgmBundle mbDirName++-- | Lower level version of 'compileToCLib', producing a 'CgPgmBundle'+compileToCLib' :: String -> [(String, SBVCodeGen ())] -> IO CgPgmBundle+compileToCLib' libName comps = mergeToLib libName `fmap` mapM (uncurry compileToC') comps++---------------------------------------------------------------------------+-- * Implementation+---------------------------------------------------------------------------++-- token for the target language+data SBVToC = SBVToC++instance CgTarget SBVToC where+  targetName _ = "C"+  translate _  = cgen++-- Unexpected input, or things we will probably never support+die :: String -> a+die msg = error $ "SBV->C: Unexpected: " ++ msg++-- Unsupported features, or features TBD+tbd :: String -> a+tbd msg = error $ "SBV->C: Not yet supported: " ++ msg++cgen :: Bool -> [Integer] -> String -> CgState -> Result -> CgPgmBundle+cgen rtc randVals nm st sbvProg = CgPgmBundle+        [ ("Makefile",  (CgMakefile,     [genMake   nm nmd]))+        , (nm  ++ ".h", (CgHeader [sig], [genHeader nm [sig]]))+        , (nmd ++ ".c", (CgDriver,       genDriver randVals nm ins outs mbRet))+        , (nm  ++ ".c", (CgSource,       genCProg rtc nm sig sbvProg ins outs mbRet))+        ]+  where nmd = nm ++ "_driver"+        sig = pprCFunHeader nm ins outs mbRet+        ins      = cgInputs st+        outs     = cgOutputs st+        mbRet    = case cgReturns st of+                     []           -> Nothing+                     [CgAtomic o] -> Just o+                     [CgArray _]  -> tbd $ "Non-atomic return values"+                     _            -> tbd $ "Multiple return values"++-- | Pretty print a functions type. If there is only one output, we compile it+-- as a function that returns that value. Otherwise, we compile it as a void function+-- that takes return values as pointers to be updated.+pprCFunHeader :: String -> [(String, CgVal)] -> [(String, CgVal)] -> Maybe SW -> Doc+pprCFunHeader fn ins outs mbRet = retType <+> text fn <> parens (fsep (punctuate comma (map mkParam ins ++ map mkPParam outs)))+  where retType = case mbRet of+                   Nothing -> text "void"+                   Just sw -> pprCWord False (hasSign sw, sizeOf sw)++mkParam, mkPParam :: (String, CgVal) -> Doc+mkParam  (n, CgAtomic sw)     = let sgsz = (hasSign sw, sizeOf sw) in pprCWord True  sgsz <+> text n+mkParam  (_, CgArray  [])     = die $ "mkParam: CgArray with no elements!"+mkParam  (n, CgArray  (sw:_)) = let sgsz = (hasSign sw, sizeOf sw) in pprCWord True  sgsz <+> text "*" <> text n+mkPParam (n, CgAtomic sw)     = let sgsz = (hasSign sw, sizeOf sw) in pprCWord False sgsz <+> text "*" <> text n+mkPParam (_, CgArray  [])     = die $ "mPkParam: CgArray with no elements!"+mkPParam (n, CgArray  (sw:_)) = let sgsz = (hasSign sw, sizeOf sw) in pprCWord False sgsz <+> text "*" <> text n++-- | Renders as "const SWord8 s0", etc. the first parameter is the width of the typefield+declSW :: Int -> SW -> Doc+declSW w sw@(SW sgsz _) = text "const" <+> pad (showCType sgsz) <+> text (show sw)+  where pad s = text $ s ++ take (w - length s) (repeat ' ')++-- | Renders as "s0", etc, or the corresponding constant+showSW :: [(SW, CW)] -> SW -> Doc+showSW consts sw+  | sw == falseSW                 = text "0"+  | sw == trueSW                  = text "1"+  | Just cw <- sw `lookup` consts = showConst cw+  | True                          = text $ show sw++-- | Words as it would be defined in the standard header stdint.h+pprCWord :: Bool -> (Bool, Int) -> Doc+pprCWord cnst sgsz = (if cnst then text "const" else empty) <+> text (showCType sgsz)++showCType :: (Bool, Int) -> String+showCType (False, 1) = "SBool"+showCType (s, sz)+  | sz `elem` [8, 16, 32, 64] = t+  | True                      = die $ "Non-regular bitvector type: " ++ t+ where t = (if s then "SInt" else "SWord") ++ show sz++-- | The printf specifier for the type+specifier :: (Bool, Int) -> Doc+specifier (False,  1) = text "%d"+specifier (False,  8) = text "%\"PRIu8\""+specifier (True,   8) = text "%\"PRId8\""+specifier (False, 16) = text "0x%04\"PRIx16\"U"+specifier (True,  16) = text "%\"PRId16\""+specifier (False, 32) = text "0x%08\"PRIx32\"UL"+specifier (True,  32) = text "%\"PRId32\"L"+specifier (False, 64) = text "0x%016\"PRIx64\"ULL"+specifier (True,  64) = text "%\"PRId64\"LL"+specifier (s, sz)     = die $ "Format specifier at type " ++ (if s then "SInt" else "SWord") ++ show sz++-- | Make a constant value of the given type. We don't check for out of bounds here, as it should not be needed.+--   There are many options here, using binary, decimal, etc. We simply+--   8-bit or less constants using decimal; otherwise we use hex.+--   Note that this automatically takes care of the boolean (1-bit) value problem, since it+--   shows the result as an integer, which is OK as far as C is concerned.+mkConst :: Integer -> (Bool, Int) -> Doc+mkConst i   (False,  1) = integer i+mkConst i   (False,  8) = integer i+mkConst i   (True,   8) = integer i+mkConst i t@(False, 16) = text (shex False True t i) <> text "U"+mkConst i t@(True,  16) = text (shex False True t i)+mkConst i t@(False, 32) = text (shex False True t i) <> text "UL"+mkConst i t@(True,  32) = text (shex False True t i) <> text "L"+mkConst i t@(False, 64) = text (shex False True t i) <> text "ULL"+mkConst i t@(True,  64) = text (shex False True t i) <> text "LL"+mkConst i   (True,  1)  = die $ "Signed 1-bit value " ++ show i+mkConst i   (s, sz)     = die $ "Constant " ++ show i ++ " at type " ++ (if s then "SInt" else "SWord") ++ show sz++-- | Show a constant+showConst :: CW -> Doc+showConst cw = mkConst (cwVal cw) (hasSign cw, sizeOf cw)++-- | Generate a makefile+genMake :: String -> String -> Doc+genMake fn dn =+     text "# Makefile for" <+> nm <> text ". Automatically generated by SBV. Do not edit!"+  $$ text ""+  $$ text "CC=gcc"+  $$ text "CCFLAGS=-Wall -O3 -DNDEBUG -fomit-frame-pointer"+  $$ text ""+  $$ text "all:" <+> nmd+  $$ text ""+  $$ nmo <> text (": " ++ ppSameLine (hsep [nmc, nmh]))+  $$ text "\t${CC} ${CCFLAGS}" <+> text "-c $< -o $@"+  $$ text ""+  $$ nmdo <> text ":" <+> nmdc+  $$ text "\t${CC} ${CCFLAGS}" <+> text "-c $< -o $@"+  $$ text ""+  $$ nmd <> text (": " ++ ppSameLine (hsep [nmo, nmdo]))+  $$ text "\t${CC} ${CCFLAGS}" <+> text "$^ -o $@"+  $$ text ""+  $$ text "clean:"+  $$ text "\trm -f *.o"+  $$ text ""+  $$ text "veryclean: clean"+  $$ text "\trm -f" <+> nmd+  $$ text ""+ where nm   = text fn+       nmd  = text dn+       nmh  = nm <> text ".h"+       nmc  = nm <> text ".c"+       nmo  = nm <> text ".o"+       nmdc = nmd <> text ".c"+       nmdo = nmd <> text ".o"++-- | Generate the header+genHeader :: String -> [Doc] -> Doc+genHeader fn sigs =+     text "/* Header file for" <+> nm <> text ". Automatically generated by SBV. Do not edit! */"+  $$ text ""+  $$ text "#ifndef" <+> tag+  $$ text "#define" <+> tag+  $$ text ""+  $$ text "#include <inttypes.h>"+  $$ text "#include <stdint.h>"+  $$ text ""+  $$ text "/* Unsigned bit-vectors */"+  $$ text "typedef uint8_t  SBool  ;"+  $$ text "typedef uint8_t  SWord8 ;"+  $$ text "typedef uint16_t SWord16;"+  $$ text "typedef uint32_t SWord32;"+  $$ text "typedef uint64_t SWord64;"+  $$ text ""+  $$ text "/* Signed bit-vectors */"+  $$ text "typedef int8_t  SInt8 ;"+  $$ text "typedef int16_t SInt16;"+  $$ text "typedef int32_t SInt32;"+  $$ text "typedef int64_t SInt64;"+  $$ text ""+  $$ text ("/* Entry point prototype" ++ plu ++ ": */")+  $$ vcat (map (<> semi) sigs)+  $$ text ""+  $$ text "#endif /*" <+> tag <+> text "*/"+  $$ text ""+ where nm  = text fn+       tag = text "__" <> nm <> text "__HEADER_INCLUDED__"+       plu = if length sigs /= 1 then "s" else ""++sepIf :: Bool -> Doc+sepIf b = if b then text "" else empty++-- | Generate an example driver program+genDriver :: [Integer] -> String -> [(String, CgVal)] -> [(String, CgVal)] -> Maybe SW -> [Doc]+genDriver randVals fn inps outs mbRet = [pre, header, body, post]+ where pre    =  text "/* Example driver program for" <+> nm <> text ". */"+              $$ text "/* Automatically generated by SBV. Edit as you see fit! */"+              $$ text ""+              $$ text "#include <inttypes.h>"+              $$ text "#include <stdint.h>"+              $$ text "#include <stdio.h>"+       header =  text "#include" <+> doubleQuotes (nm <> text ".h")+              $$ text ""+              $$ text "int main(void)"+              $$ text "{"+       body   =  text ""+              $$ nest 2 (   vcat (map mkInp pairedInputs)+                      $$ vcat (map mkOut outs)+                      $$ sepIf (not (null [() | (_, _, CgArray{}) <- pairedInputs]) || not (null outs))+                      $$ call+                      $$ text ""+                      $$ (case mbRet of+                              Just sw -> text "printf" <> parens (printQuotes (fcall <+> text "=" <+> specifier (hasSign sw, sizeOf sw) <> text "\\n")+                                                                              <> comma <+> resultVar) <> semi+                              Nothing -> text "printf" <> parens (printQuotes (fcall <+> text "->\\n")) <> semi)+                      $$ vcat (map display outs)+                      )+       post   =   text ""+              $+$ nest 2 (text "return 0" <> semi)+              $$  text "}"+              $$  text ""+       nm = text fn+       pairedInputs = matchRands (map abs randVals) inps+       matchRands _      []                                   = []+       matchRands []     _                                    = die $ "Run out of driver values!"+       matchRands (r:rs) ((n, CgAtomic sw)              : cs) = ([mkRVal sw r], n, CgAtomic sw) : matchRands rs cs+       matchRands _      ((n, CgArray [])               : _ ) = die $ "Unsupported empty array input " ++ show n+       matchRands rs     ((n, a@(CgArray sws@((sw:_)))) : cs)+          | length frs /= l                                   = die $ "Run out of driver values!"+          | True                                              = (map (mkRVal sw) frs, n, a) : matchRands srs cs+          where l          = length sws+                (frs, srs) = splitAt l rs+       mkRVal sw r = mkConst ival sgsz+         where sgsz@(sg, sz) = (hasSign sw, sizeOf sw)+               ival | r >= minVal && r <= maxVal = r+                    | not sg                     = r `mod` (2^sz)+                    | True                       = (r `mod` (2^sz)) - (2^(sz-1))+                    where expSz, expSz', minVal, maxVal :: Integer+                          expSz  = 2^(sz-1)+                          expSz' = 2*expSz+                          minVal | not sg = 0+                                 | True   = -expSz+                          maxVal | not sg = expSz'-1+                                 | True   = expSz-1+       mkInp (_,  _, CgAtomic{})         = empty  -- constant, no need to declare+       mkInp (_,  n, CgArray [])         = die $ "Unsupported empty array value for " ++ show n+       mkInp (vs, n, CgArray sws@(sw:_)) =  pprCWord True (hasSign sw, sizeOf sw) <+> text n <> brackets (int (length sws)) <+> text "= {"+                                                      $$ nest 4 (fsep (punctuate comma (align vs)))+                                                      $$ text "};"+                                         $$ text ""+                                         $$ text "printf" <> parens (printQuotes (text "Contents of input array" <+> text n <> text ":\\n")) <> semi+                                         $$ display (n, CgArray sws)+                                         $$ text ""+       mkOut (v, CgAtomic sw)            = let sgsz = (hasSign sw, sizeOf sw) in pprCWord False sgsz <+> text v <> semi+       mkOut (v, CgArray [])             = die $ "Unsupported empty array value for " ++ show v+       mkOut (v, CgArray sws@(sw:_))     = pprCWord False (hasSign sw, sizeOf sw) <+> text v <> brackets (int (length sws)) <> semi+       resultVar = text "__result"+       call = case mbRet of+                Nothing -> fcall <> semi+                Just sw -> pprCWord True (hasSign sw, sizeOf sw) <+> resultVar <+> text "=" <+> fcall <> semi+       fcall = nm <> parens (fsep (punctuate comma (map mkCVal pairedInputs ++ map mkOVal outs)))+       mkCVal ([v], _, CgAtomic{}) = v+       mkCVal (vs,  n, CgAtomic{}) = die $ "Unexpected driver value computed for " ++ show n ++ render (hcat vs)+       mkCVal (_,   n, CgArray{})  = text n+       mkOVal (n, CgAtomic{})      = text "&" <> text n+       mkOVal (n, CgArray{})       = text n+       display (n, CgAtomic sw)         = text "printf" <> parens (printQuotes (text " " <+> text n <+> text "=" <+> specifier (hasSign sw, sizeOf sw)+                                                                                <> text "\\n") <> comma <+> text n) <> semi+       display (n, CgArray [])         =  die $ "Unsupported empty array value for " ++ show n+       display (n, CgArray sws@(sw:_)) =   text "int" <+> nctr <> semi+                                        $$ text "for(" <> nctr <+> text "= 0; " <+> nctr <+> text "<" <+> int (length sws) <+> text "; ++" <> nctr <> text ")"+                                        $$ nest 2 (text "printf" <> parens (printQuotes (text " " <+> entrySpec <+> text "=" <+> spec <> text "\\n")+                                                                 <> comma <+> nctr <+> comma <> entry) <> semi)+                  where nctr      = text n <> text "_ctr"+                        entry     = text n <> text "[" <> nctr <> text "]"+                        entrySpec = text n <> text "[%d]"+                        spec      = specifier (hasSign sw, sizeOf sw)++-- | Generate the C program+genCProg :: Bool -> String -> Doc -> Result -> [(String, CgVal)] -> [(String, CgVal)] -> Maybe SW -> [Doc]+genCProg rtc fn proto (Result _ preConsts tbls arrs uints axms asgns _) inVars outVars mbRet+  | not (null arrs)  = tbd "User specified arrays"+  | not (null uints) = tbd "Uninterpreted constants"+  | not (null axms)  = tbd "User given axioms"+  | True+  = [pre, header, post]+ where pre    = text "/* File:" <+> doubleQuotes (nm <> text ".c") <> text ". Automatically generated by SBV. Do not edit! */"+              $$ text ""+              $$ text "#include <inttypes.h>"+              $$ text "#include <stdint.h>"+       header = text "#include" <+> doubleQuotes (nm <> text ".h")+       post   =  text ""+              $$ proto+              $$ text "{"+              $$ text ""+              $$ nest 2 (   vcat (concatMap (genIO True) inVars)+                         $$ vcat (merge (map genTbl tbls) (map genAsgn assignments))+                         $$ sepIf (not (null assignments) || not (null tbls))+                         $$ vcat (concatMap (genIO False) outVars)+                         $$ maybe empty mkRet mbRet+                        )+              $$ text "}"+              $$ text ""+       nm = text fn+       assignments = F.toList asgns+       typeWidth = getMax 0 [len (hasSign s, sizeOf s) | (s, _) <- assignments]+                where len (False, 1) = 5 -- SBool+                      len (False, n) = 5 + length (show n) -- SWordN+                      len (True,  n) = 4 + length (show n) -- SIntN+                      getMax 7 _      = 7  -- 7 is the max we can get with SWord64, so don't bother looking any further+                      getMax m []     = m+                      getMax m (x:xs) = getMax (m `max` x) xs+       consts = (falseSW, falseCW) : (trueSW, trueCW) : preConsts+       isConst s = isJust (lookup s consts)+       genIO :: Bool -> (String, CgVal) -> [Doc]+       genIO True  (cNm, CgAtomic sw) = [declSW typeWidth sw  <+> text "=" <+> text cNm         <> semi]+       genIO False (cNm, CgAtomic sw) = [text "*" <> text cNm <+> text "=" <+> showSW consts sw <> semi]+       genIO isInp (cNm, CgArray sws) = zipWith genElt sws [(0::Int)..]+         where genElt sw i+                 | isInp = declSW typeWidth sw <+> text "=" <+> text entry       <> semi+                 | True  = text entry          <+> text "=" <+> showSW consts sw <> semi+                 where entry = cNm ++ "[" ++ show i ++ "]"+       mkRet sw = text "return" <+> showSW consts sw <> semi+       genTbl :: ((Int, (Bool, Int), (Bool, Int)), [SW]) -> (Int, Doc)+       genTbl ((i, _, (sg, sz)), elts) =  (location, static <+> pprCWord True (sg, sz) <+> text ("table" ++ show i) <> text "[] = {"+                                                     $$ nest 4 (fsep (punctuate comma (align (map (showSW consts) elts))))+                                                     $$ text "};")+         where static   = if location == -1 then text "static" else empty+               location = maximum (-1 : map getNodeId elts)+       getNodeId s@(SW _ (NodeId n)) | isConst s = -1+                                     | True      = n+       genAsgn :: (SW, SBVExpr) -> (Int, Doc)+       genAsgn (sw, n) = (getNodeId sw, declSW typeWidth sw <+> text "=" <+> ppExpr rtc consts n <> semi)+       -- merge tables intermixed with assignments, paying attention to putting tables as+       -- early as possible.. Note that the assignment list (second argument) is sorted on its order+       merge :: [(Int, Doc)] -> [(Int, Doc)] -> [Doc]+       merge []               as                  = map snd as+       merge ts               []                  = map snd ts+       merge ts@((i, t):trest) as@((i', a):arest)+         | i < i'                                 = t : merge trest as+         | True                                   = a : merge ts arest++ppExpr :: Bool -> [(SW, CW)] -> SBVExpr -> Doc+ppExpr rtc consts (SBVApp op opArgs) = p op (map (showSW consts) opArgs)+  where cBinOps = [ (Plus, "+"), (Times, "*"), (Minus, "-")+                  , (Equal, "=="), (NotEqual, "!=")+                  , (LessThan, "<"), (GreaterThan, ">"), (LessEq, "<="), (GreaterEq, ">=")+                  , (And, "&"), (Or, "|"), (XOr, "^")+                  ]+        p (ArrRead _)       _ = tbd $ "User specified arrays (ArrRead)"+        p (ArrEq _ _)       _ = tbd $ "User specified arrays (ArrEq)"+        p (Uninterpreted s) _ = tbd $ "Uninterpreted constants (" ++ show s ++ ")"+        p (Extract i j) [a]   = extract i j (let s = head opArgs in (hasSign s, sizeOf s)) a+        p Join [a, b]         = join (let (s1 : s2 : _) = opArgs in ((hasSign s1, sizeOf s1), (hasSign s2, sizeOf s2), a, b))+        p (Rol i) [a]         = rotate True  i a (let s = head opArgs in (hasSign s, sizeOf s))+        p (Ror i) [a]         = rotate False i a (let s = head opArgs in (hasSign s, sizeOf s))+        p (Shl i) [a]         = shift True  i a (let s = head opArgs in (hasSign s, sizeOf s))+        p (Shr i) [a]         = shift False i a (let s = head opArgs in (hasSign s, sizeOf s))+        p Not [a] = text "~" <> a+        p Ite [a, b, c] = a <+> text "?" <+> b <+> text ":" <+> c+        p (LkUp (t, (as, at), _, len) ind def) []+          | not rtc                    = lkUp -- ignore run-time-checks per user request+          | needsCheckL && needsCheckR = cndLkUp checkBoth+          | needsCheckL                = cndLkUp checkLeft+          | needsCheckR                = cndLkUp checkRight+          | True                       = lkUp+          where [index, defVal] = map (showSW consts) [ind, def]+                lkUp = text "table" <> int t <> brackets (showSW consts ind)+                cndLkUp cnd = cnd <+> text "?" <+> defVal <+> text ":" <+> lkUp+                checkLeft  = index <+> text "< 0"+                checkRight = index <+> text ">=" <+> int len+                checkBoth  = parens (checkLeft <+> text "||" <+> checkRight)+                (needsCheckL, needsCheckR) | as   = (True,  (2::Integer)^(at-1)-1  >= (fromIntegral len))+                                           | True = (False, (2::Integer)^(at)  -1  >= (fromIntegral len))+        -- Div/Rem should be careful on 0, in the SBV world x `div` 0 is 0, x `rem` 0 is x+        p Quot [a, b] = parens (b <+> text "== 0") <+> text "?" <+> text "0" <+> text ":" <+> parens (a <+> text "/" <+> b)+        p Rem  [a, b] = parens (b <+> text "== 0") <+> text "?" <+>    a     <+> text ":" <+> parens (a <+> text "%" <+> b)+        p o [a, b]+          | Just co <- lookup o cBinOps+          = a <+> text co <+> b+        p o args = die $ "Received operator " ++ show o ++ " applied to " ++ show args+        shift toLeft i a (sg, sz)+          | i < 0   = shift (not toLeft) (-i) a (sg, sz)+          | i == 0  = a+          | i >= sz = mkConst 0 (sg, sz)+          | True    = a <+> text cop <+> int i+          where cop | toLeft = "<<"+                    | True   = ">>"+        rotate toLeft i a (True, sz)+          = tbd $ "Rotation of signed words at size " ++ show (toLeft, i, a, sz)+        rotate toLeft i a (False, sz)+          | i < 0   = rotate (not toLeft) (-i) a (False, sz)+          | i == 0  = a+          | i >= sz = rotate toLeft (i `mod` sz) a (False, sz)+          | True    =     parens (a <+> text cop  <+> int i)+                      <+> text "|"+                      <+> parens (a <+> text cop' <+> int (sz - i))+          where (cop, cop') | toLeft = ("<<", ">>")+                            | True   = (">>", "<<")+        -- TBD: below we only support the values that SBV actually currently generates.+        -- we would need to add new ones if we generate others. (Check instances in Data/SBV/BitVectors/Splittable.hs).+        extract 63 32 (False, 64) a = text "(SWord32)" <+> (parens (a <+> text ">> 32"))+        extract 31  0 (False, 64) a = text "(SWord32)" <+> a+        extract 31 16 (False, 32) a = text "(SWord16)" <+> (parens (a <+> text ">> 16"))+        extract 15  0 (False, 32) a = text "(SWord16)" <+> a+        extract 15  8 (False, 16) a = text "(SWord8)"  <+> (parens (a <+> text ">> 8"))+        extract  7  0 (False, 16) a = text "(SWord8)"  <+> a+        extract  i  j (sg, sz)    _ = tbd $ "extract with " ++ show (i, j, (sg, sz))+        -- TBD: ditto here for join, just like extract above+        join ((False,  8), (False,  8), a, b) = parens ((parens (text "(SWord16)" <+> a)) <+> text "<< 8")  <+> text "|" <+> parens (text "(SWord16)" <+> b)+        join ((False, 16), (False, 16), a, b) = parens ((parens (text "(SWord32)" <+> a)) <+> text "<< 16") <+> text "|" <+> parens (text "(SWord32)" <+> b)+        join ((False, 32), (False, 32), a, b) = parens ((parens (text "(SWord64)" <+> a)) <+> text "<< 32") <+> text "|" <+> parens (text "(SWord64)" <+> b)+        join (sgsz1, sgsz2, _, _)             = tbd $ "join with " ++ show (sgsz1, sgsz2)++-- same as doubleQuotes, except we have to make sure there are no line breaks..+-- Otherwise breaks the generated code.. sigh+printQuotes :: Doc -> Doc+printQuotes d = text $ '"' : ppSameLine d ++ "\""++-- Remove newlines.. Useful when generating Makefile and such+ppSameLine :: Doc -> String+ppSameLine = trim . render+ where trim ""        = ""+       trim ('\n':cs) = ' ' : trim (dropWhile isSpace cs)+       trim (c:cs)    = c   : trim cs++-- Align a bunch of docs to occupy the exact same length by padding in the left by space+-- this is ugly and inefficient, but easy to code..+align :: [Doc] -> [Doc]+align ds = map (text . pad) ss+  where ss    = map render ds+        l     = maximum (0 : map length ss)+        pad s = take (l - length s) (repeat ' ') ++ s++-- | Merge a bunch of bundles to generate code for a library+mergeToLib :: String -> [CgPgmBundle] -> CgPgmBundle+mergeToLib libName bundles = CgPgmBundle $ sources ++ [libHeader, libDriver, libMake]+  where files       = concat [fs | CgPgmBundle fs <- bundles]+        sigs        = concat [ss | (_, (CgHeader ss, _)) <- files]+        drivers     = [ds | (_, (CgDriver, ds)) <- files]+        sources     = [(f, (CgSource, [pre, libHInclude, post])) | (f, (CgSource, [pre, _, post])) <- files]+        sourceNms   = map fst sources+        libHeader   = (libName ++ ".h", (CgHeader sigs, [genHeader libName sigs]))+        libHInclude = text "#include" <+> text (show (libName ++ ".h"))+        libMake     = ("Makefile", (CgMakefile, [genLibMake libName sourceNms]))+        libDriver   = (libName ++ "_driver.c", (CgDriver, mergeDrivers libName libHInclude (zip (map takeBaseName sourceNms) drivers)))++-- | Create a Makefile for the library+genLibMake :: String -> [String] -> Doc+genLibMake libName fs =+     text "# Makefile for" <+> nm <> text ". Automatically generated by SBV. Do not edit!"+  $$ text ""+  $$ text "CC=gcc"+  $$ text "CCFLAGS=-Wall -O3 -DNDEBUG -fomit-frame-pointer"+  $$ text "AR=ar"+  $$ text "ARFLAGS=cr"+  $$ text ""+  $$ text ("all: " ++ unwords [liba, libd])+  $$ text ""+  $$ text liba <> text (": " ++ unwords os)+  $$ text "\t${AR} ${ARFLAGS} $@ $^"+  $$ text ""+  $$ text libd <> text (": " ++ unwords [libd ++ ".c", libh])+  $$ text ("\t${CC} ${CCFLAGS} $< -o $@ " ++ liba)+  $$ text ""+  $$ vcat (zipWith mkObj os fs)+  $$ text "clean:"+  $$ text "\trm -f *.o"+  $$ text ""+  $$ text "veryclean: clean"+  $$ text "\trm -f" <+> text (unwords [liba, libd])+  $$ text ""+ where nm = text libName+       liba = libName ++ ".a"+       libh = libName ++ ".h"+       libd = libName ++ "_driver"+       os   = map (flip replaceExtension ".o") fs+       mkObj o f =  text o <> text (":" ++ unwords [f, libh])+                 $$ text "\t${CC} ${CCFLAGS} -c $< -o $@"+                 $$ text ""++-- | Create a driver for a library+mergeDrivers :: String -> Doc -> [(FilePath, [Doc])] -> [Doc]+mergeDrivers libName inc ds = pre : concatMap mkDFun ds ++ [callDrivers (map fst ds)]+  where pre =  text "/* Example driver program for" <+> text libName <> text ". */"+            $$ text "/* Automatically generated by SBV. Edit as you see fit! */"+            $$ text ""+            $$ text "#include <inttypes.h>"+            $$ text "#include <stdint.h>"+            $$ text "#include <stdio.h>"+            $$ inc+        mkDFun (f, [_pre, _header, body, _post]) = [header, body, post]+           where header =  text ""+                        $$ text ("void " ++ f ++ "_driver(void)")+                        $$ text "{"+                 post   =  text "}"+        mkDFun (f, _) = die $ "mergeDrivers: non-conforming driver program for " ++ show f+        callDrivers fs =   text ""+                       $$  text "int main(void)"+                       $$  text "{"+                       $+$ nest 2 (vcat (map call fs))+                       $$  nest 2 (text "return 0;")+                       $$  text "}"+        call f =  text psep+               $$ text ptag+               $$ text psep+               $$ text (f ++ "_driver();")+               $$ text ""+           where tag  = "** Driver run for " ++ f ++ ":"+                 ptag = "printf(\"" ++ tag ++ "\\n\");"+                 lsep = take (length tag) (repeat '=')+                 psep = "printf(\"" ++ lsep ++ "\\n\");"
+ Temp/sbv-0.9.18/Data/SBV/Compilers/CodeGen.hs view
@@ -0,0 +1,179 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Compilers.CodeGen+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Code generation utilities+-----------------------------------------------------------------------------++{-# LANGUAGE FlexibleInstances          #-}+{-# LANGUAGE GeneralizedNewtypeDeriving #-}++module Data.SBV.Compilers.CodeGen where++import Control.Monad.Trans+import Control.Monad.State.Lazy+import Data.Char (toLower)+import Data.List (nub, isPrefixOf, intersperse, (\\))+import System.Directory (createDirectory, doesDirectoryExist, doesFileExist)+import System.FilePath ((</>))+import Text.PrettyPrint.HughesPJ (Doc, render, vcat)++import Data.SBV.BitVectors.Data++-- | Abstract over code generation for different languages+class CgTarget a where+  targetName :: a -> String+  translate  :: a -> Bool -> [Integer] -> String -> CgState -> Result -> CgPgmBundle++-- | Options for code-generation.+data CgConfig = CgConfig {+          cgRTC        :: Bool          -- ^ If 'True', perform run-time-checks for index-out-of-bounds or shifting-by-large values etc.+        , cgDriverVals :: [Integer]     -- ^ Values to use for the driver program generated, useful for generating non-random drivers.+        }++-- | Default options for code generation. The run-time checks are turned-off, and the driver values are completely random.+defaultCgConfig :: CgConfig+defaultCgConfig = CgConfig { cgRTC = False, cgDriverVals = [] }++-- | Abstraction of target language values+data CgVal = CgAtomic SW+           | CgArray  [SW]++data CgState = CgState {+          cgInputs       :: [(String, CgVal)]+        , cgOutputs      :: [(String, CgVal)]+        , cgReturns      :: [CgVal]+        , cgFinalConfig  :: CgConfig+        }++initCgState :: CgState+initCgState = CgState {+          cgInputs       = []+        , cgOutputs      = []+        , cgReturns      = []+        , cgFinalConfig  = defaultCgConfig+        }++-- | The code-generation monad. Allows for precise layout of input values+-- reference parameters (for returning composite values in languages such as C),+-- and return values.+newtype SBVCodeGen a = SBVCodeGen (StateT CgState Symbolic a)+                   deriving (Monad, MonadIO, MonadState CgState)++-- Reach into symbolic monad..+liftSymbolic :: Symbolic a -> SBVCodeGen a+liftSymbolic = SBVCodeGen . lift++-- Reach into symbolic monad and output a value. Returns the corresponding SW+cgSBVToSW :: SBV a -> SBVCodeGen SW+cgSBVToSW = liftSymbolic . sbvToSymSW++-- | Sets RTC (run-time-checks) for index-out-of-bounds, shift-with-large value etc. on/off.+cgPerformRTCs :: Bool -> SBVCodeGen ()+cgPerformRTCs b = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgRTC = b } })++-- | Sets driver program run time values, useful for generating programs with fixed drivers for testing.+cgSetDriverValues :: [Integer] -> SBVCodeGen ()+cgSetDriverValues vs = modify (\s -> s { cgFinalConfig = (cgFinalConfig s) { cgDriverVals = vs } })++-- | Creates an atomic input in the generated code.+cgInput :: (HasSignAndSize a, SymWord a) => String -> SBVCodeGen (SBV a)+cgInput nm = do r <- liftSymbolic free_+                sw <- cgSBVToSW r+                modify (\s -> s { cgInputs = (nm, CgAtomic sw) : cgInputs s })+                return r++-- | Creates an array input in the generated code.+cgInputArr :: (HasSignAndSize a, SymWord a) => Int -> String -> SBVCodeGen [SBV a]+cgInputArr 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 $ (mapM (const free_) [1..sz])+                sws <- mapM cgSBVToSW rs+                modify (\s -> s { cgInputs = (nm, CgArray sws) : cgInputs s })+                return rs++-- | Creates an atomic output in the generated code.+cgOutput :: (HasSignAndSize a, SymWord a) => String -> SBV a -> SBVCodeGen ()+cgOutput nm v = do _ <- liftSymbolic (output v)+                   sw <- cgSBVToSW v+                   modify (\s -> s { cgOutputs = (nm, CgAtomic sw) : cgOutputs s })++-- | Creates an array output in the generated code.+cgOutputArr :: (HasSignAndSize a, SymWord a) => String -> [SBV a] -> SBVCodeGen ()+cgOutputArr nm vs+  | 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 })+  where sz = length vs++-- | Creates a returned (unnamed) value in the generated code.+cgReturn :: (HasSignAndSize a, SymWord a) => SBV a -> SBVCodeGen ()+cgReturn v = do _ <- liftSymbolic (output v)+                sw <- cgSBVToSW v+                modify (\s -> s { cgReturns = CgAtomic sw : cgReturns s })++-- | Creates a returned (unnamed) array value in the generated code.+cgReturnArr :: (HasSignAndSize a, SymWord a) => [SBV a] -> SBVCodeGen ()+cgReturnArr vs+  | 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 })+  where sz = length vs++-- | Representation of a collection of generated programs.+newtype CgPgmBundle = CgPgmBundle [(FilePath, (CgPgmKind, [Doc]))]++-- | Different kinds of "files" we can produce. Currently this is quite "C" specific.+data CgPgmKind = CgMakefile+               | CgHeader [Doc]+               | CgSource+               | CgDriver++instance Show CgPgmBundle where+   show (CgPgmBundle fs) = concat $ intersperse "\n" $ map showFile fs++showFile :: (FilePath, (CgPgmKind, [Doc])) -> String+showFile (f, (_, ds)) =  "== BEGIN: " ++ show f ++ " ================\n"+                      ++ render (vcat ds)+                      ++ "== END: " ++ show f ++ " =================="++codeGen :: CgTarget l => l -> CgConfig -> String -> SBVCodeGen () -> IO CgPgmBundle+codeGen l cgConfig nm (SBVCodeGen comp) = do+   (((), st'), res) <- runSymbolic' $ runStateT comp initCgState { cgFinalConfig = cgConfig }+   let st = st' { cgInputs       = reverse (cgInputs st')+                , cgOutputs      = reverse (cgOutputs st')+                }+       allNamedVars = map fst (cgInputs st ++ cgOutputs st)+       dupNames = allNamedVars \\ nub allNamedVars+   when (not (null dupNames)) $ do+        error $ "SBV.codeGen: " ++ show nm ++ " has following argument names duplicated: " ++ unwords dupNames+   let finalCfg = cgFinalConfig st+   return $ translate l (cgRTC finalCfg) (cgDriverVals finalCfg) nm st res++renderCgPgmBundle :: Maybe FilePath -> CgPgmBundle -> IO ()+renderCgPgmBundle Nothing        bundle              = putStrLn $ show bundle+renderCgPgmBundle (Just dirName) (CgPgmBundle files) = do+        b <- doesDirectoryExist dirName+        when (not b) $ do putStrLn $ "Creating directory " ++ show dirName ++ ".."+                          createDirectory dirName+        dups <- filterM (\fn -> doesFileExist (dirName </> fn)) (map fst files)+        goOn <- case dups of+                  [] -> return True+                  _  -> do putStrLn $ "Code generation would override the following " ++ (if length dups == 1 then "file:" else "files:")+                           mapM_ (\fn -> putStrLn ("\t" ++ fn)) dups+                           putStr "Continue? [yn] "+                           resp <- getLine+                           return $ map toLower resp `isPrefixOf` "yes"+        if goOn then do mapM_ renderFile files+                        putStrLn "Done."+                else putStrLn "Aborting."+  where renderFile (f, (_, ds)) = do let fn = dirName </> f+                                     putStrLn $ "Generating: " ++ show fn ++ ".."+                                     writeFile fn (render (vcat ds))
+ Temp/sbv-0.9.18/Data/SBV/Examples/Arrays/Memory.hs view
@@ -0,0 +1,44 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Arrays.Memory+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Simple memory abstraction and properties+-----------------------------------------------------------------------------++module Data.SBV.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
+ Temp/sbv-0.9.18/Data/SBV/Examples/Basics/BasicTests.hs view
@@ -0,0 +1,47 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Basics.BasicTests+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Basic tests of the sbv library+-----------------------------------------------------------------------------++{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE ScopedTypeVariables #-}++module Data.SBV.Examples.Basics.BasicTests where++import Data.SBV+import Data.SBV.Internals++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 = runSymbolic $ do let x = literal (3 :: Word8)+                               y = literal (2 :: Word8)+                           output $ f x y+test2 f = runSymbolic $ do let x = literal (3 :: Word8)+                           y :: SWord8 <- free "y"+                           output $ f x y+test3 f = runSymbolic $ do x :: SWord8 <- free "x"+                           y :: SWord8 <- free "y"+                           output $ f x y+test4 f = runSymbolic $ do x :: SWord8 <- free "x"+                           output $ f x x+test5 f = runSymbolic $ do x :: SWord8 <- free "x"+                           let r = f x x+                           q :: SWord8 <- free "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
+ Temp/sbv-0.9.18/Data/SBV/Examples/Basics/Higher.hs view
@@ -0,0 +1,50 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Basics.Higher+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Testing function equality+-----------------------------------------------------------------------------++module Data.SBV.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+     ]
+ Temp/sbv-0.9.18/Data/SBV/Examples/Basics/Index.hs view
@@ -0,0 +1,69 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Basics.Index+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Testing the select function+-----------------------------------------------------------------------------++module Data.SBV.Examples.Basics.Index where++import Data.SBV++-- prove that the "select" primitive is working correctly+test1 :: Int -> IO Bool+test1 n = isTheorem $ do+            elts <- mkFreeVars n+            err  <- free_+            ind  <- free_+            ind2 <- free_+            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 <- mkFreeVars n+            elts2 <- mkFreeVars n+            let elts = zip elts1 elts2+            err1  <- free_+            err2  <- free_+            let err = (err1, err2)+            ind  <- free_+            ind2 <- free_+            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 <- mkFreeVars n+            let elts = map Left eltsI+            errI  <- free_+            let err = Left errI+            ind  <- free_+            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
+ Temp/sbv-0.9.18/Data/SBV/Examples/Basics/ProofTests.hs view
@@ -0,0 +1,44 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Basics.ProofTests+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Basic proofs+-----------------------------------------------------------------------------++{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE ScopedTypeVariables #-}++module Data.SBV.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 f1eqf2     -- yes. any output ok+             print =<< sat f1eqf3     -- yes, 0;0
+ Temp/sbv-0.9.18/Data/SBV/Examples/Basics/QRem.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Basics.QRem+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Testing the qrem (quote-rem) function+-----------------------------------------------------------------------------++module Data.SBV.Examples.Basics.QRem where++import Data.SBV++-- check: if (a, b) = x `quotRem` y then x = y*a + b+-- 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, BVDivisible a) => a -> a -> SBool+qrem x y = ite (y .== 0) ((0, x) .== (a, b)) (x .== y * a + b)+  where (a, b) = x `bvQuotRem` y++check :: IO ()+check = do print =<< prove (qrem :: SWord8 -> SWord8 -> SBool)+           -- print =<< prove (qrem :: SWord16 -> SWord16 -> SBool)   -- takes too long!
+ Temp/sbv-0.9.18/Data/SBV/Examples/BitPrecise/BitTricks.hs view
@@ -0,0 +1,60 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.BitPrecise.BitTricks+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Checks the correctness of a few tricks from the large collection found in:+--      <http://graphics.stanford.edu/~seander/bithacks.html>+-----------------------------------------------------------------------------++module Data.SBV.Examples.BitPrecise.BitTricks where++import Data.SBV++-- | Formalizes <http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax>+fastMinCorrect :: SInt32 -> SInt32 -> SBool+fastMinCorrect x y = m .== fm+  where m  = ite (x .< y) x y+        fm = y `xor` ((x `xor` y) .&. (-(oneIf (x .< y))));++-- | Formalizes <http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax>+fastMaxCorrect :: SInt32 -> SInt32 -> SBool+fastMaxCorrect x y = m .== fm+  where m  = ite (x .< y) y x+        fm = x `xor` ((x `xor` y) .&. (-(oneIf (x .< y))));++-- | Formalizes <http://graphics.stanford.edu/~seander/bithacks.html#DetectOppositeSigns>+oppositeSignsCorrect :: SInt32 -> SInt32 -> SBool+oppositeSignsCorrect x y = r .== os+  where r  = (x .< 0 &&& y .>= 0) ||| (x .>= 0 &&& y .< 0)+        os = (x `xor` y) .< 0++-- | Formalizes <http://graphics.stanford.edu/~seander/bithacks.html#ConditionalSetOrClearBitsWithoutBranching>+conditionalSetClearCorrect :: SBool -> SWord32 -> SWord32 -> SBool+conditionalSetClearCorrect f m w = r .== r'+  where r  = ite f (w .|. m) (w .&. complement m)+        r' = w `xor` ((-(oneIf f) `xor` w) .&. m);++-- | Formalizes <http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2>+powerOfTwoCorrect :: SWord32 -> SBool+powerOfTwoCorrect v = f .== s+  where f = (v ./= 0) &&& ((v .&. (v-1)) .== 0);+        powers :: [Word32]+        powers = map ((2::Word32)^) [(0::Word32) .. 31]+        s = bAny (v .==) $ map literal powers++-- | Collection of queries+queries :: IO ()+queries =+  let check :: Provable a => String -> a -> IO ()+      check w t = do putStr $ "Proving " ++ show w ++ ": "+                     print =<< prove t+  in do check "Fast min             " fastMinCorrect+        check "Fast max             " fastMaxCorrect+        check "Opposite signs       " oppositeSignsCorrect+        check "Conditional set/clear" conditionalSetClearCorrect+        check "PowerOfTwo           " powerOfTwoCorrect
+ Temp/sbv-0.9.18/Data/SBV/Examples/BitPrecise/Legato.hs view
@@ -0,0 +1,303 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.BitPrecise.Legato+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- An encoding and correctness proof of Legato's multiplier in Haskell. Bill Legato came+-- up with an interesting way to multiply two 8-bit numbers on Mostek, as described here:+--   <http://www.cs.utexas.edu/~moore/acl2/workshop-2004/contrib/legato/Weakest-Preconditions-Report.pdf>+--+-- Here's Legato's algorithm, as coded in Mostek assembly:+--+-- @+--    step1 :       LDX #8         ; load X immediate with the integer 8 +--    step2 :       LDA #0         ; load A immediate with the integer 0 +--    step3 : LOOP  ROR F1         ; rotate F1 right circular through C +--    step4 :       BCC ZCOEF      ; branch to ZCOEF if C = 0 +--    step5 :       CLC            ; set C to 0 +--    step6 :       ADC F2         ; set A to A+F2+C and C to the carry +--    step7 : ZCOEF ROR A          ; rotate A right circular through C +--    step8 :       ROR LOW        ; rotate LOW right circular through C +--    step9 :       DEX            ; set X to X-1 +--    step10:       BNE LOOP       ; branch to LOOP if Z = 0 +-- @+--+-- This program came to be known as the Legato's challenge in the community, where+-- the challenge was to prove that it indeed does perform multiplication. This file+-- formalizes the Mostek architecture in Haskell and proves that Legato's algorithm+-- is indeed correct.+-----------------------------------------------------------------------------++module Data.SBV.Examples.BitPrecise.Legato where++import Data.Array (Array, Ix(..), (!), (//), array)++import Data.SBV++------------------------------------------------------------------+-- * Mostek architecture+------------------------------------------------------------------+-- | The memory is addressed by 32-bit words.+type Address  = SWord32++-- | We model only two registers of Mostek that is used in the above algorithm, can add more.+data Register = RegX  | RegA  deriving (Eq, Ord, Ix, Bounded, Enum)++-- | The carry flag ('FlagC') and the zero flag ('FlagZ')+data Flag = FlagC | FlagZ deriving (Eq, Ord, Ix, Bounded, Enum)++-- | Mostek was an 8-bit machine.+type Value = SWord8++-- | Convenient synonym for symbolic machine bits.+type Bit = SBool++-- | Register bank+type Registers = Array Register Value++-- | Flag bank+type Flags = Array Flag Bit++-- | The memory maps 32-bit words to 8-bit words. (The 'Model' data-type is+-- defined later, depending on the verification model used.)+type Memory = Model Word32 Word8        -- Model defined later++-- | Abstraction of the machine: The CPU consists of memory, registers, and flags.+-- Unlike traditional hardware, we assume the program is stored in some other memory area that+-- we need not model. (No self modifying programs!)+data Mostek = Mostek { memory    :: Memory+                     , registers :: Registers+                     , flags     :: Flags+                     }++-- | Given a machine state, compute a value out of it+type Extract a = Mostek -> a++-- | Programs are essentially state transformers (on the machine state)+type Program = Mostek -> Mostek++instance Mergeable Mostek where+  symbolicMerge b m1 m2 = Mostek { memory    = symbolicMerge b (memory m1)    (memory m2)+                                 , registers = symbolicMerge b (registers m1) (registers m2)+                                 , flags     = symbolicMerge b (flags m1)     (flags m2)+                                 }++------------------------------------------------------------------+-- * Low-level operations+------------------------------------------------------------------++-- | Get the value of a given register+getReg :: Register -> Extract Value+getReg r m = registers m ! r++-- | Set the value of a given register+setReg :: Register -> Value -> Program+setReg r v m = m {registers = registers m // [(r, v)]}++-- | Get the value of a flag+getFlag :: Flag -> Extract Bit+getFlag f m = flags m ! f++-- | Set the value of a flag+setFlag :: Flag -> Bit -> Program+setFlag f b m = m {flags = flags m // [(f, b)]}++-- | Read memory+peek :: Address -> Extract Value+peek a m = readArray (memory m) a++-- | Write to memory+poke :: Address -> Value -> Program+poke a v m = m {memory = writeArray (memory m) a v}++-- | Checking overflow. In Legato's multipler the @ADC@ instruction+-- needs to see if the expression x + y + c overflowed, as checked+-- by this function. Note that we verify the correctness of this check+-- separately below in `checkOverflowCorrect`.+checkOverflow :: SWord8 -> SWord8 -> SBool -> SBool+checkOverflow x y c = s .< x ||| s .< y ||| s' .< s+  where s  = x + y+        s' = s + (ite c 1 0)++-- | Correctness theorem for our `checkOverflow` implementation.+--+--   We have:+--+--   >>> checkOverflowCorrect+--   Q.E.D.+checkOverflowCorrect :: IO ThmResult+checkOverflowCorrect = checkOverflow === overflow+  where -- Reference spec for overflow. We do the addition+        -- using 16 bits and check that it's larger than 255+        overflow :: SWord8 -> SWord8 -> SBool -> SBool+        overflow x y c = (0 # x) + (0 # y) + ite c 1 0 .> 255+------------------------------------------------------------------+-- * Instruction set+------------------------------------------------------------------++-- | An instruction is modeled as a 'Program' transformer. We model+-- mostek programs in direct continuation passing style.+type Instruction = Program -> Program++-- | LDX: Set register @X@ to value @v@+ldx :: Value -> Instruction+ldx v k = k . setReg RegX v++-- | LDA: Set register @A@ to value @v@+lda :: Value -> Instruction+lda v k = k . setReg RegA v++-- | CLC: Clear the carry flag+clc :: Instruction+clc k = k . setFlag FlagC false++-- | ROR, memory version: Rotate the value at memory location @a@+-- to the right by 1 bit, using the carry flag as a transfer position.+-- That is, the final bit of the memory location becomes the new carry+-- and the carry moves over to the first bit. This very instruction+-- is one of the reasons why Legato's multiplier is quite hard to understand+-- and is typically presented as a verification challenge.+rorM :: Address -> Instruction+rorM a k m = k . setFlag FlagC c' . poke a v' $ m+  where v  = peek a m+        c  = getFlag FlagC m+        v' = setBitTo (v `rotateR` 1) 7 c+        c' = bitValue v 0++-- | ROR, register version: Same as 'rorM', except through register @r@.+rorR :: Register -> Instruction+rorR r k m = k . setFlag FlagC c' . setReg r v' $ m+  where v  = getReg r m+        c  = getFlag FlagC m+        v' = setBitTo (v `rotateR` 1) 7 c+        c' = bitValue v 0++-- | BCC: branch to label @l@ if the carry flag is false+bcc :: Program -> Instruction+bcc l k m = ite (c .== false) (l m) (k m)+  where c = getFlag FlagC m++-- | ADC: Increment the value of register @A@ by the value of memory contents+-- at address @a@, using the carry-bit as the carry-in for the addition.+adc :: Address -> Instruction+adc a k m = k . setFlag FlagZ (v' .== 0) . setFlag FlagC c' . setReg RegA v' $ m+  where v  = peek a m+        ra = getReg RegA m+        c  = getFlag FlagC m+        v' = v + ra + ite c 1 0+        c' = checkOverflow v ra c++-- | DEX: Decrement the value of register @X@+dex :: Instruction+dex k m = k . setFlag FlagZ (x .== 0) . setReg RegX x $ m+  where x = getReg RegX m - 1++-- | BNE: Branch if the zero-flag is false+bne :: Program -> Instruction+bne l k m = ite (z .== false) (l m) (k m)+  where z = getFlag FlagZ m++-- | The 'end' combinator "stops" our program, providing the final continuation+-- that does nothing.+end :: Program+end = id++------------------------------------------------------------------+-- * Legato's algorithm in Haskell/SBV+------------------------------------------------------------------++-- | Parameterized by the addresses of locations of the factors (@F1@ and @F2@),+-- the following program multiplies them, storing the low-byte of the result+-- in the memory location @lowAddr@, and the high-byte in register @A@. The+-- implementation is a direct transliteration of Legato's algorithm given+-- at the top, using our notation.+legato :: Address -> Address -> Address -> Program+legato f1Addr f2Addr lowAddr = start+  where start   =    ldx 8+                   $ lda 0+                   $ loop+        loop    =    rorM f1Addr+                   $ bcc zeroCoef+                   $ clc+                   $ adc f2Addr+                   $ zeroCoef+        zeroCoef =   rorR RegA+                   $ rorM lowAddr+                   $ dex+                   $ bne loop+                   $ end++------------------------------------------------------------------+-- * Verification interface+------------------------------------------------------------------+-- | Given address/value pairs for F1 and F2, and the location of where the low-byte+-- of the result should go, @runLegato@ takes an arbitrary machine state @m@ and+-- returns the high and low bytes of the multiplication.+runLegato :: (Address, Value) -> (Address, Value) -> Address -> Mostek -> (Value, Value)+runLegato (f1Addr, f1Val) (f2Addr, f2Val) loAddr m = (getReg RegA mFinal, peek loAddr mFinal)+  where m0     = poke f1Addr f1Val $ poke f2Addr f2Val m+        mFinal = legato f1Addr f2Addr loAddr m0++-- | 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+                )++-- | 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)]+                                              }++-- | 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+-- running Legato's algorithm does indeed compute the product of @x@ and @y@ correctly.+legatoIsCorrect :: Memory -> (Address, Value) -> (Address, Value) -> Address -> InitVals -> SBool+legatoIsCorrect mem (addrX, x) (addrY, y) addrLow initVals+        = allDifferent [addrX, addrY, addrLow]    -- note the conditional: addresses must be distinct!+                ==> result .== expected+    where (hi, lo) = runLegato (addrX, x) (addrY, y) addrLow (initMachine mem initVals)+          -- NB. perform the comparison over 16 bit values to avoid overflow!+          -- If Value changes to be something else, modify this accordingly.+          result, expected :: SWord16+          result   = 256 * (0 # hi) + (0 # lo)+          expected = (0 # x) * (0 # y)++------------------------------------------------------------------+-- * Verification+------------------------------------------------------------------++-- | Choose the appropriate array model to be used for modeling the memory. (See 'Memory'.)+-- The 'SFunArray' is the function based model. 'SArray' is the SMT-Lib array's based model.+type Model = SFunArray+-- 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.+correctnessTheorem :: IO ThmResult+correctnessTheorem = proveWith timingSMTCfg $+    forAll ["mem", "addrX", "x", "addrY", "y", "addrLow", "regX", "regA", "memVals", "flagC", "flagZ"]+           legatoIsCorrect++------------------------------------------------------------------+-- * C Code generation+------------------------------------------------------------------++-- | Generate a C program that implements Legato's algorithm automatically.+legatoInC :: IO ()+legatoInC = compileToC Nothing "runLegato" $ do+                x <- cgInput "x"+                y <- cgInput "y"+                let (hi, lo) = runLegato (0, x) (1, y) 2 (initMachine (mkSFunArray 0) (0, 0, 0, false, false))+                cgOutput "hi" hi+                cgOutput "lo" lo
+ Temp/sbv-0.9.18/Data/SBV/Examples/CRC/CCITT.hs view
@@ -0,0 +1,61 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.CRC.CCITT+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- CRC checks, hamming distance, etc.+-----------------------------------------------------------------------------++module Data.SBV.Examples.CRC.CCITT where++import Data.SBV++-- 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 msg++crc :: SWord48 -> SWord16+crc 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 3+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 -> (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))
+ Temp/sbv-0.9.18/Data/SBV/Examples/CRC/CCITT_Unidir.hs view
@@ -0,0 +1,59 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.CRC.CCITT_Unidir+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Similar to CCITT. It shows that the CCITT is still HD 3+-- even if we consider only uni-directional errors+-----------------------------------------------------------------------------++module Data.SBV.Examples.CRC.CCITT_Unidir where++import Data.SBV++-- 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 msg++crc :: SWord48 -> SWord16+crc 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)
+ Temp/sbv-0.9.18/Data/SBV/Examples/CRC/GenPoly.hs view
@@ -0,0 +1,74 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.CRC.GenPoly+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Finds good polynomials for CRC's+-----------------------------------------------------------------------------++module Data.SBV.Examples.CRC.GenPoly where++import Data.SBV++-- 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 msg poly++crc :: SWord48 -> SWord64 -> SWord16+crc 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 <- isTheoremWithin 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
+ Temp/sbv-0.9.18/Data/SBV/Examples/CRC/Parity.hs view
@@ -0,0 +1,36 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.CRC.Parity+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Parity check as CRC's+-----------------------------------------------------------------------------++module Data.SBV.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
+ Temp/sbv-0.9.18/Data/SBV/Examples/CRC/USB5.hs view
@@ -0,0 +1,50 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.CRC.USB5+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- The USB5 CRC implementation+-----------------------------------------------------------------------------++module Data.SBV.Examples.CRC.USB5 where++import Data.SBV++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 w++-- crc returns 16 bits, but the first 11 are always 0+crc :: SWord11 -> SWord16+crc 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
+ Temp/sbv-0.9.18/Data/SBV/Examples/CodeGeneration/AddSub.hs view
@@ -0,0 +1,127 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.CodeGeneration.AddSub+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Simple code generation example.+-----------------------------------------------------------------------------++module Data.SBV.Examples.CodeGeneration.AddSub where++import Data.SBV++-- | Simple function that returns add/sum of args+addSub :: SWord8 -> SWord8 -> (SWord8, SWord8)+addSub x y = (x+y, x-y)++-- | Generate C code for addSub. This will place the files in a directory called @genAddSub@,+-- generating the following files:+--+-- File: @Makefile@+--+-- > # Makefile for addSub. Automatically generated by SBV. Do not edit!+-- > +-- > 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+--+-- File: @addSub.h@+--+-- > /* Header file for addSub. Automatically generated by SBV. Do not edit! */+-- > +-- > #ifndef __addSub__HEADER_INCLUDED__+-- > #define __addSub__HEADER_INCLUDED__+-- > +-- > #include <inttypes.h>+-- > #include <stdint.h>+-- > +-- > /* Unsigned bit-vectors */+-- > typedef uint8_t  SBool  ;+-- > 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__ */+--+-- File: @addSub.c@+--+-- > /* File: "addSub.c". Automatically generated by SBV. Do not edit! */+-- > +-- > #include <inttypes.h>+-- > #include <stdint.h>+-- > #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;+-- > }+--+-- File: @addSub_driver.c@+--+-- > /* Example driver program for addSub. */+-- > /* Automatically generated by SBV. Edit as you see fit! */+-- > +-- > #include <inttypes.h>+-- > #include <stdint.h>+-- > #include <stdio.h>+-- > #include "addSub.h"+-- > +-- > int main(void)+-- > {+-- >   SWord8 sum;+-- >   SWord8 dif;+-- >   +-- >   addSub(132, 241, &sum, &dif);+-- >   +-- >   printf("addSub(132, 241, &sum, &dif) ->\n");+-- >   printf("  sum = %"PRIu8"\n", sum);+-- >   printf("  dif = %"PRIu8"\n", dif);+-- >   +-- >   return 0;+-- > }+--+genAddSub :: IO ()+genAddSub = compileToC (Just "xx") "addSub" $ do+        x <- cgInput "x"+        y <- cgInput "y"+        let (s, d) = addSub x y+        cgOutput "sum" s+        cgOutput "dif" d
+ Temp/sbv-0.9.18/Data/SBV/Examples/CodeGeneration/Fibonacci.hs view
@@ -0,0 +1,158 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.CodeGeneration.Fibonacci+-- Copyright   :  (c) Lee Pike, Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Computing Fibonacci numbers and generating C code. Inspired by Lee Pike's+-- original implementation, modified for inclusion in the package. It illustrates+-- symbolic termination issues one can have when working with recursive algorithms+-- and how to deal with such, eventually generating good C code.+-----------------------------------------------------------------------------++module Data.SBV.Examples.CodeGeneration.Fibonacci where++import Data.SBV++-----------------------------------------------------------------------------+-- * A naive implementation+-----------------------------------------------------------------------------++-- | This is a naive implementation of fibonacci, and will work fine (albeit slow)+-- for concrete inputs:+--+-- >>> map fib0 [0..6]+-- [0 :: SWord32,1 :: SWord32,1 :: SWord32,2 :: SWord32,3 :: SWord32,5 :: SWord32,8 :: SWord32]+--+-- However, it is not suitable for doing proofs or generating code, as it is not+-- symbolically terminating when it is called with a symbolic value @n@. When we+-- recursively call @fib0@ on @n-1@ (or @n-2@), the test against @0@ will always+-- explore both branches since the result will be symbolic, hence will not+-- terminate. (An integrated theorem prover can establish termination+-- after a certain number of unrollings, but this would be quite expensive to+-- implement, and would be impractical.)+fib0 :: SWord32 -> SWord32+fib0 n = ite (n .== 0 ||| n .== 1)+             n+             (fib0 (n-1) + fib0 (n-2))++-----------------------------------------------------------------------------+-- * Using a recursion depth, and accumulating parameters+-----------------------------------------------------------------------------++{- $genLookup+One way to deal with symbolic termination is to limit the number of recursive+calls. In this version, we impose a limit on the index to the function, working+correctly upto that limit. If we use a compile-time constant, then SBV's code generator+can produce code as the unrolling will eventually stop.+-}++-- | The recursion-depth limited version of fibonacci. Limiting the maximum number to be 20, we can say:+--+-- >>> map (fib1 20) [0..6]+-- [0 :: SWord32,1 :: SWord32,1 :: SWord32,2 :: SWord32,3 :: SWord32,5 :: SWord32,8 :: SWord32]+--+-- The function will work correctly, so long as the index we query is at most @top@, and otherwise+-- will return the value at @top@. Note that we also use accumulating parameters here for efficiency,+-- although this is orthogonal to the termination concern.+fib1 :: SWord32 -> SWord32 -> SWord32+fib1 top n = fib' 0 1 0+  where fib' :: SWord32 -> SWord32 -> SWord32 -> SWord32+        fib' prev' prev m = ite (m .== top ||| m .== n)          -- did we reach recursion depth, or the index we're looking for+                                prev'                            -- stop and return the result+                                (fib' prev (prev' + prev) (m+1)) -- otherwise recurse++-- | We can generate code for 'fib1' using the 'genFib1' action. Note that the+-- generated code will grow larger as we pick larger values of @top@, but only linearly,+-- thanks to the accumulating parameter trick used by 'fib1'. The following is an excerpt+-- from the code generated for the call @genFib1 10@, where the code will work correctly+-- for indexes up to 10:+--+-- > SWord32 fib1(const SWord32 x)+-- > {+-- >   const SWord32 s0 = x;+-- >   const SBool   s2 = s0 == 0x00000000UL;+-- >   const SBool   s4 = s0 == 0x00000001UL;+-- >   const SBool   s6 = s0 == 0x00000002UL;+-- >   const SBool   s8 = s0 == 0x00000003UL;+-- >   const SBool   s10 = s0 == 0x00000004UL;+-- >   const SBool   s12 = s0 == 0x00000005UL;+-- >   const SBool   s14 = s0 == 0x00000006UL;+-- >   const SBool   s17 = s0 == 0x00000007UL;+-- >   const SBool   s19 = s0 == 0x00000008UL;+-- >   const SBool   s22 = s0 == 0x00000009UL;+-- >   const SWord32 s25 = s22 ? 0x00000022UL : 0x00000037UL;+-- >   const SWord32 s26 = s19 ? 0x00000015UL : s25;+-- >   const SWord32 s27 = s17 ? 0x0000000dUL : s26;+-- >   const SWord32 s28 = s14 ? 0x00000008UL : s27;+-- >   const SWord32 s29 = s12 ? 0x00000005UL : s28;+-- >   const SWord32 s30 = s10 ? 0x00000003UL : s29;+-- >   const SWord32 s31 = s8 ? 0x00000002UL : s30;+-- >   const SWord32 s32 = s6 ? 0x00000001UL : s31;+-- >   const SWord32 s33 = s4 ? 0x00000001UL : s32;+-- >   const SWord32 s34 = s2 ? 0x00000000UL : s33;+-- >   +-- >   return s34;+-- > }+genFib1 :: SWord32 -> IO ()+genFib1 top = compileToC Nothing "fib1" $ do+        x <- cgInput "x"+        cgReturn $ fib1 top x++-----------------------------------------------------------------------------+-- * Generating a look-up table+-----------------------------------------------------------------------------++{- $genLookup+While 'fib1' generates good C code, we can do much better by taking+advantage of the inherent partial-evaluation capabilities of SBV to generate+a look-up table, as follows.+-}++-- | Compute the fibonacci numbers statically at /code-generation/ time and+-- put them in a table, accessed by the 'select' call. +fib2 :: SWord32 -> SWord32 -> SWord32+fib2 top n = select table 0 n+  where table = map (fib1 top) [0 .. top]++-- | Once we have 'fib2', we can generate the C code straightforwardly. Below+-- is an excerpt from the code that SBV generates for the call @genFib2 64@. Note+-- that this code is a constant-time look-up table implementation of fibonacci,+-- with no run-time overhead. The index can be made arbitrarily large,+-- naturally. (Note that this function returns @0@ if the index is larger+-- than 64, as specified by the call to 'select' with default @0@.)+--+-- > SWord32 fibLookup(const SWord32 x)+-- > {+-- >   const SWord32 s0 = x;+-- >   static const SWord32 table0[] = {+-- >       0x00000000UL, 0x00000001UL, 0x00000001UL, 0x00000002UL,+-- >       0x00000003UL, 0x00000005UL, 0x00000008UL, 0x0000000dUL,+-- >       0x00000015UL, 0x00000022UL, 0x00000037UL, 0x00000059UL,+-- >       0x00000090UL, 0x000000e9UL, 0x00000179UL, 0x00000262UL,+-- >       0x000003dbUL, 0x0000063dUL, 0x00000a18UL, 0x00001055UL,+-- >       0x00001a6dUL, 0x00002ac2UL, 0x0000452fUL, 0x00006ff1UL,+-- >       0x0000b520UL, 0x00012511UL, 0x0001da31UL, 0x0002ff42UL,+-- >       0x0004d973UL, 0x0007d8b5UL, 0x000cb228UL, 0x00148addUL,+-- >       0x00213d05UL, 0x0035c7e2UL, 0x005704e7UL, 0x008cccc9UL,+-- >       0x00e3d1b0UL, 0x01709e79UL, 0x02547029UL, 0x03c50ea2UL,+-- >       0x06197ecbUL, 0x09de8d6dUL, 0x0ff80c38UL, 0x19d699a5UL,+-- >       0x29cea5ddUL, 0x43a53f82UL, 0x6d73e55fUL, 0xb11924e1UL,+-- >       0x1e8d0a40UL, 0xcfa62f21UL, 0xee333961UL, 0xbdd96882UL,+-- >       0xac0ca1e3UL, 0x69e60a65UL, 0x15f2ac48UL, 0x7fd8b6adUL,+-- >       0x95cb62f5UL, 0x15a419a2UL, 0xab6f7c97UL, 0xc1139639UL,+-- >       0x6c8312d0UL, 0x2d96a909UL, 0x9a19bbd9UL, 0xc7b064e2UL,+-- >       0x61ca20bbUL+-- >   };+-- >   const SWord32 s65 = s0 >= 65 ? 0x00000000UL : table0[s0];+-- >   +-- >   return s65;+-- > }+genFib2 :: SWord32 -> IO ()+genFib2 top = compileToC Nothing "fibLookup" $ do+        cgPerformRTCs True       -- protect against potential overflow, our table is not big enough+        x <- cgInput "x"+        cgReturn $ fib2 top x
+ Temp/sbv-0.9.18/Data/SBV/Examples/CodeGeneration/GCD.hs view
@@ -0,0 +1,143 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.CodeGeneration.GCD+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Computing GCD symbolically, and generating C code for it. This example+-- illustrates symbolic termination related issues when programming with+-- SBV, when the termination of a recursive algorithm crucially depends+-- on the value of a symbolic variable. The technique we use is to statically+-- enforce termination by using a recursion depth counter.+-----------------------------------------------------------------------------++module Data.SBV.Examples.CodeGeneration.GCD where++import Data.SBV++-----------------------------------------------------------------------------+-- * Computing GCD+-----------------------------------------------------------------------------++-- | The symbolic GCD algorithm, over two 8-bit numbers. We define @sgcd a 0@ to+-- be @a@ for all @a@, which implies @sgcd 0 0 = 0@. Note that this is essentially+-- Euclid's algorithm, except with a recursion depth counter. We need the depth+-- counter since the algorithm is not /symbolically terminating/, as we don't have+-- a means of determining that the second argument (@b@) will eventually reach 0 in a symbolic+-- context. Hence we stop after 12 iterations. Why 12? We've empirically determined that this+-- algorithm will recurse at most 12 times for arbitrary 8-bit numbers. Of course, this is+-- a claim that we shall prove below.+sgcd :: SWord8 -> SWord8 -> SWord8+sgcd a b = go a b 12+  where go :: SWord8 -> SWord8 -> SWord8 -> SWord8+        go x y c = ite (c .== 0 ||| y .== 0)   -- stop if y is 0, or if we reach the recursion depth+                       x+                       (go y y' (c-1))+          where (_, y') = x `bvQuotRem` y++-----------------------------------------------------------------------------+-- * Verification+-----------------------------------------------------------------------------++{- $VerificationIntro+We prove that 'sgcd' does indeed compute the common divisor of the given numbers.+Our predicate takes @x@, @y@, and @k@. We show that what 'sgcd' returns is indeed a common divisor,+and it is at least as large as any given @k@, provided @k@ is a common divisor as well.+-}++-- | We have:+--+-- >>> prove sgcdIsCorrect+-- Q.E.D.+sgcdIsCorrect :: SWord8 -> SWord8 -> SWord8 -> SBool+sgcdIsCorrect x y k = ite (y  .== 0)                        -- if y is 0+                          (k' .== x)                        -- then k' must be x, nothing else to prove by definition+                          (isCommonDivisor k'  &&&          -- otherwise, k' is a common divisor and+                          (isCommonDivisor k ==> k' .>= k)) -- if k is a common divisor as well, then k' is at least as large as k+  where k' = sgcd x y+        isCommonDivisor a = z1 .== 0 &&& z2 .== 0+           where (_, z1) = x `bvQuotRem` a+                 (_, z2) = y `bvQuotRem` a++-----------------------------------------------------------------------------+-- * Code generation+-----------------------------------------------------------------------------++{- $VerificationIntro+Now that we have proof our 'sgcd' implementation is correct, we can go ahead+and generate C code for it.+-}++-- | This call will generate the required C files. The following is the function+-- body generated for 'sgcd'. (We are not showing the generated header, @Makefile@,+-- and the driver programs for brevity.) Note that the generated function is+-- a constant time algorithm for GCD. It is not necessarily fastest, but it will take+-- precisely the same amount of time for all values of @x@ and @y@.+--+-- > /* File: "sgcd.c". Automatically generated by SBV. Do not edit! */+-- > +-- > #include <inttypes.h>+-- > #include <stdint.h>+-- > #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;+-- > }+genGCDInC :: IO ()+genGCDInC = compileToC Nothing "sgcd" $ do+                x <- cgInput "x"+                y <- cgInput "y"+                cgReturn $ sgcd x y
+ Temp/sbv-0.9.18/Data/SBV/Examples/CodeGeneration/PopulationCount.hs view
@@ -0,0 +1,217 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.CodeGeneration.PopulationCount+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Computing population-counts (number of set bits) and autimatically+-- generating C code.+-----------------------------------------------------------------------------++module Data.SBV.Examples.CodeGeneration.PopulationCount where++import Data.SBV++-----------------------------------------------------------------------------+-- * Reference: Slow but /obviously/ correct+-----------------------------------------------------------------------------++-- | Given a 64-bit quantity, the simplest (and obvious) way to count the+-- number of bits that are set in it is to simply walk through all the bits+-- and add 1 to a running count. This is slow, as it requires 64 iterations,+-- but is simple and easy to convince yourself that it is correct. For instance:+--+-- >>> popCount_Slow 0x0123456789ABCDEF+-- 32 :: SWord8+popCount_Slow :: SWord64 -> SWord8+popCount_Slow inp = go inp 0 0+  where go :: SWord64 -> Int -> SWord8 -> SWord8+        go _ 64 c = c+        go x i  c = go (x `shiftR` 1) (i+1) (ite (x .&. 1 .== 1) (c+1) c)++-----------------------------------------------------------------------------+-- * Faster: Using a look-up table+-----------------------------------------------------------------------------++-- | Faster version. This is essentially the same algorithm, except we+-- go 8 bits at a time instead of one by one, by using a precomputed table+-- of population-count values for each byte. This algorithm /loops/ only+-- 8 times, and hence is at least 8 times more efficient.+popCount :: SWord64 -> SWord8+popCount inp = go inp 0 0+  where go :: SWord64 -> Int -> SWord8 -> SWord8+        go _ 8 c = c+        go x i c = go (x `shiftR` 8) (i+1) (c + select pop8 0 (x .&. 0xff))++-- | Look-up table, containing population counts for all possible 8-bit+-- value, from 0 to 255. Note that we do not \"hard-code\" the values, but+-- merely use the slow version to compute them.+pop8 :: [SWord8]+pop8 = map popCount_Slow [0 .. 255]++-----------------------------------------------------------------------------+-- * Verification+-----------------------------------------------------------------------------++{- $VerificationIntro+We prove that `popCount` and `popCount_Slow` are functionally equivalent.+This is essential as we will automatically generate C code from `popCount`,+and we would like to make sure that the fast version is correct with+respect to the slower reference version.+-}++-- | States the correctness of faster population-count algorithm, with respect+-- to the reference slow version. We have:+--+-- >>> prove fastPopCountIsCorrect+-- Q.E.D.+fastPopCountIsCorrect :: SWord64 -> SBool+fastPopCountIsCorrect x = popCount x .== popCount_Slow x++-----------------------------------------------------------------------------+-- * Code generation+-----------------------------------------------------------------------------++-- | Not only we can prove that faster version is correct, but we can also automatically+-- generate C code to compute population-counts for us. This action will generate all the+-- C files that you will need, including a driver program for test purposes.+--+-- Below is the generated header file for `popCount`:+--+-- > /* Header file for popCount. Automatically generated by SBV. Do not edit! */+-- > +-- > #ifndef __popCount__HEADER_INCLUDED__+-- > #define __popCount__HEADER_INCLUDED__+-- > +-- > #include <inttypes.h>+-- > #include <stdint.h>+-- > +-- > /* Unsigned bit-vectors */+-- > typedef uint8_t  SBool  ;+-- > 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__ */+--+-- The generated C function. Note how the Haskell list `pop8` is turned into a look-up+-- table automatically (see @table0@ below) in the C code.+--+-- > /* File: "popCount.c". Automatically generated by SBV. Do not edit! */+-- > +-- > #include <inttypes.h>+-- > #include <stdint.h>+-- > #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;+-- > }+--+-- SBV will also generate a driver program for test purposes. The driver will call+-- the generated function with random values. (It is also possible to instruct SBV+-- to use prescribed values, see the function `compileToC''.)+--+-- > /* Example driver program for popCount. */+-- > /* Automatically generated by SBV. Edit as you see fit! */+-- > +-- > #include <inttypes.h>+-- > #include <stdint.h>+-- > #include <stdio.h>+-- > #include "popCount.h"+-- > +-- > int main(void)+-- > {+-- >   const SWord8 __result = popCount(0x000000007016b176ULL);+-- >   +-- >   printf("popCount(0x000000007016b176ULL) = %"PRIu8"\n", __result);+-- >   +-- >   return 0;+-- > }+--+-- And a @Makefile@ to simplify compilation:+--+-- > # Makefile for popCount. Automatically generated by SBV. Do not edit!+-- > +-- > 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+genPopCountInC :: IO ()+genPopCountInC = compileToC Nothing "popCount" $ do+        x <- cgInput "x"+        cgReturn $ popCount x
+ Temp/sbv-0.9.18/Data/SBV/Examples/Crypto/AES.hs view
@@ -0,0 +1,579 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Crypto.AES+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- 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>.+--+-- 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+-- optimize our Haskell code. The concern here is not with getting Haskell running+-- fast at all. The idea is to program the T-Box implementation as naturally and clearly+-- as possible in Haskell, and have SBV's code-generator generate fast C code automatically.+-- Therefore, we merely use ordinary Haskell lists as our data-structures, and do not+-- bother with any unboxing or strictness annotations. Thus, we achieve the separation+-- of concerns: Correctness via clairty and simplicity and proofs on the Haskell side,+-- performance by relying on SBV's code generator. If necessary, the generated code+-- can be FFI'd back into Haskell to complete the loop.+--+-- All 3 valid key sizes (128, 192, and 256) as required by the FIPS-197 standard+-- are supported.+-----------------------------------------------------------------------------++{-# LANGUAGE ParallelListComp #-}++module Data.SBV.Examples.Crypto.AES where++import Data.SBV+import Data.List (transpose)++-----------------------------------------------------------------------------+-- * Formalizing GF(2^8)+-----------------------------------------------------------------------------++-- | An element of the Galois Field 2^8, which are essentially polynomials with+-- maximum degree 7. They are conveniently represented as values between 0 and 255.+type GF28 = SWord8++-- | Multiplication in GF(2^8). This is simple polynomial multipliation, followed+-- by the irreducible polynomial @x^8+x^5+x^3+x^1+1@. We simply use the 'pMult'+-- function exported by SBV to do the operation. +gf28Mult :: GF28 -> GF28 -> GF28+gf28Mult x y = pMult (x, y, [8, 4, 3, 1, 0])++-- | Exponentiation by a constant in GF(2^8). The implementation uses the usual+-- square-and-multiply trick to speed up the computation.+gf28Pow :: GF28 -> Int -> GF28+gf28Pow n k = pow k+  where sq x  = x `gf28Mult` x+        pow 0    = 1+        pow i+         | odd i = n `gf28Mult` sq (pow (i `shiftR` 1))+         | True  = sq (pow (i `shiftR` 1))++-- | Computing inverses in GF(2^8). By the mathematical properties of GF(2^8)+-- and the particular irreducible polynomial used @x^8+x^5+x^3+x^1+1@, it+-- turns out that raising to the 254 power gives us the multiplicative inverse.+-- Of course, we can prove this using SBV:+--+-- >>> prove $ \x -> x ./= 0 ==> x `gf28Mult` gf28Inverse x .== 1+-- Q.E.D.+--+-- Note that we exclude @0@ in our theorem, as it does not have a+-- multiplicative inverse.+gf28Inverse :: GF28 -> GF28+gf28Inverse x = x `gf28Pow` 254++-----------------------------------------------------------------------------+-- * Implementing AES+-----------------------------------------------------------------------------++-----------------------------------------------------------------------------+-- ** Types and basic operations+-----------------------------------------------------------------------------+-- | AES state. The state consists of four 32-bit words, each of which is in turn treated+-- as four GF28's, i.e., 4 bytes. The T-Box implementation keeps the four-bytes together+-- for efficient representation.+type State = [SWord32]++-- | The key, which can be 128, 192, or 256 bits. Represented as a sequence of 32-bit words.+type Key = [SWord32]++-- | The key schedule. AES executes in rounds, and it treats first and last round keys slightly+-- differently than the middle ones. We reflect that choice by being explicit about it in our type.+-- The length of the middle list of keys depends on the key-size, which in turn determines+-- the number of rounds.+type KS = (Key, [Key], Key)++-- | Conversion from 32-bit words to 4 constituent bytes.+toBytes :: SWord32 -> [GF28]+toBytes x = [x1, x2, x3, x4]+        where (h,  l)  = split x+              (x1, x2) = split h+              (x3, x4) = split l++-- | Conversion from 4 bytes, back to a 32-bit row, inverse of 'toBytes' above. We+-- have the following simple theorems stating this relationship formally:+--+-- >>> prove $ \a b c d -> toBytes (fromBytes [a, b, c, d]) .== [a, b, c, d]+-- Q.E.D.+--+-- >>> prove $ \r -> fromBytes (toBytes r) .== r+-- Q.E.D.+fromBytes :: [GF28] -> SWord32+fromBytes [x1, x2, x3, x4] = (x1 # x2) # (x3 # x4)+fromBytes xs               = error $ "fromBytes: Unexpected input: " ++ show xs++-- | Rotating a state row by a fixed amount to the right.+rotR :: [GF28] -> Int -> [GF28]+rotR [a, b, c, d] 1 = [d, a, b, c]+rotR [a, b, c, d] 2 = [c, d, a, b]+rotR [a, b, c, d] 3 = [b, c, d, a]+rotR xs           i = error $ "rotR: Unexpected input: " ++ show (xs, i)++-----------------------------------------------------------------------------+-- ** The key schedule+-----------------------------------------------------------------------------++-- | Definition of round-constants, as specified in Section 5.2 of the AES standard.+roundConstants :: [GF28]+roundConstants = 0 : [ gf28Pow 2 (k-1) | k <- [1 .. ] ]++-- | The @InvMixColumns@ transformation, as described in Section 5.3.3 of the standard. Note+-- that this transformation is only used explicitly during key-expansion in the T-Box implementation+-- of AES.+invMixColumns :: State -> State+invMixColumns state = map fromBytes $ transpose $ mmult (map toBytes state)+ where dot f   = foldr1 xor . zipWith ($) f+       mmult n = [map (dot r) n | r <- [ [mE, mB, mD, m9]+                                       , [m9, mE, mB, mD]+                                       , [mD, m9, mE, mB]+                                       , [mB, mD, m9, mE]+                                       ]]+       -- table-lookup versions of gf28Mult with the constants used in invMixColumns+       mE = select mETable 0+       mB = select mBTable 0+       mD = select mDTable 0+       m9 = select m9Table 0+       mETable = map (gf28Mult 0xE) [0..255]+       mBTable = map (gf28Mult 0xB) [0..255]+       mDTable = map (gf28Mult 0xD) [0..255]+       m9Table = map (gf28Mult 0x9) [0..255]++-- | Key expansion. Starting with the given key, returns an infinite sequence of+-- words, as described by the AES standard, Section 5.2, Figure 11.+keyExpansion :: Int -> Key -> [Key]+keyExpansion nk key = chop4 keys+   where keys :: [SWord32]+         keys = key ++ [nextWord i prev old | i <- [nk ..] | prev <- drop (nk-1) keys | old <- keys]+         chop4 :: [a] -> [[a]]+         chop4 xs = let (f, r) = splitAt 4 xs in f : chop4 r+         nextWord :: Int -> SWord32 -> SWord32 -> SWord32+         nextWord i prev old+           | i `mod` nk == 0           = old `xor` (subWordRcon (prev `rotateL` 8) (roundConstants !! (i `div` nk)))+           | i `mod` nk == 4 && nk > 6 = old `xor` (subWordRcon prev 0)+           | True                      = old `xor` prev+         subWordRcon :: SWord32 -> GF28 -> SWord32+         subWordRcon w rc = fromBytes [a `xor` rc, b, c, d]+            where [a, b, c, d] = map sbox $ toBytes w++-----------------------------------------------------------------------------+-- ** The S-box transformation+-----------------------------------------------------------------------------++-- | The values of the AES S-box table. Note that we describe the S-box programmatically+-- using the mathematical construction given in Section 5.1.1 of the standard. However,+-- the code-generation will turn this into a mere look-up table, as it is just a+-- constant table, all computation being done at \"compile-time\".+sboxTable :: [GF28]+sboxTable = [xformByte (gf28Inverse b) | b <- [0 .. 255]]+  where xformByte :: GF28 -> GF28+        xformByte b = foldr xor 0x63 [b `rotateR` i | i <- [0, 4, 5, 6, 7]]++-- | The sbox transformation. We simply select from the sbox table. Note that we+-- are obliged to give a default value (here @0@) to be used if the index is out-of-bounds+-- as required by SBV's 'select' function. However, that will never happen since+-- the table has all 256 elements in it.+sbox :: GF28 -> GF28+sbox = select sboxTable 0++-----------------------------------------------------------------------------+-- ** The inverse S-box transformation+-----------------------------------------------------------------------------++-- | The values of the inverse S-box table. Again, the construction is programmatic.+unSBoxTable :: [GF28]+unSBoxTable = [gf28Inverse (xformByte b) | b <- [0 .. 255]]+  where xformByte :: GF28 -> GF28+        xformByte b = foldr xor 0x05 [b `rotateR` i | i <- [2, 5, 7]]++-- | The inverse s-box transformation.+unSBox :: GF28 -> GF28+unSBox = select unSBoxTable 0++-- | Prove that the 'sbox' and 'unSBox' are inverses. We have:+--+-- >>> prove sboxInverseCorrect+-- Q.E.D.+--+sboxInverseCorrect :: GF28 -> SBool+sboxInverseCorrect x = unSBox (sbox x) .== x &&& sbox (unSBox x) .== x++-----------------------------------------------------------------------------+-- ** AddRoundKey transformation+-----------------------------------------------------------------------------++-- | Adding the round-key to the current state. We simply exploit the fact+-- that addition is just xor in implementing this transformation.+addRoundKey :: Key -> State -> State+addRoundKey = zipWith xor++-----------------------------------------------------------------------------+-- ** Tables for T-Box encryption+-----------------------------------------------------------------------------++-- | T-box table generation function.for encryption+t0Func :: GF28 -> [GF28]+t0Func a = [s `gf28Mult` 2, s, s, s `gf28Mult` 3] where s = sbox a++-- | First look-up table used in encryption+t0 :: GF28 -> SWord32+t0 = select t0Table 0 where t0Table = [fromBytes (t0Func a)          | a <- [0..255]]++-- | Second look-up table used in encryption+t1 :: GF28 -> SWord32+t1 = select t1Table 0 where t1Table = [fromBytes (t0Func a `rotR` 1) | a <- [0..255]]++-- | Third look-up table used in encryption+t2 :: GF28 -> SWord32+t2 = select t2Table 0 where t2Table = [fromBytes (t0Func a `rotR` 2) | a <- [0..255]]++-- | Fourth look-up table used in encryption+t3 :: GF28 -> SWord32+t3 = select t3Table 0 where t3Table = [fromBytes (t0Func a `rotR` 3) | a <- [0..255]]++-----------------------------------------------------------------------------+-- ** Tables for T-Box decryption+-----------------------------------------------------------------------------++-- | T-box table generating function for decryption+u0Func :: GF28 -> [GF28]+u0Func a = [s `gf28Mult` 0xE, s `gf28Mult` 0x9, s `gf28Mult` 0xD, s `gf28Mult` 0xB] where s = unSBox a++-- | First look-up table used in decryption+u0 :: GF28 -> SWord32+u0 = select t0Table 0 where t0Table = [fromBytes (u0Func a)          | a <- [0..255]]++-- | Second look-up table used in decryption+u1 :: GF28 -> SWord32+u1 = select t1Table 0 where t1Table = [fromBytes (u0Func a `rotR` 1) | a <- [0..255]]++-- | Third look-up table used in decryption+u2 :: GF28 -> SWord32+u2 = select t2Table 0 where t2Table = [fromBytes (u0Func a `rotR` 2) | a <- [0..255]]++-- | Fourth look-up table used in decryption+u3 :: GF28 -> SWord32+u3 = select t3Table 0 where t3Table = [fromBytes (u0Func a `rotR` 3) | a <- [0..255]]++-----------------------------------------------------------------------------+-- ** AES rounds+-----------------------------------------------------------------------------++-- | Generic round function. Given the function to perform one round, a key-schedule,+-- and a starting state, it performs the AES rounds.+doRounds :: (Bool -> State -> Key -> State) -> KS -> State -> State+doRounds rnd (ikey, rkeys, fkey) sIn = rnd True (last rs) fkey+  where s0 = ikey `addRoundKey` sIn+        rs = s0 : [rnd False s k | s <- rs | k <- rkeys ]++-- | One encryption round. The first argument indicates whether this is the final round+-- or not, in which case the construction is slightly different.+aesRound :: Bool -> State -> Key -> State+aesRound isFinal s key = d `addRoundKey` key+  where d = map (f isFinal) [0..3]+        a = map toBytes s+        f True j = fromBytes $ [ sbox (a !! ((j+0) `mod` 4) !! 0)+                               , sbox (a !! ((j+1) `mod` 4) !! 1)+                               , sbox (a !! ((j+2) `mod` 4) !! 2)+                               , sbox (a !! ((j+3) `mod` 4) !! 3)+                               ]+        f False j = e0 `xor` e1 `xor` e2 `xor` e3+              where e0 = t0 (a !! ((j+0) `mod` 4) !! 0)+                    e1 = t1 (a !! ((j+1) `mod` 4) !! 1)+                    e2 = t2 (a !! ((j+2) `mod` 4) !! 2)+                    e3 = t3 (a !! ((j+3) `mod` 4) !! 3)++-- | One decryption round. Similar to the encryption round, the first argument+-- indicates whether this is the final round or not.+aesInvRound :: Bool -> State -> Key -> State+aesInvRound isFinal s key = d `addRoundKey` key+  where d = map (f isFinal) [0..3]+        a = map toBytes s+        f True j = fromBytes [ unSBox (a !! ((j+0) `mod` 4) !! 0)+                             , unSBox (a !! ((j+3) `mod` 4) !! 1)+                             , unSBox (a !! ((j+2) `mod` 4) !! 2)+                             , unSBox (a !! ((j+1) `mod` 4) !! 3)+                             ]+        f False j = e0 `xor` e1 `xor` e2 `xor` e3+              where e0 = u0 (a !! ((j+0) `mod` 4) !! 0)+                    e1 = u1 (a !! ((j+3) `mod` 4) !! 1)+                    e2 = u2 (a !! ((j+2) `mod` 4) !! 2)+                    e3 = u3 (a !! ((j+1) `mod` 4) !! 3)++-----------------------------------------------------------------------------+-- * AES API+-----------------------------------------------------------------------------++-- | Key schedule. Given a 128, 192, or 256 bit key, expand it to get key-schedules+-- for encryption and decryption. The key is given as a sequence of 32-bit words.+-- (4 elements for 128-bits, 6 for 192, and 8 for 256.)+aesKeySchedule :: Key -> (KS, KS)+aesKeySchedule key+  | nk `elem` [4, 6, 8]+  = (encKS, decKS)+  | True+  = error "aesKeySchedule: Invalid key size"+  where nk = length key+        nr = nk + 6+        encKS@(f, m, l) = (head rKeys, take (nr-1) (tail rKeys), rKeys !! nr)+        decKS = (l, map invMixColumns (reverse m), f)+        rKeys = keyExpansion nk key++-- | Block encryption. The first argument is the plain-text, which must have+-- precisely 4 elements, for a total of 128-bits of input. The second+-- argument is the key-schedule to be used, obtained by a call to 'aesKeySchedule'.+-- The output will always have 4 32-bit words, which is the cipher-text.+aesEncrypt :: [SWord32] -> KS -> [SWord32]+aesEncrypt pt encKS+  | length pt == 4+  = doRounds aesRound encKS pt+  | True+  = error "aesEncrypt: Invalid plain-text size"++-- | Block decryption. The arguments are the same as in 'aesEncrypt', except+-- the first argument is the cipher-text and the output is the corresponding+-- plain-text.+aesDecrypt :: [SWord32] -> KS -> [SWord32]+aesDecrypt ct decKS+  | length ct == 4+  = doRounds aesInvRound decKS ct+  | True+  = error "aesDecrypt: Invalid cipher-text size"++-----------------------------------------------------------------------------+-- * Test vectors+-----------------------------------------------------------------------------++-----------------------------------------------------------------------------+-- ** 128-bit enc/dec test+-----------------------------------------------------------------------------++-- | 128-bit encryption test, from Appendix C.1 of the AES standard:+--+-- >>> map hex t128Enc+-- ["69c4e0d8","6a7b0430","d8cdb780","70b4c55a"]+--+t128Enc :: [SWord32]+t128Enc = aesEncrypt pt ks+  where pt  = [0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff]+        key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f]+        (ks, _) = aesKeySchedule key++-- | 128-bit decryption test, from Appendix C.1 of the AES standard:+--+-- >>> map hex t128Dec+-- ["00112233","44556677","8899aabb","ccddeeff"]+--+t128Dec :: [SWord32]+t128Dec = aesDecrypt ct ks+  where ct  = [0x69c4e0d8, 0x6a7b0430, 0xd8cdb780, 0x70b4c55a]+        key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f]+        (_, ks) = aesKeySchedule key++-----------------------------------------------------------------------------+-- ** 192-bit enc/dec test+-----------------------------------------------------------------------------++-- | 192-bit encryption test, from Appendix C.2 of the AES standard:+--+-- >>> map hex t192Enc+-- ["dda97ca4","864cdfe0","6eaf70a0","ec0d7191"]+--+t192Enc :: [SWord32]+t192Enc = aesEncrypt pt ks+  where pt  = [0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff]+        key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x10111213, 0x14151617]+        (ks, _) = aesKeySchedule key++-- | 192-bit decryption test, from Appendix C.2 of the AES standard:+--+-- >>> map hex t192Dec+-- ["00112233","44556677","8899aabb","ccddeeff"]+--+t192Dec :: [SWord32]+t192Dec = aesDecrypt ct ks+  where ct  = [0xdda97ca4, 0x864cdfe0, 0x6eaf70a0, 0xec0d7191]+        key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x10111213, 0x14151617]+        (_, ks) = aesKeySchedule key++-----------------------------------------------------------------------------+-- ** 256-bit enc/dec test+-----------------------------------------------------------------------------++-- | 256-bit encryption, from Appendix C.3 of the AES standard:+--+-- >>> map hex t256Enc+-- ["8ea2b7ca","516745bf","eafc4990","4b496089"]+--+t256Enc :: [SWord32]+t256Enc = aesEncrypt pt ks+  where pt  = [0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff]+        key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f]+        (ks, _) = aesKeySchedule key++-- | 256-bit decryption, from Appendix C.3 of the AES standard:+--+-- >>> map hex t256Dec+-- ["00112233","44556677","8899aabb","ccddeeff"]+--+t256Dec :: [SWord32]+t256Dec = aesDecrypt ct ks+  where ct  = [0x8ea2b7ca, 0x516745bf, 0xeafc4990, 0x4b496089]+        key = [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f, 0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f]+        (_, ks) = aesKeySchedule key+++-----------------------------------------------------------------------------+-- * Verification+-- ${verifIntro}+-----------------------------------------------------------------------------+{- $verifIntro+  While SMT based technologies can prove correct many small properties fairly quickly, it would+  be naive for them to automatically verify that our AES implementation is correct. (By correct,+  we mean decryption follewed by encryption yielding the same result.) However, we can state+  this property precisely using SBV, and use quick-check to gain some confidence.+-}++-- | Correctness theorem for 128-bit AES. Ideally, we would run:+--+-- @+--   prove aes128IsCorrect+-- @+--+-- to get a proof automatically. Unfortunately, while SBV will successfully generate the proof+-- obligation for this theorem and ship it to the SMT solver, it would be naive to expect the SMT-solver+-- to finish that proof in any reasonable time with the currently available SMT solving technologies.+-- Instead, we can issue:+--+-- @+--   quickCheck aes128IsCorrect+-- @+-- +-- and get some degree of confidence in our code. Similar predicates can be easily constructed for 192, and+-- 256 bit cases as well.+aes128IsCorrect :: (SWord32, SWord32, SWord32, SWord32)  -- ^ plain-text words+                -> (SWord32, SWord32, SWord32, SWord32)  -- ^ key-words+                -> SBool                                 -- ^ True if round-trip gives us plain-text back+aes128IsCorrect (i0, i1, i2, i3) (k0, k1, k2, k3) = pt .== pt'+   where pt  = [i0, i1, i2, i3]+         key = [k0, k1, k2, k3]+         (encKS, decKS) = aesKeySchedule key+         ct  = aesEncrypt pt encKS+         pt' = aesDecrypt ct decKS++-----------------------------------------------------------------------------+-- * Code generation+-- ${codeGenIntro}+-----------------------------------------------------------------------------+{- $codeGenIntro+   We have emphasized that our T-Box implementation in Haskell was guided by clarity and correctness, not+   performance. Indeed, our implementation is hardly the fastest AES implementation in Haskell. However,+   we can use it to automatically generate straight-line C-code that can run fairly fast.++   For the purposes of illustration, we only show here how to generate code for a 128-bit AES block-encrypt+   function, that takes 8 32-bit words as an argument. The first 4 are the 128-bit input, and the final+   four are the 128-bit key. The impact of this is that the generated function would expand the key for+   each block of encryption, a needless task unless we change the key in every block. In a more serios application,+   we would instead generate code for both the 'aesKeySchedule' and the 'aesEncrypt' functions, thus reusing the+   key-schedule over many applications of the encryption call. (Unfortunately doing this is rather cumbersome right+   now, since Haskell does not support fixed-size lists.)+-}++-- | Code generation for 128-bit AES encryption.+--+-- The following sample from the generated code-lines show how T-Boxes are rendered as C arrays:+--+-- @+--   static const SWord32 table1[] = {+--       0xc66363a5UL, 0xf87c7c84UL, 0xee777799UL, 0xf67b7b8dUL,+--       0xfff2f20dUL, 0xd66b6bbdUL, 0xde6f6fb1UL, 0x91c5c554UL,+--       0x60303050UL, 0x02010103UL, 0xce6767a9UL, 0x562b2b7dUL,+--       0xe7fefe19UL, 0xb5d7d762UL, 0x4dababe6UL, 0xec76769aUL,+--       ...+--       }+-- @+--+-- The generated program has 5 tables (one sbox table, and 4-Tboxes), all converted to fast C arrays. Here+-- is a sample of the generated straightline C-code:+--+-- @+--   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;+-- @+--+-- The GNU C-compiler does a fine job of optimizing this straightline code to generate a fairly efficient C implementation.+cgAES128BlockEncrypt :: IO ()+cgAES128BlockEncrypt = compileToC Nothing "aes128BlockEncrypt" $ do+        pt  <- cgInputArr 4 "pt"        -- plain-text as an array of 4 Word32's+        key <- cgInputArr 4 "key"       -- key as an array of 4 Word32s+        -- Use the test values from Appendix C.1 of the AES standard as the driver values+        cgSetDriverValues $    [0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff]+                            ++ [0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f]+        let (encKs, _) = aesKeySchedule key+        cgOutputArr "ct" $ aesEncrypt pt encKs++-----------------------------------------------------------------------------+-- * C-library generation+-- ${libraryIntro}+-----------------------------------------------------------------------------+{- $libraryIntro+   The 'cgAES128BlockEncrypt' example shows how to generate code for 128-bit AES encryption. As the generated+   function performs encryption on a given block, it performs key expansion as necessary. However, this is+   not quite practical: We would like to expand the key only once, and encrypt the stream of plain-text blocks using+   the same expanded key (potentially using some crypto-mode), until we decide to change the key. In this+   section, we show how to use SBV to instead generate a library of functions that can be used in such a scenario.+   The generated library is a typical @.a@ archive, that can be linked using the C-compiler as usual.+-}++-- | Components of the AES-128 implementation that the library is generated from+aes128LibComponents :: [(String, SBVCodeGen ())]+aes128LibComponents = [ ("aes128KeySchedule",  keySchedule)+                      , ("aes128BlockEncrypt", enc128)+                      , ("aes128BlockDecrypt", dec128)+                      ]+  where -- key-schedule+        keySchedule = do key <- cgInputArr 4 "key"     -- key+                         let (encKS, decKS) = aesKeySchedule key+                         cgOutputArr "encKS" (ksToXKey encKS)+                         cgOutputArr "decKS" (ksToXKey decKS)+        -- encryption+        enc128 = do pt   <- cgInputArr 4  "pt"    -- plain-text+                    xkey <- cgInputArr 44 "xkey"  -- expanded key, for 128-bit AES, the key-expansion has 44 Word32's+                    cgOutputArr "ct" $ aesEncrypt pt (xkeyToKS xkey)+        -- decryption+        dec128 = do pt   <- cgInputArr 4  "ct"    -- cipher-text+                    xkey <- cgInputArr 44 "xkey"  -- expanded key, for 128-bit AES, the key-expansion has 44 Word32's+                    cgOutputArr "pt" $ aesDecrypt pt (xkeyToKS xkey)+        -- Transforming back and forth from our KS type to a flat array used by the generated C code+        -- Turn a series of expanded keys to our internal KS type+        xkeyToKS :: [SWord32] -> KS+        xkeyToKS xs = (f, m, l)+           where f = take 4 xs                       -- first round key+                 m = chop4 (take 36 (drop 4 xs))     -- middle rounds+                 l = drop 40 xs                      -- last round key+        -- Turn a KS to a series of expanded key words+        ksToXKey :: KS -> [SWord32]+        ksToXKey (f, m, l) = f ++ concat m ++ l+        -- chunk in fours. (This function must be in some standard library, where?)+        chop4 :: [a] -> [[a]]+        chop4 [] = []+        chop4 xs = let (f, r) = splitAt 4 xs in f : chop4 r++-- | Generate a C library, containing functions for performing 128-bit enc/dec/key-expansion.+-- A note on performance: In a very rough speed test, the generated code was able to do+-- 6.3 million block encryptions per second on a decent MacBook Pro. On the same machine, OpenSSL+-- reports 8.2 million block encryptions per second. So, the generated code is about 25% slower+-- as compared to the highly optimized OpenSSL implementation. (Note that the speed test was done+-- somewhat simplistically, so these numbers should be considered very rough estimates.)+cgAES128Library :: IO ()+cgAES128Library = compileToCLib Nothing "aes128Lib" aes128LibComponents
+ Temp/sbv-0.9.18/Data/SBV/Examples/Polynomials/Polynomials.hs view
@@ -0,0 +1,78 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Polynomials.Polynomials+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Simple usage of polynomials over GF(2^n), using Rijndael's+-- finite field: <http://en.wikipedia.org/wiki/Finite_field_arithmetic#Rijndael.27s_finite_field>+--+-- The functions available are:+--+--  [/pMult/] GF(2^n) Multiplication+--+--  [/pDiv/] GF(2^n) Division+--+--  [/pMod/] GF(2^n) Modulus+--+--  [/pDivMod/] GF(2^n) Division/Modulus, packed together+--+-- Note that addition in GF(2^n) is simply `xor`, so no custom function is provided.+-----------------------------------------------------------------------------++module Data.SBV.Examples.Polynomials.Polynomials where++import Data.SBV++-- | Helper synonym for representing GF(2^8); which are merely 8-bit unsigned words. Largest+-- term in such a polynomial has degree 7.+type GF28 = SWord8++-- | Multiplication in Rijndael's field; usual polynomial multiplication followed by reduction+-- by the irreducible polynomial.  The irreducible used by Rijndael's field is the polynomial+-- @x^8 + x^4 + x^3 + x + 1@, which we write by giving it's /exponents/ in SBV.+-- See: <http://en.wikipedia.org/wiki/Finite_field_arithmetic#Rijndael.27s_finite_field>.+-- Note that the irreducible itself is not in GF28! It has a degree of 8.+--+-- NB. You can use the 'showPoly' function to print polynomials nicely, as a mathematician would write.+(<*>) :: GF28 -> GF28 -> GF28+a <*> b = pMult (a, b, [8, 4, 3, 1, 0])++-- | States that the unit polynomial @1@, is the unit element+multUnit :: GF28 -> SBool+multUnit x = (x <*> unit) .== x+  where unit = polynomial [0]   -- x@0++-- | States that multiplication is commutative+multComm :: GF28 -> GF28 -> SBool+multComm x y = (x <*> y) .== (y <*> x)++-- | States that multiplication is associative, note that associativity+-- proofs are notoriously hard for SAT/SMT solvers+multAssoc :: GF28 -> GF28 -> GF28 -> SBool+multAssoc x y z = ((x <*> y) <*> z) .== (x <*> (y <*> z))++-- | States that the usual multiplication rule holds over GF(2^n) polynomials+-- Checks:+--+-- @+--    if (a, b) = x `pDivMod` y then x = y `pMult` a + b+-- @+--+-- being careful about @y = 0@. When divisor is 0, then quotient is+-- defined to be 0 and the remainder is the numerator.+-- (Note that addition is simply `xor` in GF(2^8).)+polyDivMod :: GF28 -> GF28 -> SBool+polyDivMod x y = ite (y .== 0) ((0, x) .== (a, b)) (x .== y <*> a `xor` b)+  where (a, b) = x `pDivMod` y++-- | Queries+testGF28 :: IO ()+testGF28 = do+  print =<< prove multUnit+  print =<< prove multComm+  -- print =<< prove multAssoc -- takes too long; see above note..+  print =<< prove polyDivMod
+ Temp/sbv-0.9.18/Data/SBV/Examples/PrefixSum/PrefixSum.hs view
@@ -0,0 +1,304 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.PrefixSum.PrefixSum+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- The PrefixSum algorithm over power-lists and proof of+-- the Ladner-Fischer implementation.+-- See <http://www.cs.utexas.edu/users/psp/powerlist.pdf>+-- and <http://www.cs.utexas.edu/~plaxton/c/337/05f/slides/ParallelRecursion-4.pdf>.+-----------------------------------------------------------------------------++{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE ScopedTypeVariables #-}++module Data.SBV.Examples.PrefixSum.PrefixSum where++import Data.SBV+import Data.SBV.Internals(runSymbolic)++----------------------------------------------------------------------+-- * Formalizing power-lists+----------------------------------------------------------------------++-- | A poor man's representation of powerlists and+-- basic operations on them: <http://www.cs.utexas.edu/users/psp/powerlist.pdf>.+-- We merely represent power-lists by ordinary lists.+type PowerList a = [a]++-- | The tie operator, concatenation+tiePL :: PowerList a -> PowerList a -> PowerList a+tiePL = (++)++-- | The zip operator, zips the power-lists of the same size, returns+-- a powerlist of double the size.+zipPL :: PowerList a -> PowerList a -> PowerList a+zipPL []     []     = []+zipPL (x:xs) (y:ys) = x : y : zipPL xs ys+zipPL _      _      = error "zipPL: nonsimilar powerlists received"++-- | Inverse of zipping+unzipPL :: PowerList a -> (PowerList a, PowerList a)+unzipPL = unzip . chunk2+  where chunk2 []       = []+        chunk2 (x:y:xs) = (x,y) : chunk2 xs+        chunk2 _        = error "unzipPL: malformed powerlist"++----------------------------------------------------------------------+-- * Reference prefix-sum implementation+----------------------------------------------------------------------++-- | Reference prefix sum (@ps@) is simply Haskell's @scanl1@ function+ps :: (a, a -> a -> a) -> PowerList a -> PowerList a+ps (_, f) = scanl1 f++----------------------------------------------------------------------+-- * The Ladner-Fischer parallel version+----------------------------------------------------------------------++-- | The Ladner-Fischer (@lf@) implementation of prefix-sum. See <http://www.cs.utexas.edu/~plaxton/c/337/05f/slides/ParallelRecursion-4.pdf>+-- or pg. 16 of <http://www.cs.utexas.edu/users/psp/powerlist.pdf>.+lf :: (a, a -> a -> a) -> PowerList a -> PowerList a+lf _ []         = error "lf: malformed (empty) powerlist"+lf _ [x]        = [x]+lf (zero, f) pl = zipPL (zipWith f (rsh lfpq) p) lfpq+   where (p, q) = unzipPL pl+         pq     = zipWith f p q+         lfpq   = lf (zero, f) pq+         rsh xs = zero : init xs+++----------------------------------------------------------------------+-- * Sample proofs for concrete operators+----------------------------------------------------------------------++-- | Correctness theorem, for a powerlist of given size, an associative operator, and its left-unit element+flIsCorrect :: Int -> (forall a. (OrdSymbolic a, Bits a) => (a, a -> a -> a)) -> Symbolic SBool+flIsCorrect n zf = do+        args :: PowerList SWord32 <- mkFreeVars n+        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@.+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@.+thm2 :: IO ThmResult+thm2 = prove $ flIsCorrect 16 (0, smax)++----------------------------------------------------------------------+-- * Attempt at proving for arbitrary operators+----------------------------------------------------------------------+-- | Try proving correctness for an arbitrary operator. This proof will /not/ go through since the+-- SMT solver does not know that the operator associative and has the given left-unit element+--+-- >>> thm3+-- Falsifiable. Counter-example:+--   s0 = 0 :: SWord32+--   s1 = 0 :: SWord32+--   s2 = 0 :: SWord32+--   s3 = 0 :: SWord32+--   s4 = 0 :: SWord32+--   s5 = 0 :: SWord32+--   s6 = 0 :: SWord32+--   s7 = 3221225472 :: SWord32+--   -- uninterpreted: u+--        u  = 0+--   -- uninterpreted: flOp+--        flOp 0 3221225472 = 2147483648+--        flOp 0 2147483648 = 3758096384+--        flOp _ _          = 0+--+-- You can verify that the above function for @flOp@ is not associative:+--+-- @+--   ghci> flOp 3221225472 (flOp 2147483648 3221225472)+--   0+--   ghci> flOp (flOp 3221225472 2147483648) 3221225472+--   2147483648+-- @+--+-- Also, the unit @0@ is clearly not a left-unit for @flOp@, as the third+-- equation for @flOp@ will simply map many elements to @0@.+thm3 :: IO ThmResult+thm3 = prove $ do args :: PowerList SWord32 <- mkFreeVars 8+                  return $ ps (u, op) args .== lf (u, op) args+  where op :: SWord32 -> SWord32 -> SWord32+        op = uninterpret "flOp"+        u :: SWord32+        u = uninterpret "u"++----------------------------------------------------------------------+-- * Proving for arbitrary operators using axioms+----------------------------------------------------------------------+-- | Generate an instance of the prefix-sum problem for an arbitrary operator, by telling the SMT solver+-- the necessary axioms for associativity and left-unit. The first argument states how wide the power list should be.+genPrefixSumInstance :: Int -> Symbolic SBool+genPrefixSumInstance n = do+     args :: PowerList SWord32 <- mkFreeVars n+     addAxiom "flOp is associative"     $ assocAxiom (sbvUFName opH)+     addAxiom "u is left-unit for flOp" $ leftUnitAxiom (sbvUFName opH) (sbvUFName uH)+     return $ ps (u, op) args .== lf (u, op) args+  where op :: SWord32 -> SWord32 -> SWord32+        opH :: SBVUF+        (opH, op) = uninterpretWithHandle "flOp"+        u  :: SWord32+        uH :: SBVUF+        (uH, u)  = uninterpretWithHandle "u"+        -- this is the brittle part; but it'll have to do until we get a proper+        -- DSL for expressing SMT-axioms..+        mkCall :: String -> String -> String -> String+        mkCall o x y = "(" ++ o ++ " " ++ x ++ " " ++ y ++ ")"+        assocAxiom :: String -> [String]+        assocAxiom o = [+             ":assumption (forall (?x BitVec[32]) (?y BitVec[32]) (?z BitVec[32])"+           , "                    (= " ++ lhs+           , "                       " ++ rhs+           , "                    )"+           , "            )"+          ]+          where lhs = mkCall o (mkCall o "?x" "?y") "?z"+                rhs = mkCall o "?x" (mkCall o "?y" "?z")+        leftUnitAxiom :: String -> String -> [String]+        leftUnitAxiom o ue = [+            ":assumption (forall (?x BitVec[32])"+          , "                    (= " ++ lhs+          , "                       " ++ rhs+          , "                    )"+          , "            )"+          ]+          where lhs = "(" ++ o ++ " " ++ ue ++ " " ++ "?x" ++ ")"+                rhs = "?x"++-- | Prove the generic problem for powerlists of given sizes. Note that+-- this will only work for Yices-1. This is due to the fact that Yices-2+-- follows the SMT-Lib standard and does not accept bit-vector problems with+-- quantified axioms in them, while Yices-1 did allow for that. The crux of+-- the problem is that there are no SMT-Lib logics that combine BV's and+-- quantifiers, see: <http://goedel.cs.uiowa.edu/smtlib/logics.html>. So we+-- are stuck until new powerful logics are added to SMT-Lib.+--+-- Here, we explicitly tell SBV to use Yices-1 that did not have that limitation.+-- Tweak the executable location accordingly below for your platform..+--+-- We have:+--+-- >>> prefixSum 2+-- Q.E.D.+--+-- >>> prefixSum 4+-- Q.E.D.+--+-- Note that these proofs tend to run long. Also, Yices-1.0.28 ran out of memory+-- and crashed on my box when I tried for size @8@, after running for about 2.5 minutes..+prefixSum :: Int -> IO ThmResult+prefixSum i+  -- Fast way of checking whether a number is a power of two, see: <http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2>+  | i <= 1 || (i .&. (i-1)) /= 0+  = error $ "prefixSum: input must be a power of 2 larger than 2, received: " ++ show i+  | True+  = proveWith cfg $ genPrefixSumInstance i+  where cfg = defaultSMTCfg { solver = yices' }+        yices' = yices { options    = ["-tc", "-smt", "-e"]+                       , executable = "/usr/local/yices-1.0.28/bin/yices"+                       }++----------------------------------------------------------------------+-- * 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+--   s_1 = True+-- TABLES+-- ARRAYS+-- UNINTERPRETED CONSTANTS+-- AXIOMS+-- 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+-- OUTPUTS+--   s0+--   s8+--   s9+--   s11+--   s12+--   s14+--   s15+--   s18+ladnerFischerTrace :: Int -> IO ()+ladnerFischerTrace n = gen >>= print+  where gen = runSymbolic $ do args :: [SWord8] <- mkFreeVars 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+--   s_1 = True+-- TABLES+-- ARRAYS+-- UNINTERPRETED CONSTANTS+-- AXIOMS+-- 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+-- OUTPUTS+--   s0+--   s8+--   s9+--   s10+--   s11+--   s12+--   s13+--   s14+--+scanlTrace :: Int -> IO ()+scanlTrace n = gen >>= print+  where gen = runSymbolic $ do args :: [SWord8] <- mkFreeVars n+                               mapM_ output $ ps (0, (+)) args
+ Temp/sbv-0.9.18/Data/SBV/Examples/Puzzles/DogCatMouse.hs view
@@ -0,0 +1,41 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Puzzles.DogCatMouse+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Puzzle:+--   Spend exactly 100 dollars and buy exactly 100 animals.+--   Dogs cost 15 dollars, cats cost 1 dollar, and mice cost 25 cents each.+--   You have to buy at least one of each.+--   How many of each should you buy?+-----------------------------------------------------------------------------++module Data.SBV.Examples.Puzzles.DogCatMouse where++import Data.SBV++-- | Use 16-bit words to represent the counts, much larger than we actually need, but no harm.+type Count = SWord16++-- | Codes the puzzle statement, more or less directly using SBV.+puzzle :: Count -> Count -> Count -> SBool+puzzle dog cat mouse =+         dog   .>= 1 &&& dog   .<= 98                  -- at least one dog and at most 98+    &&&  cat   .>= 1 &&& cat   .<= 98                  -- ditto for cats+    &&&  mouse .>= 1 &&& mouse .<= 98                  -- ditto for mice+    &&&  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)++-- | Prints the only solution:+--+-- >>> solve+-- Only one solution found:+--   dog = 3 :: SWord16+--   cat = 41 :: SWord16+--   mouse = 56 :: SWord16+solve :: IO AllSatResult+solve = allSat $ forAll ["dog", "cat", "mouse"] puzzle
+ Temp/sbv-0.9.18/Data/SBV/Examples/Puzzles/Euler185.hs view
@@ -0,0 +1,50 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Puzzles.Euler185+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- A solution to Project Euler problem #185: <http://projecteuler.net/index.php?section=problems&id=185>+-----------------------------------------------------------------------------++module Data.SBV.Examples.Puzzles.Euler185 where++import Data.Char(ord)+import Data.SBV++-- | The given guesses and the correct digit counts, encoded as a simple list.+guesses :: [(String, SWord8)]+guesses = [ ("5616185650518293", 2), ("3847439647293047", 1), ("5855462940810587", 3)+          , ("9742855507068353", 3), ("4296849643607543", 3), ("3174248439465858", 1)+          , ("4513559094146117", 2), ("7890971548908067", 3), ("8157356344118483", 1)+          , ("2615250744386899", 2), ("8690095851526254", 3), ("6375711915077050", 1)+          , ("6913859173121360", 1), ("6442889055042768", 2), ("2321386104303845", 0)+          , ("2326509471271448", 2), ("5251583379644322", 2), ("1748270476758276", 3)+          , ("4895722652190306", 1), ("3041631117224635", 3), ("1841236454324589", 3)+          , ("2659862637316867", 2)+          ]++-- | Encode the problem, note that we check digits are within 0-9 as+-- we use 8-bit words to represent them. Otherwise, the constraints are simply+-- generated by zipping the alleged solution with each guess, and making sure the+-- number of matching digits match what's given in the problem statement.+euler185 :: Symbolic SBool+euler185 = do soln <- mkFreeVars 16+              return $ bAll digit soln &&& bAnd (map (genConstr soln) guesses)+  where genConstr a (b, c) = sum (zipWith eq a b) .== (c :: SWord8)+        digit x = (x :: SWord8) .>= 0 &&& x .<= 9+        eq x y =  ite (x .== fromIntegral (ord y - ord '0')) 1 0++-- | Print out the solution nicely. We have:+--+-- >>> solve+-- 4640261571849533+-- Number of solutions: 1+solve :: IO ()+solve = do res <- allSat euler185+           cnt <- displayModels disp res+           putStrLn $ "Number of solutions: " ++ show cnt+   where disp _ ss = putStrLn $ concatMap show (ss :: [Word8])
+ Temp/sbv-0.9.18/Data/SBV/Examples/Puzzles/MagicSquare.hs view
@@ -0,0 +1,77 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Puzzles.MagicSquare+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Solves the magic-square puzzle. An NxN magic square is one where all entries+-- are filled with numbers from 1 to NxN such that sums of all rows, columns+-- and diagonals is the same.+-----------------------------------------------------------------------------++module Data.SBV.Examples.Puzzles.MagicSquare where++import Data.List (genericLength, transpose)++import Data.SBV++-- | Use 32-bit words for elements.+type Elem  = SWord32++-- | A row is a list of elements+type Row   = [Elem]++-- | The puzzle board is a list of rows+type Board = [Row]++-- | Checks that all elements in a list are within bounds+check :: Elem -> Elem -> [Elem] -> SBool+check low high grp = bAll rangeFine grp+  where rangeFine x = x .>= low &&& x .<= high++-- | Get the diagonal of a square matrix+diag :: [[a]] -> [a]+diag ((a:_):rs) = a : diag (map tail rs)+diag _          = []++-- | Test if a given board is a magic square+isMagic :: Board -> SBool+isMagic rows = bAnd $ fromBool isSquare : allEqual (map sum items) : allDifferent (concat rows) : map chk items+  where items = d1 : d2 : rows ++ columns+        n = genericLength rows+        isSquare = all (\r -> genericLength r == n) rows+        columns = transpose rows+        d1 = diag rows+        d2 = diag (map reverse rows)+        chk = check (literal 1) (literal (n*n))++-- | Group a list of elements in the sublists of length @i@+chunk :: Int -> [a] -> [[a]]+chunk _ [] = []+chunk i xs = let (f, r) = splitAt i xs in f : chunk i r++-- | Given @n@, magic @n@ prints all solutions to the @nxn@ magic square problem+magic :: Int -> IO ()+magic n+ | n < 0 = putStrLn $ "n must be non-negative, received: " ++ show n+ | True  = do putStrLn $ "Finding all " ++ show n ++ "-magic squares.."+              res <- allSat $ mkFreeVars n2 >>= return . isMagic . chunk n+              cnt <- displayModels disp res+              putStrLn $ "Found: " ++ show cnt ++ " solution(s)."+   where n2 = n * n+         disp i model+          | lmod /= n2+          = error $ "Impossible! Backend solver returned " ++ show n ++ " values, was expecting: " ++ show lmod+          | True+          = do putStrLn $ "Solution #" ++ show i+               mapM_ printRow board+               putStrLn $ "Valid Check: " ++ show (isMagic sboard)+               putStrLn "Done."+          where lmod  = length model+                board = chunk n $ model+                sboard = map (map literal) board+                sh2 z = let s = show z in if length s < 2 then ' ':s else s+                printRow r = putStr "   " >> mapM_ (\x -> putStr ((sh2 x) ++ " ")) r >> putStrLn ""
+ Temp/sbv-0.9.18/Data/SBV/Examples/Puzzles/NQueens.hs view
@@ -0,0 +1,47 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Puzzles.NQueens+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Solves the NQueens puzzle: <http://en.wikipedia.org/wiki/Eight_queens_puzzle>+-----------------------------------------------------------------------------++module Data.SBV.Examples.Puzzles.NQueens where++import Data.SBV++-- | A solution is a sequence of row-numbers where queens should be placed+type Solution = [SWord8]++-- | Checks that a given solution of @n@-queens is valid, i.e., no queen+-- captures any other.+isValid :: Int -> Solution -> SBool+isValid n s = bAll rangeFine s &&& allDifferent s &&& bAll checkDiag ijs+  where rangeFine x = x .>= 1 &&& x .<= fromIntegral n+        ijs = [(i, j) | i <- [1..n], j <- [i+1..n]]+        checkDiag (i, j) = diffR ./= diffC+           where qi = s !! (i-1)+                 qj = s !! (j-1)+                 diffR = ite (qi .>= qj) (qi-qj) (qj-qi)+                 diffC = fromIntegral (j-i)++-- | Given @n@, it solves the @n-queens@ puzzle, printing all possible solutions.+nQueens :: Int -> IO ()+nQueens n+ | n < 0 = putStrLn $ "n must be non-negative, received: " ++ show n+ | True  = do putStrLn $ "Finding all " ++ show n ++ "-queens solutions.."+              res <- allSat $ mkFreeVars n >>= return . isValid n+              cnt <- displayModels disp res+              putStrLn $ "Found: " ++ show cnt ++ " solution(s)."+   where disp i s = do putStr $ "Solution #" ++ show i ++ ": "+                       dispSolution s+         dispSolution :: [Word8] -> IO ()+         dispSolution model+           | lmod /= n = error $ "Impossible! Backend solver returned " ++ show lmod ++ " values, was expecting: " ++ show n+           | True      = do putStr $ show model+                            putStrLn $ " (Valid: " ++ show (isValid n (map literal model)) ++ ")"+           where lmod  = length model
+ Temp/sbv-0.9.18/Data/SBV/Examples/Puzzles/PowerSet.hs view
@@ -0,0 +1,35 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Puzzles.PowerSet+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Computes the powerset of a givenset+-----------------------------------------------------------------------------++module Data.SBV.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 $ mkFreeVars n >>= return . genPowerSet+                 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 _ = []
+ Temp/sbv-0.9.18/Data/SBV/Examples/Puzzles/Sudoku.hs view
@@ -0,0 +1,251 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Puzzles.Sudoku+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- The Sudoku solver, quintessential SMT solver example!+-----------------------------------------------------------------------------++module Data.SBV.Examples.Puzzles.Sudoku where++import Data.List  (transpose)+import Data.Maybe (fromJust)++import Data.SBV++-------------------------------------------------------------------+-- * Modeling Sudoku+-------------------------------------------------------------------+-- | A row is a sequence of 8-bit words, too large indeed for representing 1-9, but does not harm+type Row   = [SWord8]++-- | A Sudoku board is a sequence of 9 rows+type Board = [Row]++-- | Given a series of elements, make sure they are all different+-- and they all are numbers between 1 and 9+check :: [SWord8] -> SBool+check grp = bAnd $ allDifferent grp : map rangeFine grp+  where rangeFine x = x .> 0 &&& x .<= 9++-- | Given a full Sudoku board, check that it is valid+valid :: Board -> SBool+valid rows = bAnd $ literal sizesOK : map check (rows ++ columns ++ squares)+  where sizesOK = length rows == 9 && all (\r -> length r == 9) rows+        columns = transpose rows+        regions = transpose [chunk 3 row | row <- rows]+        squares = [concat sq | sq <- chunk 3 (concat regions)]+        chunk :: Int -> [a] -> [[a]]+        chunk _ [] = []+        chunk i xs = let (f, r) = splitAt i xs in f : chunk i r++-- | A puzzle is a pair: First is the number of missing elements, second+-- is a function that given that many elements returns the final board.+type Puzzle = (Int, [SWord8] -> Board)++-------------------------------------------------------------------+-- * Solving Sudoku puzzles+-------------------------------------------------------------------++-- | Solve a given puzzle and print the results+solve :: Puzzle -> IO ()+solve p@(i, f) = do putStrLn "Solving the puzzle.."+                    SatResult res <- sat $ mkFreeVars i >>= return . valid . f+                    dispSolution p (getModel res)++-- | Helper function to display results nicely, not really needed, but helps presentation+dispSolution :: Puzzle -> [Word8] -> IO ()+dispSolution (i, f) fs+  | lmod /= i = error $ "Impossible! Backend solver returned " ++ show lmod ++ " values, was expecting: " ++ show i+  | True      = do putStrLn "Final board:"+                   mapM_ printRow final+                   putStrLn $ "Valid Check: " ++ show (valid final)+                   putStrLn "Done."+  where lmod = length fs+        final = f (map literal fs)+        printRow r = putStr "   " >> mapM_ (\x -> putStr (show (fromJust (unliteral x)) ++ " ")) r >> putStrLn ""++-- | Find all solutions to a puzzle+solveAll :: Puzzle -> IO ()+solveAll p@(i, f) = do putStrLn "Finding all solutions.."+                       res <- allSat $ mkFreeVars i >>= return . valid . f+                       cnt <- displayModels disp res+                       putStrLn $ "Found: " ++ show cnt ++ " solution(s)."+   where disp n s = do putStrLn $ "Solution #" ++ show n+                       dispSolution p s++-------------------------------------------------------------------+-- * Example boards+-------------------------------------------------------------------++-- | Find an arbitrary good board+puzzle0 :: Puzzle+puzzle0 = (81, f)+  where f   [ a1, a2, a3, a4, a5, a6, a7, a8, a9,+              b1, b2, b3, b4, b5, b6, b7, b8, b9,+              c1, c2, c3, c4, c5, c6, c7, c8, c9,+              d1, d2, d3, d4, d5, d6, d7, d8, d9,+              e1, e2, e3, e4, e5, e6, e7, e8, e9,+              f1, f2, f3, f4, f5, f6, f7, f8, f9,+              g1, g2, g3, g4, g5, g6, g7, g8, g9,+              h1, h2, h3, h4, h5, h6, h7, h8, h9,+              i1, i2, i3, i4, i5, i6, i7, i8, i9 ]+         = [ [a1, a2, a3, a4, a5, a6, a7, a8, a9],+             [b1, b2, b3, b4, b5, b6, b7, b8, b9],+             [c1, c2, c3, c4, c5, c6, c7, c8, c9],+             [d1, d2, d3, d4, d5, d6, d7, d8, d9],+             [e1, e2, e3, e4, e5, e6, e7, e8, e9],+             [f1, f2, f3, f4, f5, f6, f7, f8, f9],+             [g1, g2, g3, g4, g5, g6, g7, g8, g9],+             [h1, h2, h3, h4, h5, h6, h7, h8, h9],+             [i1, i2, i3, i4, i5, i6, i7, i8, i9] ]+        f _ = error "puzzle0 needs exactly 81 elements!"++-- | A random puzzle, found on the internet..+puzzle1 :: Puzzle+puzzle1 = (49, f)+  where f   [ a1,     a3, a4, a5, a6, a7,     a9,+              b1, b2, b3,             b7, b8, b9,+                  c2,     c4, c5, c6,     c8,+                      d3,     d5,     d7,+              e1, e2,     e4, e5, e6,     e8, e9,+                      f3,     f5,     f7,+                  g2,     g4, g5, g6,     g8,+              h1, h2, h3,             h7, h8, h9,+              i1,     i3, i4, i5, i6, i7,     i9 ]+         = [ [a1,  6, a3, a4, a5, a6, a7,  1, a9],+             [b1, b2, b3,  6,  5,  1, b7, b8, b9],+             [ 1, c2,  7, c4, c5, c6,  6, c8,  2],+             [ 6,  2, d3,  3, d5,  5, d7,  9,  4],+             [e1, e2,  3, e4, e5, e6,  2, e8, e9],+             [ 4,  8, f3,  9, f5,  7, f7,  3,  6],+             [ 9, g2,  6, g4, g5, g6,  4, g8,  8],+             [h1, h2, h3,  7,  9,  4, h7, h8, h9],+             [i1,  5, i3, i4, i5, i6, i7,  7, i9] ]+        f _ = error "puzzle1 needs exactly 49 elements!"++-- | Another random puzzle, found on the internet..+puzzle2 :: Puzzle+puzzle2 = (55, f)+  where f   [     a2,     a4, a5, a6, a7,     a9,+              b1, b2,     b4,         b7, b8, b9,+              c1,     c3, c4, c5, c6, c7, c8, c9,+                  d2, d3, d4,             d8, d9,+              e1,     e3,     e5,     e7,     e9,+              f1, f2,             f6, f7, f8,+              g1, g2, g3, g4, g5, g6, g7,     g9,+              h1, h2, h3,         h6,     h8, h9,+              i1,     i3, i4, i5, i6,     i8     ]+         = [ [ 1, a2,  3, a4, a5, a6, a7,  8, a9],+             [b1, b2,  6, b4,  4,  8, b7, b8, b9],+             [c1,  4, c3, c4, c5, c6, c7, c8, c9],+             [ 2, d2, d3, d4,  9,  6,  1, d8, d9],+             [e1,  9, e3,  8, e5,  1, e7,  4, e9],+             [f1, f2,  4,  3,  2, f6, f7, f8,  8],+             [g1, g2, g3, g4, g5, g6, g7,  7, g9],+             [h1, h2, h3,  1,  5, h6,  4, h8, h9],+             [i1,  6, i3, i4, i5, i6,  2, i8,  3] ]+        f _ = error "puzzle2 needs exactly 55 elements!"++-- | Another random puzzle, found on the internet..+puzzle3 :: Puzzle+puzzle3 = (56, f)+  where f   [     a2, a3, a4,     a6,     a8, a9,+                  b2,     b4, b5, b6, b7, b8, b9,+              c1, c2, c3, c4,     c6, c7,     c9,+              d1,     d3,     d5,     d7,     d9,+                  e2, e3, e4,     e6, e7, e8,+              f1,     f3,     f5,     f7,     f9,+              g1,     g3, g4,     g6, g7, g8, g9,+              h1, h2, h3, h4, h5, h6,     h8,+              i1, i2,     i4,     i6, i7, i8     ]+         = [ [ 6, a2, a3, a4,  1, a6,  5, a8, a9],+             [ 8, b2,  3, b4, b5, b6, b7, b8, b9],+             [c1, c2, c3, c4,  6, c6, c7,  2, c9],+             [d1,  3, d3,  1, d5,  8, d7,  9, d9],+             [ 1, e2, e3, e4,  9, e6, e7, e8,  4],+             [f1,  5, f3,  2, f5,  3, f7,  1, f9],+             [g1,  7, g3, g4,  3, g6, g7, g8, g9],+             [h1, h2, h3, h4, h5, h6,  3, h8,  6],+             [i1, i2,  4, i4,  5, i6, i7, i8,  9] ]+        f _ = error "puzzle3 needs exactly 56 elements!"++-- | According to the web, this is the toughest +-- sudoku puzzle ever.. It even has a name: Al Escargot:+-- <http://zonkedyak.blogspot.com/2006/11/worlds-hardest-sudoku-puzzle-al.html>+puzzle4 :: Puzzle+puzzle4 = (58, f)+  where f   [     a2, a3, a4, a5,     a7,     a9,+              b1,     b3, b4,     b6, b7, b8,+              c1, c2,         c5, c6,     c8, c9,+              d1, d2,         d5, d6,     d8, d9,+              e1,     e3, e4,     e6, e7, e8,+                  f2, f3, f4, f5,     f7, f8, f9,+                  g2, g3, g4, g5, g6, g7,     g9,+              h1,     h3, h4, h5, h6, h7, h8,+              i1, i2,     i4, i5, i6,     i8, i9 ]+         = [ [ 1, a2, a3, a4, a5,  7, a7,  9, a9],+             [b1,  3, b3, b4,  2, b6, b7, b8,  8],+             [c1, c2,  9,  6, c5, c6,  5, c8, c9],+             [d1, d2,  5,  3, d5, d6,  9, d8, d9],+             [e1,  1, e3, e4,  8, e6, e7, e8,  2],+             [ 6, f2, f3, f4, f5,  4, f7, f8, f9],+             [ 3, g2, g3, g4, g5, g6, g7,  1, g9],+             [h1,  4, h3, h4, h5, h6, h7, h8,  7],+             [i1, i2,  7, i4, i5, i6,  3, i8, i9] ]+        f _ = error "puzzle4 needs exactly 58 elements!"++-- | This one has been called diabolical, apparently+puzzle5 :: Puzzle+puzzle5 = (53, f)+  where f   [ a1,     a3,     a5, a6,         a9,+              b1,         b4, b5,     b7,     b9,+                  c2,     c4, c5, c6, c7, c8, c9,+              d1, d2,     d4,     d6, d7, d8,+              e1, e2, e3,     e5,     e7, e8, e9,+                  f2, f3, f4,     f6,     f8, f9,+              g1, g2, g3, g4, g5, g6,     g8,+              h1,     h3,     h5, h6,         h9,+              i1,         i4, i5,     i7,     i9 ]+         = [ [a1,  9, a3,  7, a5, a6,  8,  6, a9],+             [b1,  3,  1, b4, b5,  5, b7,  2, b9],+             [ 8, c2,  6, c4, c5, c6, c7, c8, c9],+             [d1, d2,  7, d4,  5, d6, d7, d8,  6],+             [e1, e2, e3,  3, e5,  7, e7, e8, e9],+             [ 5, f2, f3, f4,  1, f6,  7, f8, f9],+             [g1, g2, g3, g4, g5, g6,  1, g8,  9],+             [h1,  2, h3,  6, h5, h6,  3,  5, h9],+             [i1,  5,  4, i4, i5,  8, i7,  7, i9] ]+        f _ = error "puzzle5 needs exactly 53 elements!"++-- | The following is nefarious according to+-- <http://haskell.org/haskellwiki/Sudoku>+puzzle6 :: Puzzle+puzzle6 = (64, f)+  where f   [ a1, a2, a3, a4,     a6, a7,     a9,+              b1,     b3, b4, b5, b6, b7, b8, b9,+              c1, c2,     c4, c5, c6, c7, c8, c9,+              d1,     d3, d4, d5, d6,     d8,+                  e2, e3, e4,     e6, e7, e8, e9,+              f1, f2, f3, f4, f5, f6,     f8, f9,+              g1, g2,         g5,     g7, g8, g9,+                  h2, h3,     h5, h6,     h8, h9,+              i1, i2, i3, i4, i5, i6, i7,     i9  ]+         = [ [a1, a2, a3, a4,  6, a6, a7,  8, a9],+             [b1,  2, b3, b4, b5, b6, b7, b8, b9],+             [c1, c2,  1, c4, c5, c6, c7, c8, c9],+             [d1,  7, d3, d4, d5, d6,  1, d8,  2],+             [ 5, e2, e3, e4,  3, e6, e7, e8, e9],+             [f1, f2, f3, f4, f5, f6,  4, f8, f9],+             [g1, g2,  4,  2, g5,  1, g7, g8, g9],+             [ 3, h2, h3,  7, h5, h6,  6, h8, h9],+             [i1, i2, i3, i4, i5, i6, i7,  5, i9] ]+        f _ = error "puzzle6 needs exactly 64 elements!"++-- | Solve them all, this takes a fraction of a second to run for each case+allPuzzles :: IO ()+allPuzzles = mapM_ solve [puzzle0, puzzle1, puzzle2, puzzle3, puzzle4, puzzle5, puzzle6]
+ Temp/sbv-0.9.18/Data/SBV/Examples/Puzzles/Temperature.hs view
@@ -0,0 +1,40 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Puzzles.Temperature+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Puzzle:+--   What 2 digit fahrenheit/celcius values are reverses of each other?+--   Ignoring the fractions in the conversion+-----------------------------------------------------------------------------++module Data.SBV.Examples.Puzzles.Temperature where++import Data.SBV++type Temp = SWord16 -- larger than we need actually++-- 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) `bvQuotRem` 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 `bvQuotRem` 10+        swap (a, b) = (b, a)++solve :: IO ()+solve = do res <- allSat $ free_ >>= return . revOf+           cnt <- displayModels disp res+           putStrLn $ "Found " ++ show cnt ++ " solutions."+     where disp :: Int -> Word16 -> 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
+ Temp/sbv-0.9.18/Data/SBV/Examples/Puzzles/U2Bridge.hs view
@@ -0,0 +1,270 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Puzzles.U2Bridge+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- The famous U2 bridge crossing puzzle: <http://www.brainj.net/puzzle.php?id=u2>+-----------------------------------------------------------------------------++{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE PatternGuards #-}++module Data.SBV.Examples.Puzzles.U2Bridge where++import Control.Monad.State (State, runState, put, get, modify, evalState)+import Data.Maybe          (fromJust)++import Data.SBV++-------------------------------------------------------------+-- * Modeling the puzzle+-------------------------------------------------------------++-- | U2 band members+data U2Member = Bono | Edge | Adam | Larry+              deriving (Show, Enum)++-- | Model time using 32 bits+type Time      = SWord32++-- | Each member gets an 8-bit id+type SU2Member = SWord8++-- | Bono's ID+bono :: SU2Member+bono  = fromIntegral . fromEnum $ Bono++-- | Edge's ID+edge :: SU2Member+edge  = fromIntegral . fromEnum $ Edge++-- | Adam's ID+adam :: SU2Member+adam  = fromIntegral . fromEnum $ Adam++-- | Larry's ID+larry :: SU2Member+larry = fromIntegral . fromEnum $ Larry++-- | Is this a valid person?+isU2Member :: SU2Member -> SBool+isU2Member = (.<= larry)  -- 8 bits can represent 256 people; trim it down!++-- | Crossing times for each member of the band+crossTime :: SU2Member -> Time+crossTime = select [  1 {- Bono -}+                   ,  2 {- Edge -}+                   ,  5 {- Adam -}+                   ] 10 {- Larry -}++-- | Location of the flash+type Location = SBool++-- | We represent this side of the bridge as 'here', and arbitrarily as 'false'+here :: Location+here = false++-- | We represent other side of the bridge as 'there', and arbitrarily as 'true'+there :: Location+there = bnot here++-- | The status of the puzzle after each move+data Status = Status { time   :: Time       -- ^ elapsed time+                     , flash  :: Location   -- ^ location of the flash+                     , lBono  :: Location   -- ^ location of Bono+                     , lEdge  :: Location   -- ^ location of Edge+                     , lAdam  :: Location   -- ^ location of Adam+                     , lLarry :: Location   -- ^ location of Larry+                     }++-- | Start configuration, time elapsed is 0 and everybody is 'here'+start :: Status+start = Status { time   = 0+               , flash  = here+               , lBono  = here+               , lEdge  = here+               , lAdam  = here+               , lLarry = here+               }++instance Mergeable Status where+  symbolicMerge t s1 s2 = Status { time   = symbolicMerge t (time s1)   (time  s2)+                                 , flash  = symbolicMerge t (flash s1)  (flash s2)+                                 , lBono  = symbolicMerge t (lBono s1)  (lBono s2)+                                 , lEdge  = symbolicMerge t (lEdge s1)  (lEdge s2)+                                 , lAdam  = symbolicMerge t (lAdam s1)  (lAdam s2)+                                 , lLarry = symbolicMerge t (lLarry s1) (lLarry s2)+                                 }++-- | A puzzle move is modeled as a state-transformer+type Move a = State Status a++instance Mergeable a => Mergeable (Move a) where+  symbolicMerge t a b+    = do s <- get+         let (ar, s1) = runState a s+             (br, s2) = runState b s+         put $ symbolicMerge t s1 s2+         return $ symbolicMerge t ar br++-- | Read the state via an accessor function+peek :: (Status -> a) -> Move a+peek f = do s <- get+            return (f s)++-- | Given an arbitrary member, return his location+whereIs :: SU2Member -> Move SBool+whereIs p = do [lb, le, la, ll]  <- mapM peek [lBono, lEdge, lAdam, lLarry]+               return $ select [lb, le, la] ll p++-- | Transferring the flash to the other side+xferFlash :: Move ()+xferFlash = modify $ \s -> s{flash = bnot (flash s)}++-- | Transferring a person to the other side+xferPerson :: SU2Member -> Move ()+xferPerson p =  do [lb, le, la, ll] <- mapM peek [lBono, lEdge, lAdam, lLarry]+                   let lb' = ite (p .== bono)  (bnot lb) lb+                       le' = ite (p .== edge)  (bnot le) le+                       la' = ite (p .== adam)  (bnot la) la+                       ll' = ite (p .== larry) (bnot ll) ll+                   modify $ \s -> s{lBono = lb', lEdge = le', lAdam = la', lLarry = ll'}++-- | Increment the time, when only one person crosses+bumpTime1 :: SU2Member -> Move ()+bumpTime1 p = modify $ \s -> s{time = time s + crossTime p}++-- | Increment the time, when two people cross together+bumpTime2 :: SU2Member -> SU2Member -> Move ()+bumpTime2 p1 p2 = modify $ \s -> s{time = time s + crossTime p1 `smax` crossTime p2}++-- | Symbolic version of 'when'+whenS :: SBool -> Move () -> Move ()+whenS t a = ite t a (return ())++-- | Move one member, remembering to take the flash+move1 :: SU2Member -> Move ()+move1 p = do f <- peek flash+             l <- whereIs p+             -- only do the move if the person and the flash are at the same side+             whenS (f .== l) $ do bumpTime1 p+                                  xferFlash+                                  xferPerson p++-- | Move two members, again with the flash+move2 :: SU2Member -> SU2Member -> Move ()+move2 p1 p2 = do f  <- peek flash+                 l1 <- whereIs p1+                 l2 <- whereIs p2+                 -- only do the move if both people and the flash are at the same side+                 whenS (f .== l1 &&& f .== l2) $ do bumpTime2 p1 p2+                                                    xferFlash+                                                    xferPerson p1+                                                    xferPerson p2++-------------------------------------------------------------+-- * Actions+-------------------------------------------------------------++-- | A move action is a sequence of triples. The first component is symbolically+-- True if only one member crosses. (In this case the third element of the triple+-- is irrelevant.) If the first component is (symbolically) False, then both members+-- move together+type Actions = [(SBool, SU2Member, SU2Member)]++-- | Run a sequence of given actions.+run :: Actions -> Move [Status]+run = sequence . map step+ where step (b, p1, p2) = ite b (move1 p1) (move2 p1 p2) >> get++-------------------------------------------------------------+-- * Recognizing valid solutions+-------------------------------------------------------------++-- | Check if a given sequence of actions is valid, i.e., they must all+-- cross the bridge according to the rules and in less than 17 seconds+isValid :: Actions -> SBool+isValid as = time end .<= 17 &&& bAll check as &&& zigZag there (map flash states) &&& bAll (.== there) [lBono end, lEdge end, lAdam end, lLarry end]+  where check (s, p1, p2) =   isU2Member p1 &&& isU2Member p2+                          -- the following two conditions ensure we find distinct solutions+                          &&& (bnot s ==> p1 .> p2) -- for two person moves, ensure first person is "larger"+                          &&& (s ==> p2 .== bono)   -- for one person moves, ensure second person is always "bono"+        states = evalState (run as) start+        end = last states+        zigZag _ []       = true+        zigZag w (f:rest) = w .== f &&& zigZag (bnot w) rest++instance SatModel U2Member where+  parseCWs as = cvtModel cvtCW $ parseCWs as+    where cvtCW :: Word8 -> Maybe U2Member+          cvtCW i = lookup i (zip [0..] [Bono, Edge, Adam, Larry])++-------------------------------------------------------------+-- * Solving the puzzle+-------------------------------------------------------------++-- | See if there is a solution that has precisely @n@ steps+solveN :: Int -> IO Bool+solveN n = do putStrLn $ "Checking for solutions with " ++ show n ++ " move" ++ plu n ++ "."+              let genAct = do b  <- free_+                              p1 <- free_+                              p2 <- free_+                              return (b, p1, p2)+              res <- allSat $ mapM (const genAct) [1..n] >>= return . isValid+              cnt <- displayModels disp res+              if cnt == 0 then return False+                          else do putStrLn $ "Found: " ++ show cnt ++ " solution" ++ plu cnt ++ " with " ++ show n ++ " move" ++ plu n ++ "."+                                  return True+  where plu v = if v == 1 then "" else "s"+        disp :: Int -> [(Bool, U2Member, U2Member)] -> IO ()+        disp i ss+         | lss /= n = error $ "Expected " ++ show n ++ " results; got: " ++ show lss+         | True     = do putStrLn $ "Solution #" ++ show i ++ ": "+                         go False 0 ss+                         return ()+         where lss  = length ss+               go _ t []                   = putStrLn $ "Total time: " ++ show t+               go l t ((True, a, _):rest)  = do putStrLn $ sh2 t ++ shL l ++ show a+                                                go (not l) (t + ctime a) rest+               go l t ((False, a, b):rest) = do putStrLn $ sh2 t ++ shL l ++ show a ++ ", " ++ show b+                                                go (not l) (t + ctime a `max` ctime b) rest+               ctime = fromJust . unliteral . crossTime . fromIntegral . fromEnum+               sh2 t = let s = show t in if length s < 2 then ' ' : s else s+               shL False = " --> "+               shL True  = " <-- "++-- | Solve the U2-bridge crossing puzzle, starting by testing solutions with+-- increasing number of steps, until we find one. We have:+--+-- >>> solveU2+-- Checking for solutions with 1 move.+-- Checking for solutions with 2 moves.+-- Checking for solutions with 3 moves.+-- Checking for solutions with 4 moves.+-- Checking for solutions with 5 moves.+-- Solution #1: +--  0 --> Edge, Bono+--  2 <-- Edge+--  4 --> Larry, Adam+-- 14 <-- Bono+-- 15 --> Edge, Bono+-- Total time: 17+-- Solution #2: +--  0 --> Edge, Bono+--  2 <-- Bono+--  3 --> Larry, Adam+-- 13 <-- Edge+-- 15 --> Edge, Bono+-- Total time: 17+-- Found: 2 solutions with 5 moves.+--+-- Finding the all 2 possible solutions to the puzzle.+solveU2 :: IO ()+solveU2 = go 1+ where go i = do p <- solveN i+                 if p then return () else go (i+1)
+ Temp/sbv-0.9.18/Data/SBV/Examples/Uninterpreted/AUF.hs view
@@ -0,0 +1,85 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Uninterpreted.AUF+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Formalizes and proves the following theorem, about arithmetic,+-- uninterpreted functions, and arrays. (For reference, see <http://research.microsoft.com/en-us/um/redmond/projects/z3/fmcad06-slides.pdf>+-- slide number 24):+--+-- @+--    x + 2 = y  implies  f (read (write (a, x, 3), y - 2)) = f (y - x + 1)+-- @+--+-- We interpret the types as follows (other interpretations certainly possible):+--+--    [/x/] 'SWord32' (32-bit unsigned address)+--+--    [/y/] 'SWord32' (32-bit unsigned address)+--+--    [/a/] An array, indexed by 32-bit addresses, returning 32-bit unsigned integers+--+--    [/f/] An uninterpreted function of type @'SWord32' -> 'SWord64'@+--+-- The function @read@ and @write@ are usual array operations.+-----------------------------------------------------------------------------++module Data.SBV.Examples.Uninterpreted.AUF where++import Data.SBV++--------------------------------------------------------------+-- * Model using functional arrays+--------------------------------------------------------------++-- | The array type, takes symbolic 32-bit unsigned indexes+-- and stores 32-bit unsigned symbolic values. These are+-- functional arrays where reading before writing a cell+-- throws an exception.+type A = SFunArray Word32 Word32++-- | Uninterpreted function in the theorem+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))+              .== f (y - x + 1)++-- | Prints Q.E.D. when run, as expected+--+-- >>> proveThm1+-- Q.E.D.+proveThm1 :: IO ()+proveThm1 = print =<< prove thm1++--------------------------------------------------------------+-- * Model using SMT arrays+--------------------------------------------------------------++-- | This version directly uses SMT-arrays and hence does not need an initializer.+-- Reading an element before writing to it returns an arbitrary value.+type B = SArray Word32 Word32++-- | Same as 'thm1', except we don't need an initializer with the 'SArray' model.+thm2 :: SWord32 -> SWord32 -> B -> SBool+thm2 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:+--+-- >>> proveThm2+-- Q.E.D.+proveThm2 :: IO ()+proveThm2 = print =<< prove thm2
+ Temp/sbv-0.9.18/Data/SBV/Examples/Uninterpreted/Function.hs view
@@ -0,0 +1,44 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Uninterpreted.Function+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Demonstrates function counter-examples+-----------------------------------------------------------------------------++module Data.SBV.Examples.Uninterpreted.Function where++import Data.SBV++-- | An uninterpreted function+f :: SWord8 -> SWord8 -> SWord16+f = uninterpret "f"++-- | Asserts that @f x z == f (y+2) z@ whenever @x == y+2@. Naturally correct:+--+-- >>> prove thmGood+-- Q.E.D.+thmGood :: SWord8 -> SWord8 -> SWord8 -> SBool+thmGood x y z = x .== y+2 ==> f x z .== f (y + 2) z++-- | Asserts that @f@ is commutative; which is not necessarily true!+-- Indeed, the SMT solver (Yices in this case) returns a counter-example+-- function that is not commutative. We have:+--+--+-- >>> prove $ forAll ["x", "y"] thmBad+-- Falsifiable. Counter-example:+--   x = 0 :: SWord8+--   y = 128 :: SWord8+--   -- uninterpreted: f+--        f 128 0 = 32768+--        f _   _ = 0+--+-- Note how the counterexample function @f@ returned by Yices violates commutativity;+-- thus providing evidence that the asserted theorem is not valid.+thmBad :: SWord8 -> SWord8 -> SBool+thmBad x y = f x y .== f y x
+ Temp/sbv-0.9.18/Data/SBV/Examples/Uninterpreted/Uninterpreted.hs view
@@ -0,0 +1,30 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.Uninterpreted.Uninterpreted+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Testing uninterpreted functions+-----------------------------------------------------------------------------++module Data.SBV.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
+ Temp/sbv-0.9.18/Data/SBV/Internals.hs view
@@ -0,0 +1,40 @@+---------------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Internals+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Low level functions to access the SBV infrastructure, for developers who+-- want to build further tools on top of SBV. End-users of the library+-- should not need to use this module.+---------------------------------------------------------------------------------++module Data.SBV.Internals (+   -- * Running symbolic programs /manually/+    Result, runSymbolic+    -- * Other internal structures useful for low-level programming+  , SBV(..), CW, mkConstCW, genFree, genFree_+  -- * Compilation to C+  , compileToC', compileToCLib', CgPgmBundle(..), CgPgmKind(..)+    -- * Integrating with the test framework+    -- $testFramework+  , module Data.SBV.Utils.SBVTest+  ) where++import Data.SBV.BitVectors.Data   (Result, runSymbolic, SBV(..), CW, mkConstCW)+import Data.SBV.BitVectors.Model  (genFree, genFree_)+import Data.SBV.Compilers.C       (compileToC', compileToCLib')+import Data.SBV.Compilers.CodeGen (CgPgmBundle(..), CgPgmKind(..))+import Data.SBV.Utils.SBVTest++{- $compileC+Lower level access to program bundles, for further processing of program bundles.+-}++{- $testFramework+Functionality needed for extending SBV's internal test-suite. Only for developers of further libraries on+top of SBV.+-}
+ Temp/sbv-0.9.18/Data/SBV/Provers/Prover.hs view
@@ -0,0 +1,352 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Provers.Prover+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Provable abstraction and the connection to SMT solvers+-----------------------------------------------------------------------------++{-# LANGUAGE TypeSynonymInstances #-}+{-# LANGUAGE FlexibleInstances #-}+{-# LANGUAGE OverlappingInstances #-}+{-# LANGUAGE PatternGuards #-}+{-# LANGUAGE BangPatterns #-}++module Data.SBV.Provers.Prover (+         SMTSolver(..), SMTConfig(..), Predicate, Provable(..)+       , ThmResult(..), SatResult(..), AllSatResult(..), SMTResult(..)+       , isSatisfiable, isTheorem+       , isSatisfiableWithin, isTheoremWithin+       , numberOfModels+       , Equality(..)+       , prove, proveWith+       , sat, satWith+       , allSat, allSatWith+       , SatModel(..), getModel, displayModels+       , defaultSMTCfg, verboseSMTCfg, timingSMTCfg, verboseTimingSMTCfg+       , Yices.yices+       , timeout+       , compileToSMTLib+       ) where++import Control.Monad                  (when)+import Control.Concurrent             (forkIO)+import Control.Concurrent.Chan.Strict (newChan, writeChan, getChanContents)+import Data.Maybe                     (fromJust, isJust, catMaybes)+import System.Time                    (getClockTime)++import Data.SBV.BitVectors.Data+import Data.SBV.BitVectors.Model+import Data.SBV.SMT.SMT+import Data.SBV.SMT.SMTLib+import qualified Data.SBV.Provers.Yices as Yices+import Data.SBV.Utils.TDiff++-- | Default configuration for the SMT solver. Non-verbose, non-timing, prints results in base 10, and uses+-- the Yices SMT solver.+defaultSMTCfg :: SMTConfig+defaultSMTCfg = SMTConfig {verbose = False, timing  = False, printBase = 10, solver = Yices.yices}++-- | Same as 'defaultSMTCfg', except verbose+verboseSMTCfg :: SMTConfig+verboseSMTCfg = defaultSMTCfg {verbose=True}++-- | Same as 'defaultSMTCfg', except prints timing info+timingSMTCfg :: SMTConfig+timingSMTCfg  = defaultSMTCfg {timing=True}++-- | Same as 'defaultSMTCfg', except both verbose and timing info+verboseTimingSMTCfg :: SMTConfig+verboseTimingSMTCfg = timingSMTCfg {verbose=True}++-- We might need a better system if we add more backend solvers+-- | Adds a time out of @n@ seconds to a given solver configuration+timeout :: Int -> SMTConfig -> SMTConfig+timeout n s+ | nm == name Yices.yices = s{solver = Yices.timeout n (solver s)}+ | True                   = error $ "SBV.Prover.timeout: Solver " ++ show nm ++ " does not support time-outs"+ where nm = name (solver s)++-- | 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 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 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 free 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++instance Provable Predicate where+  forAll_  = id+  forAll _ = id++instance Provable SBool where+  forAll_  = return+  forAll _ = 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)+-}++-- Functions+instance (SymWord a, Provable p) => Provable (SBV a -> p) where+  forAll_       k = free_  >>= \a -> forAll_   $ k a+  forAll (s:ss) k = free s >>= \a -> forAll ss $ k a+  forAll []     k = forAll_ k++-- Arrays (memory)+instance (HasSignAndSize a, HasSignAndSize b, SymArray array, Provable p) => Provable (array a b -> p) where+  forAll_       k = newArray_  Nothing >>= \a -> forAll_   $ k a+  forAll (s:ss) k = newArray s Nothing >>= \a -> forAll ss $ k a+  forAll []     k = forAll_ k++-- 2 Tuple+instance (SymWord a, SymWord b, Provable p) => Provable ((SBV a, SBV b) -> p) where+  forAll_       k = free_  >>= \a -> forAll_   $ \b -> k (a, b)+  forAll (s:ss) k = free s >>= \a -> forAll ss $ \b -> k (a, b)+  forAll []     k = forAll_ k++-- 3 Tuple+instance (SymWord a, SymWord b, SymWord c, Provable p) => Provable ((SBV a, SBV b, SBV c) -> p) where+  forAll_       k = free_  >>= \a -> forAll_   $ \b c -> k (a, b, c)+  forAll (s:ss) k = free s >>= \a -> forAll ss $ \b c -> k (a, b, c)+  forAll []     k = forAll_ 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 = free_  >>= \a -> forAll_   $ \b c d -> k (a, b, c, d)+  forAll (s:ss) k = free s >>= \a -> forAll ss $ \b c d -> k (a, b, c, d)+  forAll []     k = forAll_ 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 = free_  >>= \a -> forAll_   $ \b c d e -> k (a, b, c, d, e)+  forAll (s:ss) k = free s >>= \a -> forAll ss $ \b c d e -> k (a, b, c, d, e)+  forAll []     k = forAll_ 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 = free_  >>= \a -> forAll_   $ \b c d e f -> k (a, b, c, d, e, f)+  forAll (s:ss) k = free s >>= \a -> forAll ss $ \b c d e f -> k (a, b, c, d, e, f)+  forAll []     k = forAll_ 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 = free_  >>= \a -> forAll_   $ \b c d e f g -> k (a, b, c, d, e, f, g)+  forAll (s:ss) k = free s >>= \a -> forAll ss $ \b c d e f g -> k (a, b, c, d, e, f, g)+  forAll []     k = forAll_ 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++-- Decision procedures (with optional timeout)+checkTheorem :: Provable a => Maybe Int -> a -> IO (Maybe Bool)+checkTheorem mbTo p = do r <- pr 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+   where pr = maybe prove (\i -> proveWith (timeout i defaultSMTCfg)) mbTo++checkSatisfiable :: Provable a => Maybe Int -> a -> IO (Maybe Bool)+checkSatisfiable mbTo p = do r <- s p+                             case r of+                               SatResult (Satisfiable _ _) -> return $ Just True+                               SatResult (Unsatisfiable _) -> return $ Just False+                               SatResult (TimeOut _)       -> return Nothing+                               _                           -> error $ "SBV.isSatisfiable: Received: " ++ show r+   where s = maybe sat (\i -> satWith (timeout i defaultSMTCfg)) mbTo++-- | Checks theoremhood within the given time limit of @i@ seconds.+-- Returns @Nothing@ if times out, or the result wrapped in a @Just@ otherwise.+isTheoremWithin :: Provable a => Int -> a -> IO (Maybe Bool)+isTheoremWithin i = checkTheorem (Just i)++-- | Checks satisfiability within the given time limit of @i@ seconds.+-- Returns @Nothing@ if times out, or the result wrapped in a @Just@ otherwise.+isSatisfiableWithin :: Provable a => Int -> a -> IO (Maybe Bool)+isSatisfiableWithin i = checkSatisfiable (Just i)++-- | Checks theoremhood+isTheorem :: Provable a => a -> IO Bool+isTheorem p = fromJust `fmap` checkTheorem Nothing p++-- | Checks satisfiability+isSatisfiable :: Provable a => a -> IO Bool+isSatisfiable p = fromJust `fmap` checkSatisfiable Nothing p++-- | Returns the number of models that satisfy the predicate, as it would+-- be returned by 'allSat'. Note that the number of models is always a+-- finite number, and hence this will always return a result. Of course,+-- computing it might take quite long, as it literally generates and counts+-- the number of satisfying models.+numberOfModels :: Provable a => a -> IO Int+numberOfModels p = do AllSatResult rs <- allSat p+                      return $ sum $ map walk rs+  where walk (Satisfiable{}) = 1+        -- shouldn't happen, but just in case+        walk r               = error $ "numberOfModels: Unexpected result from an allSat check: " ++ show (AllSatResult [r])++-- | 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.+compileToSMTLib :: Provable a => a -> IO String+compileToSMTLib a = do+        t <- getClockTime+        let comments = ["Created on " ++ show t]+        (_, _, smtLibPgm) <- generateTrace defaultSMTCfg False comments a+        return $ show smtLibPgm ++ "\n"++-- | Proves the predicate using the given SMT-solver+proveWith :: Provable a => SMTConfig -> a -> IO ThmResult+proveWith config a = generateTrace config False [] a >>= callSolver [] "Checking Theoremhood.." ThmResult config++-- | Find a satisfying assignment using the given SMT-solver+satWith :: Provable a => SMTConfig -> a -> IO SatResult+satWith config a = generateTrace config True [] a >>= callSolver [] "Checking Satisfiability.." SatResult config++-- | Find all satisfying assignments using the given SMT-solver+allSatWith :: Provable a => SMTConfig -> a -> IO AllSatResult+allSatWith config p = do when (verbose config) $ putStrLn  "** Checking Satisfiability, all solutions.."+                         sbvPgm <- generateTrace config True [] p+                         resChan <- newChan+                         let add  = writeChan resChan . Just+                             stop = writeChan resChan Nothing+                             final r = add r >> stop+                             -- only fork if non-verbose.. otherwise stdout gets garbled+                             fork io = if verbose config then io else forkIO io >> return ()+                         fork $ go sbvPgm add stop final (1::Int) []+                         results <- getChanContents resChan+                         return $ AllSatResult $ map fromJust $ takeWhile isJust results+  where go sbvPgm add stop final = loop+          where loop !n nonEqConsts = do+                  SatResult r <- callSolver nonEqConsts ("Looking for solution " ++ show n) SatResult config sbvPgm+                  case r of+                    Satisfiable _ (SMTModel [] _ _) -> final r+                    Unknown _ (SMTModel [] _ _)     -> final r+                    ProofError _ _                  -> final r+                    TimeOut _                       -> stop+                    Unsatisfiable _                 -> stop+                    Satisfiable _ model             -> add r >> loop (n+1) (modelAssocs model : nonEqConsts)+                    Unknown     _ model             -> add r >> loop (n+1) (modelAssocs model : nonEqConsts)++callSolver :: [[(String, CW)]] -> String -> (SMTResult -> b) -> SMTConfig -> ([NamedSymVar], [(String, UnintKind)], SMTLibPgm) -> IO b+callSolver nonEqConstraints checkMsg wrap config (inps, modelMap, smtLibPgm) = do+        let msg = when (verbose config) . putStrLn . ("** " ++)+        msg checkMsg+        let finalPgm = addNonEqConstraints nonEqConstraints smtLibPgm+        msg $ "Generated SMTLib program:\n" ++ finalPgm+        smtAnswer <- engine (solver config) config inps modelMap finalPgm+        msg "Done.."+        return $ wrap smtAnswer++generateTrace :: Provable a => SMTConfig -> Bool -> [String] -> a -> IO ([NamedSymVar], [(String, UnintKind)], SMTLibPgm)+generateTrace config isSat comments predicate = do+        let msg = when (verbose config) . putStrLn . ("** " ++)+            isTiming = timing config+        msg "Starting symbolic simulation.."+        res <- timeIf isTiming "problem construction" $ runSymbolic $ forAll_ predicate >>= output+        msg $ "Generated symbolic trace:\n" ++ show res+        msg "Translating to SMT-Lib.."+        case res of+          Result is consts tbls arrs uis axs pgm [o@(SW (False, 1) _)] | sizeOf o == 1 ->+             timeIf isTiming "translation" $ let uiMap = catMaybes (map arrayUIKind arrs) ++ map unintFnUIKind uis+                                             in return (is, uiMap, toSMTLib isSat comments is consts tbls arrs uis axs pgm o)+          _ -> error $ "SBVProver.generateTrace: Impossible happened:\n" ++ show res++-- | Equality as a proof method. Allows for+-- very concise construction of equivalence proofs, which is very typical in+-- bit-precise proofs.+infix 4 ===+class Equality a where+  (===) :: a -> a -> IO ThmResult++instance (SymWord a, EqSymbolic z) => Equality (SBV a -> z) where+  k === l = prove $ \a -> k a .== l a++instance (SymWord a, SymWord b, EqSymbolic z) => Equality (SBV a -> SBV b -> z) where+  k === l = prove $ \a b -> k a b .== l a b++instance (SymWord a, SymWord b, EqSymbolic z) => Equality ((SBV a, SBV b) -> z) where+  k === l = prove $ \a b -> k (a, b) .== l (a, b)++instance (SymWord a, SymWord b, SymWord c, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> z) where+  k === l = prove $ \a b c -> k a b c .== l a b c++instance (SymWord a, SymWord b, SymWord c, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c) -> z) where+  k === l = prove $ \a b c -> k (a, b, c) .== l (a, b, c)++instance (SymWord a, SymWord b, SymWord c, SymWord d, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> z) where+  k === l = prove $ \a b c d -> k a b c d .== l a b c d++instance (SymWord a, SymWord b, SymWord c, SymWord d, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d) -> z) where+  k === l = prove $ \a b c d -> k (a, b, c, d) .== l (a, b, c, d)++instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> z) where+  k === l = prove $ \a b c d e -> k a b c d e .== l a b c d e++instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d, SBV e) -> z) where+  k === l = prove $ \a b c d e -> k (a, b, c, d, e) .== l (a, b, c, d, e)++instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, EqSymbolic z) => Equality (SBV a -> SBV b -> SBV c -> SBV d -> SBV e -> SBV f -> z) where+  k === l = prove $ \a b c d e f -> k a b c d e f .== l a b c d e f++instance (SymWord a, SymWord b, SymWord c, SymWord d, SymWord e, SymWord f, EqSymbolic z) => Equality ((SBV a, SBV b, SBV c, SBV d, SBV e, SBV f) -> z) where+  k === l = prove $ \a b c d e f -> k (a, b, c, d, e, f) .== l (a, b, c, d, e, f)++instance (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++instance (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)
+ Temp/sbv-0.9.18/Data/SBV/Provers/SExpr.hs view
@@ -0,0 +1,52 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Provers.SExpr+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Parsing of S-expressions (mainly used for parsing Yices output)+-----------------------------------------------------------------------------++module Data.SBV.Provers.SExpr where++import Control.Monad.Error ()             -- for Monad (Either String) instance+import Data.Char           (isDigit, ord)+import Numeric             (readInt, readDec)++data SExpr = S_Con String+           | S_Num Integer+           | S_App [SExpr]++parseSExpr :: String -> Either String SExpr+parseSExpr inp = do (sexp, []) <- parse inpToks+                    return sexp+  where inpToks = let cln ""          sofar = sofar+                      cln ('(':r)     sofar = cln r (" ( " ++ sofar)+                      cln (')':r)     sofar = cln r (" ) " ++ sofar)+                      cln (':':':':r) sofar = cln r (" :: " ++ sofar)+                      cln (c:r)       sofar = cln r (c:sofar)+                  in reverse (map reverse (words (cln 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 []+                              return (S_App 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 ('0':'b':r)       = mkNum $ readInt 2 (`elem` "01") (\c -> ord c - ord '0') r+        pTok ('b':'v':r)       = mkNum $ readDec (takeWhile (/= '[') r)+        pTok n | all isDigit n = mkNum $ readDec n+        pTok n                 = return $ S_Con $ n+        mkNum [(n, "")] = return $ S_Num n+        mkNum _         = die "cannot read number"
+ Temp/sbv-0.9.18/Data/SBV/Provers/Yices.hs view
@@ -0,0 +1,150 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Provers.Yices+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- The connection to the Yices SMT solver+-----------------------------------------------------------------------------++{-# LANGUAGE PatternGuards #-}++module Data.SBV.Provers.Yices(yices, timeout) where++import Data.Char          (isDigit)+import Data.List          (sortBy, isPrefixOf, intercalate, transpose, partition)+import Data.Maybe         (catMaybes, isJust, fromJust)+import System.Environment (getEnv)++import Data.SBV.BitVectors.Data+import Data.SBV.Provers.SExpr+import Data.SBV.SMT.SMT++-- | The description of the Yices SMT solver+-- The default executable is @\"yices\"@, which must be in your path. You can use the @SBV_YICES@ environment variable to point to the executable on your system.+-- The default options are @\"-m -f\"@, which is valid for Yices 2 series. You can use the @SBV_YICES_OPTIONS@ environment variable to override the options.+yices :: SMTSolver+yices = SMTSolver {+           name       = "Yices"+         , executable = "yices"+         -- , options    = ["-tc", "-smt", "-e"]   -- For Yices1+         , options    = ["-m", "-f"]  -- For Yices2+         , engine     = \cfg inps modelMap pgm -> do+                                execName <-                getEnv "SBV_YICES"           `catch` (\_ -> return (executable (solver cfg)))+                                execOpts <- (words `fmap` (getEnv "SBV_YICES_OPTIONS")) `catch` (\_ -> return (options (solver cfg)))+                                let cfg' = cfg { solver = (solver cfg) {executable = execName, options = execOpts} }+                                standardSolver cfg' pgm (ProofError cfg) (interpret cfg inps modelMap)+         }++timeout :: Int -> SMTSolver -> SMTSolver+timeout n s+  | n <= 0 = error $ "Yices.timeout value should be > 0, received: " ++ show n+  | True   = s{options = options s ++ ["-t", show n]}++sortByNodeId :: [(Int, a)] -> [(Int, a)]+sortByNodeId = sortBy (\(x, _) (y, _) -> compare x y)++interpret :: SMTConfig -> [NamedSymVar] -> [(String, UnintKind)] -> [String] -> SMTResult+interpret cfg _    _        ("unsat":_)      = Unsatisfiable cfg+interpret cfg inps modelMap ("unknown":rest) = Unknown       cfg  $ extractMap inps modelMap rest+interpret cfg inps modelMap ("sat":rest)     = Satisfiable   cfg  $ extractMap inps modelMap rest+interpret cfg _    _        ("timeout":_)    = TimeOut       cfg+interpret cfg _    _        ls               = ProofError    cfg  $ ls++extractMap :: [NamedSymVar] -> [(String, UnintKind)] -> [String] -> SMTModel+extractMap inps modelMap solverLines =+   SMTModel { modelAssocs    = map (\(_, y) -> y) $ sortByNodeId $ concatMap (getCounterExample inps) modelLines+            , modelUninterps = [(n, ls) | (UFun _ n, ls) <- uis]+            , modelArrays    = [(n, ls) | (UArr _ n, ls) <- uis]+            }+  where (modelLines, unintLines) = moveConstUIs $ break ("--- " `isPrefixOf`) solverLines+        uis = extractUnints modelMap unintLines++-- another crude hack+moveConstUIs :: ([String], [String]) -> ([String], [String])+moveConstUIs (pre, post) = (pre', concatMap mkDecl extras ++ post)+  where (extras, pre') = partition ("(= uninterpreted_" `isPrefixOf`) pre+        mkDecl s = ["--- " ++ takeWhile (/= ' ') (drop 3 s) ++ " ---", s]++getCounterExample :: [NamedSymVar] -> String -> [(Int, (String, CW))]+getCounterExample inps line = either err extract (parseSExpr line)+  where err r =  error $  "*** Failed to parse Yices model output from: "+                       ++ "*** " ++ show line ++ "\n"+                       ++ "*** Reason: " ++ r ++ "\n"+        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.Yices: Cannot uniquely identify value for "+                                                  ++ 's':v ++ " in "  ++ show matches+        isInput _       = Nothing+        extract (S_App [S_Con "=", S_Con v, S_Num i]) | Just (n, s, nm) <- isInput v = [(n, (nm, mkConstCW (hasSign s, sizeOf s) i))]+        extract (S_App [S_Con "=", S_Num i, S_Con v]) | Just (n, s, nm) <- isInput v = [(n, (nm, mkConstCW (hasSign s, sizeOf s) i))]+        extract _                                                                    = []++extractUnints :: [(String, UnintKind)] -> [String] -> [(UnintKind, [String])]+extractUnints modelMap = catMaybes . map (extractUnint modelMap) . chunks+  where chunks []     = []+        chunks (x:xs) = let (f, r) = span (not . ("---" `isPrefixOf`)) xs in (x:f) : chunks r++-- Parsing the Yices output is done extremely crudely and designed+-- mostly by observation of Yices output. Likely to have bugs and+-- brittle as Yices evolves. We really need an SMT-Lib2 like interface.+extractUnint :: [(String, UnintKind)] -> [String] -> Maybe (UnintKind, [String])+extractUnint _    []           = Nothing+extractUnint mmap (tag : rest)+  | null tag'                  = Nothing+  | not (isJust mbKnd)         = Nothing+  | True                       = mapM (getUIVal knd) rest >>= \xs -> return (knd, format knd xs)+  where mbKnd | "--- uninterpreted_" `isPrefixOf` tag = uf `lookup` mmap+              | True                                  = af `lookup` mmap+        knd = fromJust mbKnd+        tag' = dropWhile (/= '_') tag+        f    = takeWhile (/= ' ') (tail tag')+        uf   = f+        af   = "array_" ++ f++getUIVal :: UnintKind -> String -> Maybe (String, [String], String)+getUIVal knd s+  | "default: " `isPrefixOf` s+  = getDefaultVal knd (dropWhile (/= ' ') s)+  | True+  = case parseSExpr s of+       Right (S_App [S_Con "=", (S_App (S_Con _ : args)), S_Num i]) -> getCallVal knd args i+       Right (S_App [S_Con "=", S_Con _, S_Num i])                  -> getCallVal knd []   i+       _ -> Nothing++getDefaultVal :: UnintKind -> String -> Maybe (String, [String], String)+getDefaultVal knd n = case parseSExpr n of+                        Right (S_Num i) -> Just $ showDefault knd (show i)+                        _               -> Nothing++getCallVal :: UnintKind -> [SExpr] -> Integer -> Maybe (String, [String], String)+getCallVal knd args res = mapM getArg args >>= \as -> return (showCall knd as (show res))++getArg :: SExpr -> Maybe String+getArg (S_Num i) = Just (show i)+getArg _         = Nothing++showDefault :: UnintKind -> String -> (String, [String], String)+showDefault (UFun cnt f) res = (f, replicate cnt "_", res)+showDefault (UArr cnt f) res = (f, replicate cnt "_", res)++showCall :: UnintKind -> [String] -> String -> (String, [String], String)+showCall (UFun _ f) as res = (f, as, res)+showCall (UArr _ f) as res = (f, as, res)++format :: UnintKind -> [(String, [String], String)] -> [String]+format (UFun{}) eqns = fmtFun eqns+format (UArr{}) eqns = let fmt (f, as, r) = f ++ "[" ++ intercalate ", " as ++ "] = " ++ r in map fmt eqns++fmtFun :: [(String, [String], String)] -> [String]+fmtFun ls = map fmt ls+  where fmt (f, as, r) = f ++ " " ++ unwords (map align (zip as (lens ++ repeat 0))) ++ " = " ++ r+        lens           = map (maximum . (0:)) $ map (map length) $ transpose [as | (_, as, _) <- ls]+        align (s, i)   = take (i `max` length s) (s ++ repeat ' ')
+ Temp/sbv-0.9.18/Data/SBV/SMT/SMT.hs view
@@ -0,0 +1,308 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.SMT.SMT+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Abstraction of SMT solvers+-----------------------------------------------------------------------------++{-# LANGUAGE ScopedTypeVariables #-}++module Data.SBV.SMT.SMT where++import Control.DeepSeq  (NFData(..))+import Control.Monad    (when, zipWithM)+import Data.Char        (isSpace)+import Data.Int         (Int8, Int16, Int32, Int64)+import Data.List        (intercalate)+import Data.Word        (Word8, Word16, Word32, Word64)+import System.Directory (findExecutable)+import System.Process   (readProcessWithExitCode)+import System.Exit      (ExitCode(..))++import Data.SBV.BitVectors.Data+import Data.SBV.BitVectors.PrettyNum+import Data.SBV.Utils.TDiff++-- | Solver configuration+data SMTConfig = SMTConfig {+         verbose   :: Bool      -- ^ Debug mode+       , timing    :: Bool      -- ^ Print timing information on how long different phases took (construction, solving, etc.)+       , printBase :: Int       -- ^ Print literals in this base+       , solver    :: SMTSolver -- ^ The actual SMT solver+       }++type SMTEngine = SMTConfig -> [NamedSymVar] -> [(String, UnintKind)] -> String -> IO SMTResult++-- | An SMT solver+data SMTSolver = SMTSolver {+         name       :: String    -- ^ Printable name of the solver+       , 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+       }++-- | A model, as returned by a solver+data SMTModel = SMTModel {+        modelAssocs    :: [(String, CW)]+     ,  modelArrays    :: [(String, [String])]  -- very crude!+     ,  modelUninterps :: [(String, [String])]  -- very crude!+     }+     deriving Show++-- | The result of an SMT solver call. Each constructor is tagged with+-- the 'SMTConfig' that created it so that further tools can inspect it+-- 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            -- ^ Unsatisfiable+               | Satisfiable   SMTConfig SMTModel   -- ^ Satisfiable with model+               | 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)++resultConfig :: SMTResult -> SMTConfig+resultConfig (Unsatisfiable c) = c+resultConfig (Satisfiable c _) = c+resultConfig (Unknown c _)     = c+resultConfig (ProofError c _)  = c+resultConfig (TimeOut c)       = c++instance NFData SMTResult where+  rnf (Unsatisfiable _)   = ()+  rnf (Satisfiable _ xs)  = rnf xs `seq` ()+  rnf (Unknown _ xs)      = rnf xs `seq` ()+  rnf (ProofError _ xs)   = rnf xs `seq` ()+  rnf (TimeOut _)         = ()++instance NFData SMTModel where+  rnf (SMTModel assocs unints uarrs) = rnf assocs `seq` rnf unints `seq` rnf uarrs `seq` ()++-- | A 'prove' call results in a 'ThmResult'+newtype ThmResult    = ThmResult    SMTResult++-- | 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++-- | An 'allSat' call results in a 'AllSatResult'+newtype AllSatResult = AllSatResult [SMTResult]++instance Show ThmResult where+  show (ThmResult r) = showSMTResult "Q.E.D."+                                     "Unknown"     "Unknown. Potential counter-example:\n"+                                     "Falsifiable" "Falsifiable. Counter-example:\n" r++instance Show SatResult where+  show (SatResult r) = showSMTResult "Unsatisfiable"+                                     "Unknown"     "Unknown. Potential model:\n"+                                     "Satisfiable" "Satisfiable. Model:\n" r+++instance Show AllSatResult where+  show (AllSatResult [])  =  "No solutions found"+  show (AllSatResult [s]) =  "Only one solution found:\n" ++ shUnique s+        where shUnique = showSMTResult "Unsatisfiable"+                                       ("Unknown (No assignment to variables returned)") "Unknown. Potential assignment:\n" "" ""+  show (AllSatResult ss)  =  "Multiple solutions found:\n"      -- shouldn't display how-many; would be too slow/leak-space to compute everything..+                          ++ unlines (zipWith sh [(1::Int)..] ss)+                          ++ "Done."+        where sh i = showSMTResult "Unsatisfiable"+                                   ("Unknown #" ++ show i ++ "(No assignment to variables returned)") "Unknown. Potential assignment:\n"+                                   ("Solution #" ++ show i ++ " (No assignment to variables returned)") ("Solution #" ++ show i ++ ":\n")++-- | Instances of 'SatModel' can be automatically extracted from models returned by the+-- solvers. The idea is that the sbv infrastructure provides a stream of 'CW''s (constant-words)+-- coming from the solver, and the type @a@ is interpreted based on these constants. Many typical+-- instances are already provided, so new instances can be declared with relative ease.+--+-- Minimum complete definition: 'parseCWs'+class SatModel a where+  -- | Given a sequence of constant-words, extract one instance of the type @a@, returning+  -- the remaining elements untouched. If the next element is not what's expected for this+  -- type you should return 'Nothing'+  parseCWs  :: [CW] -> Maybe (a, [CW])+  -- | Given a parsed model instance, transform it using @f@, and return the result.+  -- The default definition for this method should be sufficient in most use cases.+  cvtModel  :: (a -> Maybe b) -> Maybe (a, [CW]) -> Maybe (b, [CW])+  cvtModel f x = x >>= \(a, r) -> f a >>= \b -> return (b, r)++genParse :: Integral a => (Bool,Size) -> [CW] -> Maybe (a,[CW])+genParse (signed,size) (x:r)+  | hasSign x == signed && sizeOf x == size = Just (fromIntegral (cwVal x),r)+genParse _ _ = Nothing++instance SatModel Bool where+  parseCWs xs = do (x,r) <- genParse (False,1) xs+                   return ((x :: Integer) /= 0, r)++instance SatModel Word8 where+  parseCWs = genParse (False,8)++instance SatModel Int8 where+  parseCWs = genParse (True,8)++instance SatModel Word16 where+  parseCWs = genParse (False,16)++instance SatModel Int16 where+  parseCWs = genParse (True,16)++instance SatModel Word32 where+  parseCWs = genParse (False,32)++instance SatModel Int32 where+  parseCWs = genParse (True,32)++instance SatModel Word64 where+  parseCWs = genParse (False,64)++instance SatModel Int64 where+  parseCWs = genParse (True,64)++-- when reading a list; go as long as we can (maximal-munch)+-- note that this never fails..+instance SatModel a => SatModel [a] where+  parseCWs [] = Just ([], [])+  parseCWs xs = case parseCWs xs of+                  Just (a, ys) -> case parseCWs ys of+                                    Just (as, zs) -> Just (a:as, zs)+                                    Nothing       -> Just ([], ys)+                  Nothing     -> Just ([], xs)++instance (SatModel a, SatModel b) => SatModel (a, b) where+  parseCWs as = do (a, bs) <- parseCWs as+                   (b, cs) <- parseCWs bs+                   return ((a, b), cs)++instance (SatModel a, SatModel b, SatModel c) => SatModel (a, b, c) where+  parseCWs as = do (a,      bs) <- parseCWs as+                   ((b, c), ds) <- parseCWs bs+                   return ((a, b, c), ds)++instance (SatModel a, SatModel b, SatModel c, SatModel d) => SatModel (a, b, c, d) where+  parseCWs as = do (a,         bs) <- parseCWs as+                   ((b, c, d), es) <- parseCWs bs+                   return ((a, b, c, d), es)++instance (SatModel a, SatModel b, SatModel c, SatModel d, SatModel e) => SatModel (a, b, c, d, e) where+  parseCWs as = do (a, bs)            <- parseCWs as+                   ((b, c, d, e), fs) <- parseCWs bs+                   return ((a, b, c, d, e), fs)++instance (SatModel a, SatModel b, SatModel c, SatModel d, SatModel e, SatModel f) => SatModel (a, b, c, d, e, f) where+  parseCWs as = do (a, bs)               <- parseCWs as+                   ((b, c, d, e, f), gs) <- parseCWs bs+                   return ((a, b, c, d, e, f), gs)++instance (SatModel a, SatModel b, SatModel c, SatModel d, SatModel e, SatModel f, SatModel g) => SatModel (a, b, c, d, e, f, g) where+  parseCWs as = do (a, bs)                  <- parseCWs as+                   ((b, c, d, e, f, g), hs) <- parseCWs bs+                   return ((a, b, c, d, e, f, g), hs)++-- | Given an 'SMTResult', extract an arbitrarily typed model from it, given a 'SatModel' instance+getModel :: SatModel a => SMTResult -> a+getModel (Unsatisfiable _) = error "SatModel.getModel: Unsatisfiable result"+getModel (Unknown _ _)     = error "Impossible! Backend solver returned unknown for Bit-vector problem!"+getModel (ProofError _ s)  = error $ unlines $ "An error happened: " : s+getModel (TimeOut _)       = error $ "Timeout"+getModel (Satisfiable _ 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++-- | 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.+displayModels :: SatModel a => (Int -> a -> IO ()) -> AllSatResult -> IO Int+displayModels disp (AllSatResult ms) = do+    inds <- zipWithM display (map getModel ms) [(1::Int)..]+    return $ last (0:inds)+  where display r i = disp i r >> return i++showSMTResult :: String -> String -> String -> String -> String -> SMTResult -> String+showSMTResult unsatMsg unkMsg unkMsgModel satMsg satMsgModel result = case result of+  Unsatisfiable _                   -> unsatMsg+  Satisfiable _ (SMTModel [] [] []) -> satMsg+  Satisfiable _ m                   -> satMsgModel ++ showModel cfg m+  Unknown _ (SMTModel [] [] [])     -> unkMsg+  Unknown _ m                       -> unkMsgModel ++ showModel cfg m+  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++showModel :: SMTConfig -> SMTModel -> String+showModel cfg m = intercalate "\n" (map (shM cfg) assocs ++ concatMap shUI uninterps ++ concatMap shUA arrs)+  where assocs    = modelAssocs m+        uninterps = modelUninterps m+        arrs      = modelArrays m++shCW :: SMTConfig -> CW -> String+shCW cfg v = sh (printBase cfg) v+  where sh 2  = binS+        sh 10 = show+        sh 16 = hexS+        sh n  = \w -> show w ++ " -- Ignoring unsupported printBase " ++ show n ++ ", use 2, 10, or 16."++shM :: SMTConfig -> (String, CW) -> String+shM cfg (s, v) = "  " ++ s ++ " = " ++ shCW cfg v++-- very crude.. printing uninterpreted functions+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++-- very crude.. printing array values+shUA :: (String, [String]) -> [String]+shUA (f, cases) = ("  -- array: " ++ f) : map shC cases+  where shC s = "       " ++ s++pipeProcess :: String -> String -> [String] -> String -> IO (Either String [String])+pipeProcess nm execName opts script = do+        mbExecPath <- findExecutable execName+        case mbExecPath of+          Nothing -> return $ Left $ "Unable to locate executable for " ++ nm+                                   ++ "\nExecutable specified: " ++ show execName+          Just execPath -> do (ec, contents, errors) <- readProcessWithExitCode execPath opts script+                              case ec of+                                ExitSuccess  ->  if null errors+                                                 then return $ Right $ map clean (filter (not . null) (lines contents))+                                                 else return $ Left errors+                                ExitFailure n -> let errors' = if null (dropWhile isSpace errors)+                                                               then (if null (dropWhile isSpace contents)+                                                                     then "(No error message printed on stderr by the executable.)"+                                                                     else contents)+                                                               else errors+                                                 in return $ Left $  "Failed to complete the call to " ++ nm+                                                                  ++ "\nExecutable   : " ++ show execPath+                                                                  ++ "\nOptions      : " ++ unwords opts+                                                                  ++ "\nExit code    : " ++ show n+                                                                  ++ "\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  = take 78 $ repeat '='++standardSolver :: SMTConfig -> String -> ([String] -> a) -> ([String] -> a) -> IO a+standardSolver config script failure success = do+    let msg      = when (verbose config) . putStrLn . ("** " ++)+        smtSolver= solver config+        exec     = executable smtSolver+        opts     = options smtSolver+        isTiming = timing config+        nmSolver = name smtSolver+    msg $ "Calling: " ++ show (unwords (exec:opts))+    contents <- timeIf isTiming nmSolver $ pipeProcess nmSolver exec opts script+    msg $ nmSolver ++ " output:\n" ++ either id (intercalate "\n") contents+    case contents of+      Left e   -> return $ failure (lines e)+      Right xs -> return $ success xs
+ Temp/sbv-0.9.18/Data/SBV/SMT/SMTLib.hs view
@@ -0,0 +1,224 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.SMT.SMTLib+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Conversion of symbolic programs to SMTLib format+-----------------------------------------------------------------------------+{-# LANGUAGE PatternGuards #-}++module Data.SBV.SMT.SMTLib(SMTLibPgm, toSMTLib, addNonEqConstraints) where++import Control.DeepSeq              (NFData(..))+import qualified Data.Foldable as F (toList)+import Data.List                    (intercalate)++import Data.SBV.BitVectors.Data++newtype SMTLibPgm = SMTLibPgm ([(String, SW)], [String], [String])+instance NFData SMTLibPgm++instance Show SMTLibPgm where+  show (SMTLibPgm (_, pre, post)) = intercalate "\n" $ pre ++ post++addNonEqConstraints :: [[(String, CW)]] -> SMTLibPgm -> String+addNonEqConstraints nonEqConstraints (SMTLibPgm (aliasTable, pre, post)) = intercalate "\n" $+     pre+  ++ [ " ; --- refuted-models ---" ]+  ++ concatMap nonEqs (map (map intName) nonEqConstraints)+  ++ post+ where intName (s, c)+          | Just sw <- s `lookup` aliasTable = (show sw, c)+          | True                             = (s, c)++toSMTLib :: Bool                                        -- ^ is this a sat problem?+         -> [String]                                    -- ^ extra comments to place on top+         -> [(SW, String)]                              -- ^ inputs and aliasing names+         -> [(SW, CW)]                                  -- ^ constants+         -> [((Int, (Bool, Int), (Bool, Int)), [SW])]   -- ^ auto-generated tables+         -> [(Int, ArrayInfo)]                          -- ^ user specified arrays+         -> [(String, SBVType)]                         -- ^ uninterpreted functions/constants+         -> [(String, [String])]                        -- ^ user given axioms+         -> Pgm                                         -- ^ assignments+         -> SW                                          -- ^ output variable+         -> SMTLibPgm+toSMTLib isSat comments inps consts tbls arrs uis axs asgnsSeq out = SMTLibPgm (aliasTable, pre, post)+  where logic+         | null tbls && null arrs && null uis = "QF_BV"+         | True                               = "QF_AUFBV"+        pre =    [ "; Automatically generated by SBV. Do not edit." ]+              ++ map ("; " ++) comments+              ++ ["(benchmark sbv"+                 , " :logic " ++ logic+                 , " :status unknown"+                 , " ; --- inputs ---"+                 ]+              ++ map decl (map fst inps)+              ++ [ " ; --- declarations ---" ]+              ++ map (decl . fst) consts+              ++ map (decl . fst) asgns+              ++ [ " ; --- constants ---" ]+              ++ map cvtCnst consts+              ++ [ " ; --- tables ---" ]+              ++ concatMap mkTable tbls+              ++ [ " ; --- arrays ---" ]+              ++ concatMap declArray arrs+              ++ [ " ; --- uninterpreted constants ---" ]+              ++ concatMap declUI uis+              ++ [ " ; --- user given axioms ---" ]+              ++ map declAx axs+              ++ [ " ; --- assignments ---" ]+              ++ map cvtAsgn asgns+        post =    [ " ; --- formula ---" ]+               ++ [mkFormula isSat out]+               ++ [")"]+        aliasTable = map (\(x, y) -> (y, x)) inps+        asgns = F.toList asgnsSeq++-- TODO: Does this work for SMT-Lib when the index/element types are signed?+-- Currently we ignore the signedness of the arguments, as there appears to be no way+-- to capture that in SMT-Lib; and likely it does not matter. Would be good to check+-- explicitly though.+mkTable :: ((Int, (Bool, Int), (Bool, Int)), [SW]) -> [String]+mkTable ((i, (_, at), (_, rt)), elts) = (" :extrafuns ((" ++ t ++ " Array[" ++ show at ++ ":" ++ show rt ++ "]))") : zipWith mkElt elts [(0::Int)..]+  where t = "table" ++ show i+        mkElt x k = " :assumption (= (select " ++ t ++ " bv" ++ show k ++ "[" ++ show at ++ "]) " ++ show x ++ ")"++declArray :: (Int, ArrayInfo) -> [String]+declArray (i, (_, ((_, at), (_, rt)), ctx)) = adecl : ctxInfo+  where nm = "array_" ++ show i+        adecl = " :extrafuns ((" ++ nm ++ " Array[" ++ show at ++ ":" ++ show rt ++ "]))"+        ctxInfo = case ctx of+                    ArrayFree Nothing   -> []+                    ArrayFree (Just sw) -> declA sw+                    ArrayReset _ sw     -> declA sw+                    ArrayMutate j a b -> [" :assumption (= " ++ nm ++ " (store array_" ++ show j ++ " " ++ show a ++ " " ++ show b ++ "))"]+                    ArrayMerge  t j k -> [" :assumption (= " ++ nm ++ " (ite (= bv1[1] " ++ show t ++ ") array_" ++ show j ++ " array_" ++ show k ++ "))"]+        declA sw = let iv = nm ++ "_freeInitializer"+                   in [ " :extrafuns ((" ++ iv ++ " BitVec[" ++ show at ++ "]))"+                      , " :assumption (= (select " ++ nm ++ " " ++ iv ++ ") " ++ show sw ++ ")"+                      ]++declAx :: (String, [String]) -> String+declAx (nm, ls) = (" ;; -- user given axiom: " ++ nm ++ "\n   ") ++ intercalate "\n   " ls++declUI :: (String, SBVType) -> [String]+declUI (i, t) = [" :extrafuns ((uninterpreted_" ++ i ++ " " ++ cvtType t ++ "))"]++mkFormula :: Bool -> SW -> String+mkFormula isSat s+ | isSat = " :formula (= " ++ show s ++ " bv1[1])"+ | True  = " :formula (= " ++ show s ++ " bv0[1])"++nonEqs :: [(String, CW)] -> [String]+nonEqs []     =  []+nonEqs [sc]   =  [" :assumption " ++ nonEq sc]+nonEqs (sc:r) =  [" :assumption (or " ++ nonEq sc]+              ++ map (("                 " ++) . nonEq) r+              ++ ["             )"]++nonEq :: (String, CW) -> String+nonEq (s, c) = "(not (= " ++ s ++ " " ++ cvtCW c ++ "))"++-- SMTLib represents signed/unsigned quantities with the same type+decl :: SW -> String+decl s = " :extrafuns  ((" ++ show s ++ " BitVec[" ++ show (sizeOf s) ++ "]))"++cvtAsgn :: (SW, SBVExpr) -> String+cvtAsgn (s, e) = " :assumption (= " ++ show s ++ " " ++ cvtExp e ++ ")"++cvtCnst :: (SW, CW) -> String+cvtCnst (s, c) = " :assumption (= " ++ show s ++ " " ++ cvtCW c ++ ")"++cvtCW :: CW -> String+cvtCW x | not (hasSign x) = "bv" ++ show (cwVal x) ++ "[" ++ show (sizeOf x) ++ "]"+-- signed numbers (with 2's complement representation) is problematic+-- since there's no way to put a bvneg over a positive number to get minBound..+-- Hence, we punt and use binary notation in that particular case+cvtCW x | cwVal x == least = mkMinBound (sizeOf x)+  where least = negate (2 ^ sizeOf x)+cvtCW x = negIf (w < 0) $ "bv" ++ show (abs w) ++ "[" ++ show (sizeOf x) ++ "]"+  where w = cwVal x++negIf :: Bool -> String -> String+negIf True  a = "(bvneg " ++ a ++ ")"+negIf False a = a++-- anamoly at the 2's complement min value! Have to use binary notation here+-- as there is no positive value we can provide to make the bvneg work.. (see above)+mkMinBound :: Int -> String+mkMinBound i = "bv1" ++ take (i-1) (repeat '0') ++ "[" ++ show i ++ "]"++rot :: String -> Int -> SW -> String+rot o c x = "(" ++ o ++ "[" ++ show c ++ "] " ++ show x ++ ")"++shft :: String -> String -> Int -> SW -> String+shft oW oS c x= "(" ++ o ++ " " ++ show x ++ " " ++ cvtCW c' ++ ")"+   where s  = hasSign x+         c' = mkConstCW (s, sizeOf x) c+         o  = if hasSign x then oS else oW++cvtExp :: SBVExpr -> String+cvtExp (SBVApp Ite [a, b, c]) = "(ite (= bv1[1] " ++ show a ++ ") " ++ show b ++ " " ++ show c ++ ")"+cvtExp (SBVApp (Rol i) [a])   = rot "rotate_left"  i a+cvtExp (SBVApp (Ror i) [a])   = rot "rotate_right" i a+cvtExp (SBVApp (Shl i) [a])   = shft "bvshl"  "bvshl"  i a+cvtExp (SBVApp (Shr i) [a])   = shft "bvlshr" "bvashr" i a+cvtExp (SBVApp (LkUp (t, (_, at), _, l) i e) [])+  | needsCheck = "(ite " ++ cond ++ show e ++ " " ++ lkUp ++ ")"+  | True       = lkUp+  where needsCheck = (2::Integer)^(at) > (fromIntegral l)+        lkUp = "(select table" ++ show t ++ " " ++ show i ++ ")"+        cond+         | hasSign i = "(or " ++ le0 ++ " " ++ gtl ++ ") "+         | True      = gtl ++ " "+        (less, leq) = if hasSign i then ("bvslt", "bvsle") else ("bvult", "bvule")+        mkCnst = cvtCW . mkConstCW (hasSign i, sizeOf i)+        le0  = "(" ++ less ++ " " ++ show i ++ " " ++ mkCnst 0 ++ ")"+        gtl  = "(" ++ leq  ++ " " ++ mkCnst l ++ " " ++ show i ++ ")"+cvtExp (SBVApp (Extract i j) [a]) = "(extract[" ++ show i ++ ":" ++ show j ++ "] " ++ show a ++ ")"+cvtExp (SBVApp (ArrEq i j) []) = "(ite (= array_" ++ show i ++ " array_" ++ show j ++") bv1[1] bv0[1])"+cvtExp (SBVApp (ArrRead i) [a]) = "(select array_" ++ show i ++ " " ++ show a ++ ")"+cvtExp (SBVApp (Uninterpreted nm) [])   = "uninterpreted_" ++ nm+cvtExp (SBVApp (Uninterpreted nm) args) = "(uninterpreted_" ++ nm ++ " " ++ intercalate " " (map show args) ++ ")"+cvtExp inp@(SBVApp op args)+  | Just f <- lookup op smtOpTable+  = f (any hasSign args) (map show args)+  | True+  = error $ "SBV.SMT.SMTLib.cvtExp: impossible happened; can't translate: " ++ show inp+  where lift2  o _ [x, y] = "(" ++ o ++ " " ++ x ++ " " ++ y ++ ")"+        lift2  o _ sbvs   = error $ "SBV.SMTLib.cvtExp.lift2: Unexpected arguments: "   ++ show (o, sbvs)+        lift2B oU oS sgn sbvs+          | sgn+          = "(ite " ++ lift2 oS sgn sbvs ++ " bv1[1] bv0[1])"+          | True+          = "(ite " ++ lift2 oU sgn sbvs ++ " bv1[1] bv0[1])"+        lift2N o sgn sbvs = "(bvnot " ++ lift2 o sgn sbvs ++ ")"+        lift1  o _ [x]    = "(" ++ o ++ " " ++ x ++ ")"+        lift1  o _ sbvs   = error $ "SBV.SMT.SMTLib.cvtExp.lift1: Unexpected arguments: "   ++ show (o, sbvs)+        smtOpTable = [ (Plus,          lift2   "bvadd")+                     , (Minus,         lift2   "bvsub")+                     , (Times,         lift2   "bvmul")+                     , (Quot,          lift2   "bvudiv")+                     , (Rem,           lift2   "bvurem")+                     , (Equal,         lift2   "bvcomp")+                     , (NotEqual,      lift2N  "bvcomp")+                     , (LessThan,      lift2B  "bvult" "bvslt")+                     , (GreaterThan,   lift2B  "bvugt" "bvsgt")+                     , (LessEq,        lift2B  "bvule" "bvsle")+                     , (GreaterEq,     lift2B  "bvuge" "bvsge")+                     , (And,           lift2   "bvand")+                     , (Or,            lift2   "bvor")+                     , (XOr,           lift2   "bvxor")+                     , (Not,           lift1   "bvnot")+                     , (Join,          lift2   "concat")+                     ]++cvtType :: SBVType -> String+cvtType (SBVType []) = error "SBV.SMT.SMTLib.cvtType: internal: received an empty type!"+cvtType (SBVType xs) = intercalate " " $ map sh xs+  where sh (_, s) = "BitVec[" ++ show s ++ "]"
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Arrays/Memory.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Arrays.Memory+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Arrays.Memory+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Arrays.Memory(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Arrays.Memory++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+     "memory-raw"           ~: assert       =<< isTheorem raw+   , "memory-waw"           ~: assert       =<< isTheorem waw+   , "memory-wcommute-bad"  ~: assert . not =<< isTheorem wcommutesBad+   , "memory-wcommute-good" ~: assert       =<< isTheorem wcommutesGood+   ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Basics/Arithmetic.hs view
@@ -0,0 +1,155 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Basics.Arithmetic+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for basic concrete arithmetic+-----------------------------------------------------------------------------++{-# LANGUAGE Rank2Types #-}++module Data.SBV.TestSuite.Basics.Arithmetic(testSuite) where++import Data.SBV+import Data.SBV.Internals++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test $+        genBinTest "+"                (+)+     ++ genBinTest "-"                (-)+     ++ genBinTest "*"                (*)+     ++ genUnTest  "negate"           negate+     ++ genUnTest  "abs"              abs+     ++ genUnTest  "signum"           signum+     ++ genBinTest ".&."              (.&.)+     ++ genBinTest ".|."              (.|.)+     ++ genBinTest "xor"              (xor)+     ++ genUnTest  "complement"       complement+     ++ genIntTest "shift"            shift+     ++ genIntTest "rotate"           rotate+     ++ genIntTest "setBit"           setBit+     ++ genIntTest "clearBit"         clearBit+     ++ genIntTest "complementBit"    complementBit+     ++ genIntTest "shiftL"           shiftL+     ++ genIntTest "shiftR"           shiftR+     ++ genIntTest "rotateL"          rotateL+     ++ genIntTest "rotateR"          rotateR+     ++ genBlasts++genBinTest :: String -> (forall 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]+  where pair (x, y, a) b   = (x, y, show ((fromIntegral a) `asTypeOf` b) == show b)+        mkTest (x, y, s) = "arithmetic-" ++ nm ++ "." ++ x ++ "_" ++ y  ~: s `showsAs` "True"++genUnTest :: String -> (forall 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]+  where pair (x, a) b   = (x, show ((fromIntegral a) `asTypeOf` b) == show b)+        mkTest (x, s) = "arithmetic-" ++ nm ++ "." ++ x ~: s `showsAs` "True"++genIntTest :: String -> (forall 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]+  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) = "arithmetic-" ++ nm ++ "." ++ t ++ "_" ++ x ++ "_" ++ y ++ "_" ++ a ++ "_" ++ b ~: s `showsAs` "True"+        is = [-10 .. 10]++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-" ++ show x ~: r `showsAs` "True"++-- Concrete test data+xsSigned, xsUnsigned :: (Num a, Enum a, Bounded a) => [a]+xsUnsigned = take 5 (iterate (1+) minBound) ++ take 5 (iterate (\x -> x-1) maxBound)+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
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Basics/BasicTests.hs view
@@ -0,0 +1,51 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Basics.BasicTests+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Basics.BasicTests+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Basics.BasicTests(testSuite) where++import Data.SBV.Internals+import Data.SBV.Examples.Basics.BasicTests++-- 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"+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Basics/Higher.hs view
@@ -0,0 +1,34 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Basics.Higher+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Basics.Higher+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Basics.Higher(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Basics.Higher++-- 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)))+
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Basics/Index.hs view
@@ -0,0 +1,21 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Basics.Index+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Basics.Index+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Basics.Index(testSuite) where++import Data.SBV.Internals+import Data.SBV.Examples.Basics.Index++-- 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"
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Basics/ProofTests.hs view
@@ -0,0 +1,35 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Basics.ProofTests+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Basics.ProofTests+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Basics.ProofTests(testSuite)  where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Basics.ProofTests++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+   "proofs-1"  ~: assert       =<< isTheorem f1eqf2+ , "proofs-2"  ~: assert . not =<< isTheorem f1eqf3+ , "proofs-3"  ~: assert       =<< isTheorem f3eqf4+ , "proofs-4"  ~: assert       =<< isTheorem f1Single+ , "proofs-5"  ~: assert       =<< isSatisfiable f1eqf2+ , "proofs-6"  ~: assert       =<< isSatisfiable f1eqf3+ , "proofs-7"  ~: assert . not =<< isSatisfiable (\x -> x .== x + (1 :: SWord16))+ , "proofs-8"  ~: assert       =<< isSatisfiable (\x -> x :: SBool)+ , "proofs-9"  ~: assert       =<< isSatisfiable (\x -> return x :: Predicate)+ , "proofs-10" ~: assert       =<< isSatisfiable (forAll_ $ \x -> x :: SBool)+ , "proofs-11" ~: assert       =<< isSatisfiable (forAll_ $ \x -> return x :: Predicate)+ , "proofs-12" ~: assert       =<< isSatisfiable (forAll ["q"] $ \x -> x :: SBool)+ , "proofs-13" ~: assert       =<< isSatisfiable (forAll ["q"] $ \x -> return x :: Predicate)+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Basics/QRem.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Basics.QRem+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Basics.QRem+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Basics.QRem(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Basics.QRem++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+   "qrem" ~: assert =<< isTheorem (qrem :: SWord8 -> SWord8 -> SBool)+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/BitPrecise/BitTricks.hs view
@@ -0,0 +1,27 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.BitPrecise.BitTricks+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.BitPrecise.BitTricks+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.BitPrecise.BitTricks(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.BitPrecise.BitTricks++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+   "fast min"              ~: assert =<< isTheorem fastMinCorrect+ , "fast max"              ~: assert =<< isTheorem fastMaxCorrect+ , "opposite signs"        ~: assert =<< isTheorem oppositeSignsCorrect+ , "conditional set clear" ~: assert =<< isTheorem conditionalSetClearCorrect+ , "power of two"          ~: assert =<< isTheorem powerOfTwoCorrect+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/BitPrecise/Legato.hs view
@@ -0,0 +1,34 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.BitPrecise.Legato+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.BitPrecise.Legato+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.BitPrecise.Legato(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.BitPrecise.Legato++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \goldCheck -> test [+   "legato-1" ~: legatoPgm `goldCheck` "legato.gold"+ , "legato-2" ~: legatoC `goldCheck` "legato_c.gold"+ ]+ where legatoPgm = runSymbolic $ forAll ["mem", "addrX", "x", "addrY", "y", "addrLow", "regX", "regA", "memVals", "flagC", "flagZ"] legatoIsCorrect+                                 >>= output+       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 0) (0, 0, 0, false, false))+                    cgOutput "hi" hi+                    cgOutput "lo" lo
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/CRC/CCITT.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.CRC.CCITT+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.CRC.CCITT+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.CRC.CCITT(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.CRC.CCITT++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \goldCheck -> test [+  "ccitt" ~: crcPgm `goldCheck` "ccitt.gold"+ ]+ where crcPgm = runSymbolic $ forAll_ crcGood >>= output
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/CRC/CCITT_Unidir.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.CRC.CCITT_Unidir+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.CRC.CCITT_Unidir+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.CRC.CCITT_Unidir(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.CRC.CCITT_Unidir++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+   "ccitHDis3" ~: assert       =<< isTheorem (crcUniGood 3)+ , "ccitHDis4" ~: assert . not =<< isTheorem (crcUniGood 4)+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/CRC/GenPoly.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.CRC.GenPoly+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.CRC.GenPoly+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.CRC.GenPoly(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.CRC.GenPoly++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+   "crcGood" ~: assert       =<< isSatisfiable (crcGood 3 0)+ , "crcGood" ~: assert . not =<< isTheorem (crcGood 3 12)+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/CRC/Parity.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.CRC.Parity+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.CRC.Parity+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.CRC.Parity(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.CRC.Parity++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+   "parity" ~: assert =<< isTheorem parityOK+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/CRC/USB5.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.CRC.USB5+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.CRC.USB5+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.CRC.USB5(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.CRC.USB5++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+   "usbGood" ~: assert =<< isTheorem usbGood+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/CodeGeneration/AddSub.hs view
@@ -0,0 +1,31 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.CodeGeneration.AddSub+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.CodeGeneration.AddSub+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.CodeGeneration.AddSub(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.CodeGeneration.AddSub++-- 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
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/CodeGeneration/CgTests.hs view
@@ -0,0 +1,41 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.CodeGeneration.CgTests+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for code-generation features+-----------------------------------------------------------------------------++{-# LANGUAGE ScopedTypeVariables #-}++module Data.SBV.TestSuite.CodeGeneration.CgTests(testSuite) where++import Data.SBV+import Data.SBV.Internals++-- 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)
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/CodeGeneration/Fibonacci.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.CodeGeneration.Fibonacci+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.CodeGeneration.Fibonacci+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.CodeGeneration.Fibonacci(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.CodeGeneration.Fibonacci++-- 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
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/CodeGeneration/GCD.hs view
@@ -0,0 +1,28 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.CodeGeneration.GCD+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.CodeGeneration.GCD+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.CodeGeneration.GCD(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.CodeGeneration.GCD++-- 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
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/CodeGeneration/PopulationCount.hs view
@@ -0,0 +1,29 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.CodeGeneration.PopulationCount+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.CodeGeneration.PopulationCount+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.CodeGeneration.PopulationCount(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.CodeGeneration.PopulationCount++-- 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 $ popCount x
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Crypto/AES.hs view
@@ -0,0 +1,34 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Crypto.AES+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.CodeGeneration.AES+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Crypto.AES(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Crypto.AES++-- 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
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Polynomials/Polynomials.hs view
@@ -0,0 +1,25 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Polynomials.Polynomials+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Polynomials.Polynomials+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Polynomials.Polynomials(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Polynomials.Polynomials++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+   "polynomial-1" ~: assert =<< isTheorem multUnit+ , "polynomial-2" ~: assert =<< isTheorem multComm+ , "polynomial-3" ~: assert =<< isTheorem polyDivMod+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/PrefixSum/PrefixSum.hs view
@@ -0,0 +1,25 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.PrefixSum.PrefixSum+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.PrefixSum.PrefixSum+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.PrefixSum.PrefixSum(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.PrefixSum.PrefixSum++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \goldCheck -> test [+    "prefixSum1" ~: assert =<< isTheorem (flIsCorrect  8 (0, (+)))+  , "prefixSum2" ~: assert =<< isTheorem (flIsCorrect 16 (0, smax))+  , "prefixSum3" ~: runSymbolic (genPrefixSumInstance 16 >>= output) `goldCheck` "prefixSum_16.gold"+  ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Puzzles/DogCatMouse.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Puzzles.DogCatMouse+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Puzzles.DogCatMouse+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Puzzles.DogCatMouse(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Puzzles.DogCatMouse++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \goldCheck -> test [+  "dog cat mouse" ~: allSat puzzle `goldCheck` "dogCatMouse.gold"+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Puzzles/Euler185.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Puzzles.Euler185+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Puzzles.Euler185+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Puzzles.Euler185(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Puzzles.Euler185++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \goldCheck -> test [+  "euler185" ~: allSat euler185 `goldCheck` "euler185.gold"+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Puzzles/MagicSquare.hs view
@@ -0,0 +1,25 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Puzzles.MagicSquare+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Puzzles.MagicSquare+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Puzzles.MagicSquare(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Puzzles.MagicSquare++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+   "magic 2" ~: assert . not =<< isSatisfiable (mkMagic 2)+ , "magic 3" ~: assert       =<< isSatisfiable (mkMagic 3)+ ]+ where mkMagic n = mkFreeVars (n*n) >>= return . isMagic . chunk n
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Puzzles/NQueens.hs view
@@ -0,0 +1,32 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Puzzles.NQueens+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Puzzles.NQueens+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Puzzles.NQueens(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Puzzles.NQueens++-- 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 = mkFreeVars n >>= return . isValid n
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Puzzles/PowerSet.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Puzzles.PowerSet+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Puzzles.PowerSet+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Puzzles.PowerSet(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Puzzles.PowerSet++-- 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 $ mkFreeVars n >>= return . genPowerSet+                   return (cnt == 2^n)
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Puzzles/Sudoku.hs view
@@ -0,0 +1,25 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Puzzles.Sudoku+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Puzzles.Sudoku+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Puzzles.Sudoku(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Puzzles.Sudoku++-- 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) = isSatisfiable $ mkFreeVars i >>= return . valid . f
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Puzzles/Temperature.hs view
@@ -0,0 +1,23 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Puzzles.Temperature+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Puzzles.Temperature+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Puzzles.Temperature(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Puzzles.Temperature++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \goldCheck -> test [+  "temperature" ~: sat revOf `goldCheck` "temperature.gold"+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Puzzles/U2Bridge.hs view
@@ -0,0 +1,31 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Puzzles.U2Bridge+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Puzzles.U2Bridge+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Puzzles.U2Bridge(testSuite) where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Puzzles.U2Bridge++-- 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" ~: solve 5 `goldCheck` "U2Bridge.gold"+ , "U2Bridge-6" ~: assert $ (0 ==) `fmap` count 6+ ]+ where act     = do b <- free_; p1 <- free_; p2 <- free_; return (b, p1, p2)+       count n = numberOfModels $ mapM (const act) [1..(n::Int)] >>= return . isValid+       solve n = sat $ mapM (const act) [1..(n::Int)] >>= return . isValid
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Uninterpreted/AUF.hs view
@@ -0,0 +1,26 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Uninterpreted.AUF+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Uninterpreted.AUF+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Uninterpreted.AUF where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Uninterpreted.AUF++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \goldCheck -> test [+   "auf-0" ~: assert =<< isTheorem thm1+ , "auf-1" ~: assert =<< isTheorem thm2+ , "auf-2" ~: pgm `goldCheck` "auf-1.gold"+ ]+ where pgm = runSymbolic $ forAll ["x", "y", "a", "initVal"] thm1 >>= output
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Uninterpreted/Function.hs view
@@ -0,0 +1,24 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.TestSuite.Uninterpreted.Function+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Testsuite for Data.SBV.Examples.Uninterpreted.Function+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Uninterpreted.Function where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Uninterpreted.Function++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+   "aufunc-0" ~: assert       =<< isTheorem thmGood+ , "aufunc-1" ~: assert . not =<< isTheorem thmBad+ ]
+ Temp/sbv-0.9.18/Data/SBV/TestSuite/Uninterpreted/Uninterpreted.hs view
@@ -0,0 +1,25 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Examples.TestSuite.Uninterpreted+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Test suite for Data.SBV.Examples.Uninterpreted.Uninterpreted+-----------------------------------------------------------------------------++module Data.SBV.TestSuite.Uninterpreted.Uninterpreted where++import Data.SBV+import Data.SBV.Internals+import Data.SBV.Examples.Uninterpreted.Uninterpreted++-- Test suite+testSuite :: SBVTestSuite+testSuite = mkTestSuite $ \_ -> test [+   "uninterpreted-0" ~: assert       =<< isTheorem p0+ , "uninterpreted-1" ~: assert       =<< isTheorem p1+ , "uninterpreted-2" ~: assert . not =<< isTheorem p2+ ]
+ Temp/sbv-0.9.18/Data/SBV/Utils/Boolean.hs view
@@ -0,0 +1,82 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Utils.Boolean+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Abstraction of booleans. Unfortunately, Haskell makes Bool's very hard to+-- work with, by making it a fixed-data type. This is our workaround+-----------------------------------------------------------------------------++module Data.SBV.Utils.Boolean(Boolean(..), bAnd, bOr, bAny, bAll)  where++infixl 6 <+>       -- xor+infixr 3 &&&, ~&   -- and, nand+infixr 2 |||, ~|   -- or, nor+infixr 1 ==>, <=>  -- implies, iff++-- | The 'Boolean' class: a generalization of Haskell's 'Bool' type+-- Haskell 'Bool' and SBV's 'SBool' are instances of this class, unifying the treatment of boolean values.+--+-- Minimal complete definition: 'true', 'bnot', '&&&'+-- However, it's advisable to define 'false', and '|||' as well (typically), for clarity.+class Boolean b where+  -- | logical true+  true   :: b+  -- | logical false+  false  :: b+  -- | complement+  bnot   :: b -> b+  -- | and+  (&&&)  :: b -> b -> b+  -- | or+  (|||)  :: b -> b -> b+  -- | nand+  (~&)   :: b -> b -> b+  -- | nor+  (~|)   :: b -> b -> b+  -- | xor+  (<+>)  :: b -> b -> b+  -- | implies+  (==>)  :: b -> b -> b+  -- | equivalence+  (<=>)  :: b -> b -> b+  -- | cast from Bool+  fromBool :: Bool -> b++  -- default definitions+  false   = bnot true+  a ||| b = bnot (bnot a &&& bnot b)+  a ~& b  = bnot (a &&& b)+  a ~| b  = bnot (a ||| b)+  a <+> b = (a &&& bnot b) ||| (bnot a &&& b)+  a <=> b = (a &&& b) ||| (bnot a &&& bnot b)+  a ==> b = bnot a ||| b+  fromBool True  = true+  fromBool False = false++-- | Generalization of 'and'+bAnd :: Boolean b => [b] -> b+bAnd = foldr (&&&) true++-- | Generalization of 'or'+bOr :: Boolean b => [b] -> b+bOr  = foldr (|||) false++-- | Generalization of 'any'+bAny :: Boolean b => (a -> b) -> [a] -> b+bAny f = bOr  . map f++-- | Generalization of 'all'+bAll :: Boolean b => (a -> b) -> [a] -> b+bAll f = bAnd . map f++instance Boolean Bool where+  true   = True+  false  = False+  bnot   = not+  (&&&)  = (&&)+  (|||)  = (||)
+ Temp/sbv-0.9.18/Data/SBV/Utils/Lib.hs view
@@ -0,0 +1,34 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Utils.Lib+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Misc helpers+-----------------------------------------------------------------------------++module Data.SBV.Utils.Lib where++mlift2 :: Monad m => (a' -> b' -> r) -> (a -> m a') -> (b -> m b') -> (a, b) -> m r+mlift2 k f g (a, b) = f a >>= \a' -> g b >>= \b' -> return $ k a' b'++mlift3 :: Monad m => (a' -> b' -> c' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (a, b, c) -> m r+mlift3 k f g h (a, b, c) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> return $ k a' b' c'++mlift4 :: Monad m => (a' -> b' -> c' -> d' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (d -> m d') -> (a, b, c, d) -> m r+mlift4 k f g h i (a, b, c, d) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> i d >>= \d' -> return $ k a' b' c' d'++mlift5 :: Monad m => (a' -> b' -> c' -> d' -> e' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (d -> m d') -> (e -> m e') -> (a, b, c, d, e) -> m r+mlift5 k f g h i j (a, b, c, d, e) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> i d >>= \d' -> j e >>= \e' -> return $ k a' b' c' d' e'++mlift6 :: Monad m => (a' -> b' -> c' -> d' -> e' -> f' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (d -> m d') -> (e -> m e') -> (f -> m f') -> (a, b, c, d, e, f) -> m r+mlift6 k f g h i j l (a, b, c, d, e, y) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> i d >>= \d' -> j e >>= \e' -> l y >>= \y' -> return $ k a' b' c' d' e' y'++mlift7 :: Monad m => (a' -> b' -> c' -> d' -> e' -> f' -> g' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (d -> m d') -> (e -> m e') -> (f -> m f') -> (g -> m g') -> (a, b, c, d, e, f, g) -> m r+mlift7 k f g h i j l m (a, b, c, d, e, y, z) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> i d >>= \d' -> j e >>= \e' -> l y >>= \y' -> m z >>= \z' -> return $ k a' b' c' d' e' y' z'++mlift8 :: Monad m => (a' -> b' -> c' -> d' -> e' -> f' -> g' -> h' -> r) -> (a -> m a') -> (b -> m b') -> (c -> m c') -> (d -> m d') -> (e -> m e') -> (f -> m f') -> (g -> m g') -> (h -> m h') -> (a, b, c, d, e, f, g, h) -> m r+mlift8 k f g h i j l m n (a, b, c, d, e, y, z, w) = f a >>= \a' -> g b >>= \b' -> h c >>= \c' -> i d >>= \d' -> j e >>= \e' -> l y >>= \y' -> m z >>= \z' -> n w >>= \w' -> return $ k a' b' c' d' e' y' z' w'
+ Temp/sbv-0.9.18/Data/SBV/Utils/SBVTest.hs view
@@ -0,0 +1,45 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Utils.SBVTest+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Integration with HUnit-based test suite for SBV+-----------------------------------------------------------------------------++{-# LANGUAGE RankNTypes #-}+module Data.SBV.Utils.SBVTest(generateGoldCheck, showsAs, ioShowsAs, mkTestSuite, SBVTestSuite(..), module Test.HUnit) where++import System.FilePath ((</>))+import Test.HUnit      (Test(..), Assertion, assert, (~:), test)++-- | A Test-suite, parameterized by the gold-check generator/checker+data 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
+ Temp/sbv-0.9.18/Data/SBV/Utils/TDiff.hs view
@@ -0,0 +1,37 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Data.SBV.Utils.TDiff+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Runs an IO computation printing the time it took to run it+-----------------------------------------------------------------------------++module Data.SBV.Utils.TDiff(timeIf) where++import Control.DeepSeq (rnf, NFData(..))+import System.Time     (TimeDiff(..), normalizeTimeDiff, diffClockTimes, getClockTime)+import Numeric         (showFFloat)++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++-- | 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 => Bool -> String -> IO a -> IO a+timeIf False _ m = m+timeIf True  w m = do start <- getClockTime+                      r <- m+                      end <- rnf r `seq` getClockTime+                      let elapsed = diffClockTimes end start+                      putStrLn $ "** Elapsed " ++ w ++ " time:" ++ showTDiff elapsed+                      return r
+ Temp/sbv-0.9.18/INSTALL view
@@ -0,0 +1,19 @@+The sbv library can be installed simply by issuing cabal install+like this:++     cabal install sbv++Once the installation is done, you will get the Data.SBV library.+The installation will also put a binary named++     SBVUnitTests++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+Yices, the default SMT solver used by sbv, from SRI. (You can get it+from http://yices.csl.sri.com/.) Please make sure that the "yices"+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.
+ Temp/sbv-0.9.18/LICENSE view
@@ -0,0 +1,26 @@+SBV: A library for Symbolic Bitvectors++Copyright (c) 2010-2011, Levent Erkok (erkokl@gmail.com)+All rights reserved.++Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met:+    * Redistributions of source code must retain the above copyright+      notice, this list of conditions and the following disclaimer.+    * Redistributions in binary form must reproduce the above copyright+      notice, this list of conditions and the following disclaimer in the+      documentation and/or other materials provided with the distribution.+    * Neither the name of the developer (Levent Erkok) nor the+      names of its contributors may be used to endorse or promote products+      derived from this software without specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE+DISCLAIMED. IN NO EVENT SHALL LEVENT ERKOK BE LIABLE FOR ANY+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ Temp/sbv-0.9.18/README view
@@ -0,0 +1,123 @@+SBV: Symbolic Bit Vectors in Haskell+====================================++Express properties about bit-precise Haskell programs and automatically prove+them using SMT solvers.++        $ ghci -XScopedTypeVariables+        Prelude> :m Data.SBV+        Prelude Data.SBV> prove $ \(x::SWord8) -> x `shiftL` 2 .== 4*x+        Q.E.D.+        Prelude Data.SBV> prove $ forAll ["x"] $ \(x::SWord8) -> x `shiftL` 2 .== x+        Falsifiable. Counter-example:+          x = 128 :: SWord8++The function `prove` has the following type:+    +        prove :: Provable a => a -> IO ThmResult++The class `Provable` comes with instances for n-ary predicates, for arbitrary n.+The predicates are just regular Haskell functions over symbolic signed and unsigned+bit-vectors. Functions for checking satisfiability (`sat` and `allSat`) are also provided.+In addition, functions using the SBV library can be compiled to C automatically.++Resources+=========+The sbv library is hosted at [http://github.com/LeventErkok/sbv](http://github.com/LeventErkok/sbv).++The hackage site+[http://hackage.haskell.org/package/sbv](http://hackage.haskell.org/package/sbv) is the best place+for details on the API and the example use cases.++Comments, bug reports, and patches are always welcome.++Overview+========+The Haskell sbv library provides support for dealing with Symbolic Bit Vectors+in Haskell. It introduces the types:++  - `SBool`: Symbolic Booleans (bits)+  - `SWord8`, `SWord16`, `SWord32`, `SWord64`: Symbolic Words (unsigned)+  - `SInt8`,  `SInt16`,  `SInt32`,  `SInt64`: Symbolic Ints (signed)+  - Arrays of symbolic values+  - Symbolic polynomials over GF(2^n ), and polynomial arithmetic+  - Uninterpreted constants and functions over symbolic values, with user+    defined SMT-Lib axioms++The user can construct ordinary Haskell programs using these types, which behave+very similar to their concrete counterparts. In particular these types belong to the+standard classes `Num`, `Bits`, (custom versions of) `Eq` and `Ord`, along with several+other custom classes for simplifying bit-precise programming with symbolic values. The+framework takes full advantage of Haskell's type inference to avoid many common mistakes.++Furthermore, predicates (i.e., functions that return `SBool`) built out of these types can also be:++  - proven correct via an external SMT solver (the `prove` function)+  - checked for satisfiability (the `sat` and `allSat` functions)+  - quick-checked++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.++The SBV library can also compile Haskell functions that manipulate symbolic+values directly to C, rendering them as straight-line C programs that can be+executed in, say, embedded platforms.++Use of SMT solvers+==================+The sbv library uses third-party SMT solvers via the standard SMT-Lib interface: +[http://goedel.cs.uiowa.edu/smtlib/](http://goedel.cs.uiowa.edu/smtlib/)++While the library is designed to work with any SMT-Lib compliant SMT-solver,+solver specific support is required for parsing counter-example/model data since+there is currently no agreed upon format for getting models from arbitrary SMT+solvers. (The SMT-Lib2 initiative will potentially address this issue in the+future, at which point the sbv library can be generalized as well.) Currently, we+only support the Yices SMT solver from SRI as far as the counter-example+and model generation support is concerned:+[http://yices.csl.sri.com/](http://yices.csl.sri.com/) However, other solvers can+be hooked up with relative ease.++Prerequisites+=============+You **should** download and install Yices (version 2.X) on your machine, and+make sure the "yices" executable is in your path before using the sbv library,+as it is the current default solver. Alternatively, you can specify the location+of yices executable in the environment variable `SBV_YICES` and the options to yices+in `SBV_YICES_OPTIONS`. (The default for the latter is `"-m -f"`.)++Examples+=========+Please see the files under the+[Examples](http://github.com/LeventErkok/sbv/tree/master/Data/SBV/Examples)+directory for a number of interesting applications and use cases. Amongst others,+it contains solvers for Sudoku and N-Queens puzzles as mandatory SMT solver examples in+the Puzzles directory.++Installation+============+The sbv library is cabalized. Assuming you have cabal/ghc installed, it should merely+be a matter of running +     +         cabal install sbv+	 +Please see [INSTALL](http://github.com/LeventErkok/sbv/tree/master/INSTALL) for installation details.++Once the installation is done, you can run the executable `SBVUnitTests` which will+execute the regression test suite for sbv on your machine to ensure all is well.++Copyright, License+==================+The sbv library is distributed with the BSD3 license. See [COPYRIGHT](http://github.com/LeventErkok/sbv/tree/master/COPYRIGHT) for+details. The [LICENSE](http://github.com/LeventErkok/sbv/tree/master/LICENSE) file contains+the [BSD3](http://en.wikipedia.org/wiki/BSD_licenses) verbiage.++Thanks+======+[Galois, Inc.](http://www.galois.com) has contributed to the development of SBV,+by providing time and computing machinery.++The following people reported bugs, provided comments/feedback, or contributed to the development of SBV in various ways:+Ian Blumenfeld, Iavor Diatchki, Lee Pike, Austin Seipp, Don Stewart, and Josef Svenningsson.
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/U2Bridge.gold view
@@ -0,0 +1,16 @@+Satisfiable. Model:+  s0 = False+  s1 = 1 :: SWord8+  s2 = 0 :: SWord8+  s3 = True+  s4 = 1 :: SWord8+  s5 = 0 :: SWord8+  s6 = False+  s7 = 3 :: SWord8+  s8 = 2 :: SWord8+  s9 = True+  s10 = 0 :: SWord8+  s11 = 0 :: SWord8+  s12 = False+  s13 = 1 :: SWord8+  s14 = 0 :: SWord8
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/addSub.gold view
@@ -0,0 +1,93 @@+== BEGIN: "Makefile" ================+# Makefile for addSub. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#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" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/aes128Dec.gold view
@@ -0,0 +1,2597 @@+== BEGIN: "Makefile" ================+# Makefile for aes128Dec. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#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" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/aes128Enc.gold view
@@ -0,0 +1,1155 @@+== BEGIN: "Makefile" ================+# Makefile for aes128Enc. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#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" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/aes128Lib.gold view
@@ -0,0 +1,3763 @@+== BEGIN: "aes128KeySchedule.c" ================+/* File: "aes128KeySchedule.c". Automatically generated by SBV. Do not edit! */++#include <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 <inttypes.h>+#include <stdint.h>+#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!++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" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/auf-1.gold view
@@ -0,0 +1,30 @@+INPUTS+  s0 :: SWord32, aliasing "x"+  s1 :: SWord32, aliasing "y"+  s2 :: SWord32, aliasing "initVal"+CONSTANTS+  s_2 = False+  s_1 = True+  s3 = 2 :: SWord32+  s9 = 3 :: SWord32+  s13 = 1 :: SWord32+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+  uninterpreted_f :: SWord32 -> SWord64+AXIOMS+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+OUTPUTS+  s17
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-1_1.gold view
@@ -0,0 +1,1 @@+5 :: SWord8
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-1_2.gold view
@@ -0,0 +1,1 @@+5 :: SWord8
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-1_3.gold view
@@ -0,0 +1,1 @@+25 :: SWord8
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-1_4.gold view
@@ -0,0 +1,1 @@+25 :: SWord8
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-1_5.gold view
@@ -0,0 +1,1 @@+4 :: SWord8
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-2_1.gold view
@@ -0,0 +1,16 @@+INPUTS+  s0 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False+  s_1 = True+  s1 = 3 :: SWord8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s1 - s0+  s4 :: SWord8 = s2 * s3+OUTPUTS+  s4
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-2_2.gold view
@@ -0,0 +1,15 @@+INPUTS+  s0 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False+  s_1 = True+  s1 = 9 :: SWord8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 * s0+  s3 :: SWord8 = s1 - s2+OUTPUTS+  s3
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-2_3.gold view
@@ -0,0 +1,15 @@+INPUTS+  s0 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False+  s_1 = True+  s1 = 3 :: SWord8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s2 * s2+OUTPUTS+  s3
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-2_4.gold view
@@ -0,0 +1,15 @@+INPUTS+  s0 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False+  s_1 = True+  s1 = 3 :: SWord8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s2 * s2+OUTPUTS+  s3
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-2_5.gold view
@@ -0,0 +1,1 @@+4 :: SWord8
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-3_1.gold view
@@ -0,0 +1,16 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s0 - s1+  s4 :: SWord8 = s2 * s3+OUTPUTS+  s4
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-3_2.gold view
@@ -0,0 +1,16 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 * s0+  s3 :: SWord8 = s1 * s1+  s4 :: SWord8 = s2 - s3+OUTPUTS+  s4
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-3_3.gold view
@@ -0,0 +1,15 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s2 * s2+OUTPUTS+  s3
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-3_4.gold view
@@ -0,0 +1,15 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+  s3 :: SWord8 = s2 * s2+OUTPUTS+  s3
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-3_5.gold view
@@ -0,0 +1,15 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "y"+CONSTANTS+  s_2 = False+  s_1 = True+  s2 = 1 :: SWord8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s3 :: SWord8 = s0 + s2+OUTPUTS+  s3
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-4_1.gold view
@@ -0,0 +1,15 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s1 :: SWord8 = s0 + s0+  s2 :: SWord8 = s0 - s0+  s3 :: SWord8 = s1 * s2+OUTPUTS+  s3
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-4_2.gold view
@@ -0,0 +1,14 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s1 :: SWord8 = s0 * s0+  s2 :: SWord8 = s1 - s1+OUTPUTS+  s2
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-4_3.gold view
@@ -0,0 +1,14 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s1 :: SWord8 = s0 + s0+  s2 :: SWord8 = s1 * s1+OUTPUTS+  s2
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-4_4.gold view
@@ -0,0 +1,14 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s1 :: SWord8 = s0 + s0+  s2 :: SWord8 = s1 * s1+OUTPUTS+  s2
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-4_5.gold view
@@ -0,0 +1,14 @@+INPUTS+  s0 :: SWord8, aliasing "x"+CONSTANTS+  s_2 = False+  s_1 = True+  s1 = 1 :: SWord8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s1+OUTPUTS+  s2
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-5_1.gold view
@@ -0,0 +1,17 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "q"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s0+  s3 :: SWord8 = s0 - s0+  s4 :: SWord8 = s2 * s3+OUTPUTS+  s1+  s4
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-5_2.gold view
@@ -0,0 +1,16 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "q"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 * s0+  s3 :: SWord8 = s2 - s2+OUTPUTS+  s1+  s3
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-5_3.gold view
@@ -0,0 +1,16 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "q"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s0+  s3 :: SWord8 = s2 * s2+OUTPUTS+  s1+  s3
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-5_4.gold view
@@ -0,0 +1,16 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "q"+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s2 :: SWord8 = s0 + s0+  s3 :: SWord8 = s2 * s2+OUTPUTS+  s1+  s3
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/basic-5_5.gold view
@@ -0,0 +1,16 @@+INPUTS+  s0 :: SWord8, aliasing "x"+  s1 :: SWord8, aliasing "q"+CONSTANTS+  s_2 = False+  s_1 = True+  s2 = 1 :: SWord8+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s3 :: SWord8 = s0 + s2+OUTPUTS+  s1+  s3
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/ccitt.gold view
@@ -0,0 +1,1828 @@+INPUTS+  s0 :: SWord32+  s1 :: SWord16+  s2 :: SWord32+  s3 :: SWord16+CONSTANTS+  s_2 = False+  s_1 = True+  s1685 = 0 :: SWord8+  s1686 = 1 :: SWord8+  s1814 = 3 :: SWord8+  s9 = 0 :: SWord16+  s12 = 9223372036854775808 :: SWord64+  s14 = 0 :: SWord64+  s16 = 4611686018427387904 :: SWord64+  s19 = 2305843009213693952 :: SWord64+  s22 = 1152921504606846976 :: SWord64+  s25 = 576460752303423488 :: SWord64+  s30 = 288230376151711744 :: SWord64+  s35 = 144115188075855872 :: SWord64+  s40 = 72057594037927936 :: SWord64+  s45 = 36028797018963968 :: SWord64+  s50 = 18014398509481984 :: SWord64+  s55 = 9007199254740992 :: SWord64+  s60 = 4503599627370496 :: SWord64+  s67 = 2251799813685248 :: SWord64+  s74 = 1125899906842624 :: SWord64+  s81 = 562949953421312 :: SWord64+  s88 = 281474976710656 :: SWord64+  s95 = 140737488355328 :: SWord64+  s104 = 70368744177664 :: SWord64+  s113 = 35184372088832 :: SWord64+  s122 = 17592186044416 :: SWord64+  s131 = 8796093022208 :: SWord64+  s140 = 4398046511104 :: SWord64+  s149 = 2199023255552 :: SWord64+  s158 = 1099511627776 :: SWord64+  s167 = 549755813888 :: SWord64+  s176 = 274877906944 :: SWord64+  s185 = 137438953472 :: SWord64+  s194 = 68719476736 :: SWord64+  s203 = 34359738368 :: SWord64+  s212 = 17179869184 :: SWord64+  s221 = 8589934592 :: SWord64+  s230 = 4294967296 :: SWord64+  s239 = 2147483648 :: SWord64+  s248 = 1073741824 :: SWord64+  s257 = 536870912 :: SWord64+  s266 = 268435456 :: SWord64+  s275 = 134217728 :: SWord64+  s284 = 67108864 :: SWord64+  s293 = 33554432 :: SWord64+  s302 = 16777216 :: SWord64+  s311 = 8388608 :: SWord64+  s320 = 4194304 :: SWord64+  s329 = 2097152 :: SWord64+  s338 = 1048576 :: SWord64+  s347 = 524288 :: SWord64+  s356 = 262144 :: SWord64+  s365 = 131072 :: SWord64+  s374 = 65536 :: SWord64+  s479 = 32768 :: SWord64+  s488 = 16384 :: SWord64+  s497 = 8192 :: SWord64+  s506 = 4096 :: SWord64+  s515 = 2048 :: SWord64+  s522 = 1024 :: SWord64+  s529 = 512 :: SWord64+  s536 = 256 :: SWord64+  s543 = 128 :: SWord64+  s550 = 64 :: SWord64+  s557 = 32 :: SWord64+  s564 = 16 :: SWord64+  s569 = 8 :: SWord64+  s574 = 4 :: SWord64+  s579 = 2 :: SWord64+  s584 = 1 :: SWord64+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+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+  s13 :: SWord64 = s11 & s12+  s15 :: SBool = s13 /= s14+  s17 :: SWord64 = s11 & s16+  s18 :: SBool = s14 /= s17+  s20 :: SWord64 = s11 & s19+  s21 :: SBool = s14 /= s20+  s23 :: SWord64 = s11 & s22+  s24 :: SBool = s14 /= s23+  s26 :: SWord64 = s11 & s25+  s27 :: SBool = s14 /= s26+  s28 :: SBool = ~ s27+  s29 :: SBool = if s15 then s28 else s27+  s31 :: SWord64 = s11 & s30+  s32 :: SBool = s14 /= s31+  s33 :: SBool = ~ s32+  s34 :: SBool = if s18 then s33 else s32+  s36 :: SWord64 = s11 & s35+  s37 :: SBool = s14 /= s36+  s38 :: SBool = ~ s37+  s39 :: SBool = if s21 then s38 else s37+  s41 :: SWord64 = s11 & s40+  s42 :: SBool = s14 /= s41+  s43 :: SBool = ~ s42+  s44 :: SBool = if s24 then s43 else s42+  s46 :: SWord64 = s11 & s45+  s47 :: SBool = s14 /= s46+  s48 :: SBool = ~ s47+  s49 :: SBool = if s29 then s48 else s47+  s51 :: SWord64 = s11 & s50+  s52 :: SBool = s14 /= s51+  s53 :: SBool = ~ s52+  s54 :: SBool = if s34 then s53 else s52+  s56 :: SWord64 = s11 & s55+  s57 :: SBool = s14 /= s56+  s58 :: SBool = ~ s57+  s59 :: SBool = if s39 then s58 else s57+  s61 :: SWord64 = s11 & s60+  s62 :: SBool = s14 /= s61+  s63 :: SBool = ~ s62+  s64 :: SBool = if s15 then s63 else s62+  s65 :: SBool = ~ s64+  s66 :: SBool = if s44 then s65 else s64+  s68 :: SWord64 = s11 & s67+  s69 :: SBool = s14 /= s68+  s70 :: SBool = ~ s69+  s71 :: SBool = if s18 then s70 else s69+  s72 :: SBool = ~ s71+  s73 :: SBool = if s49 then s72 else s71+  s75 :: SWord64 = s11 & s74+  s76 :: SBool = s14 /= s75+  s77 :: SBool = ~ s76+  s78 :: SBool = if s21 then s77 else s76+  s79 :: SBool = ~ s78+  s80 :: SBool = if s54 then s79 else s78+  s82 :: SWord64 = s11 & s81+  s83 :: SBool = s14 /= s82+  s84 :: SBool = ~ s83+  s85 :: SBool = if s24 then s84 else s83+  s86 :: SBool = ~ s85+  s87 :: SBool = if s59 then s86 else s85+  s89 :: SWord64 = s11 & s88+  s90 :: SBool = s14 /= s89+  s91 :: SBool = ~ s90+  s92 :: SBool = if s29 then s91 else s90+  s93 :: SBool = ~ s92+  s94 :: SBool = if s66 then s93 else s92+  s96 :: SWord64 = s11 & s95+  s97 :: SBool = s14 /= s96+  s98 :: SBool = ~ s97+  s99 :: SBool = if s15 then s98 else s97+  s100 :: SBool = ~ s99+  s101 :: SBool = if s34 then s100 else s99+  s102 :: SBool = ~ s101+  s103 :: SBool = if s73 then s102 else s101+  s105 :: SWord64 = s11 & s104+  s106 :: SBool = s14 /= s105+  s107 :: SBool = ~ s106+  s108 :: SBool = if s18 then s107 else s106+  s109 :: SBool = ~ s108+  s110 :: SBool = if s39 then s109 else s108+  s111 :: SBool = ~ s110+  s112 :: SBool = if s80 then s111 else s110+  s114 :: SWord64 = s11 & s113+  s115 :: SBool = s14 /= s114+  s116 :: SBool = ~ s115+  s117 :: SBool = if s21 then s116 else s115+  s118 :: SBool = ~ s117+  s119 :: SBool = if s44 then s118 else s117+  s120 :: SBool = ~ s119+  s121 :: SBool = if s87 then s120 else s119+  s123 :: SWord64 = s11 & s122+  s124 :: SBool = s14 /= s123+  s125 :: SBool = ~ s124+  s126 :: SBool = if s24 then s125 else s124+  s127 :: SBool = ~ s126+  s128 :: SBool = if s49 then s127 else s126+  s129 :: SBool = ~ s128+  s130 :: SBool = if s94 then s129 else s128+  s132 :: SWord64 = s11 & s131+  s133 :: SBool = s14 /= s132+  s134 :: SBool = ~ s133+  s135 :: SBool = if s29 then s134 else s133+  s136 :: SBool = ~ s135+  s137 :: SBool = if s54 then s136 else s135+  s138 :: SBool = ~ s137+  s139 :: SBool = if s103 then s138 else s137+  s141 :: SWord64 = s11 & s140+  s142 :: SBool = s14 /= s141+  s143 :: SBool = ~ s142+  s144 :: SBool = if s34 then s143 else s142+  s145 :: SBool = ~ s144+  s146 :: SBool = if s59 then s145 else s144+  s147 :: SBool = ~ s146+  s148 :: SBool = if s112 then s147 else s146+  s150 :: SWord64 = s11 & s149+  s151 :: SBool = s14 /= s150+  s152 :: SBool = ~ s151+  s153 :: SBool = if s39 then s152 else s151+  s154 :: SBool = ~ s153+  s155 :: SBool = if s66 then s154 else s153+  s156 :: SBool = ~ s155+  s157 :: SBool = if s121 then s156 else s155+  s159 :: SWord64 = s11 & s158+  s160 :: SBool = s14 /= s159+  s161 :: SBool = ~ s160+  s162 :: SBool = if s44 then s161 else s160+  s163 :: SBool = ~ s162+  s164 :: SBool = if s73 then s163 else s162+  s165 :: SBool = ~ s164+  s166 :: SBool = if s130 then s165 else s164+  s168 :: SWord64 = s11 & s167+  s169 :: SBool = s14 /= s168+  s170 :: SBool = ~ s169+  s171 :: SBool = if s49 then s170 else s169+  s172 :: SBool = ~ s171+  s173 :: SBool = if s80 then s172 else s171+  s174 :: SBool = ~ s173+  s175 :: SBool = if s139 then s174 else s173+  s177 :: SWord64 = s11 & s176+  s178 :: SBool = s14 /= s177+  s179 :: SBool = ~ s178+  s180 :: SBool = if s54 then s179 else s178+  s181 :: SBool = ~ s180+  s182 :: SBool = if s87 then s181 else s180+  s183 :: SBool = ~ s182+  s184 :: SBool = if s148 then s183 else s182+  s186 :: SWord64 = s11 & s185+  s187 :: SBool = s14 /= s186+  s188 :: SBool = ~ s187+  s189 :: SBool = if s59 then s188 else s187+  s190 :: SBool = ~ s189+  s191 :: SBool = if s94 then s190 else s189+  s192 :: SBool = ~ s191+  s193 :: SBool = if s157 then s192 else s191+  s195 :: SWord64 = s11 & s194+  s196 :: SBool = s14 /= s195+  s197 :: SBool = ~ s196+  s198 :: SBool = if s66 then s197 else s196+  s199 :: SBool = ~ s198+  s200 :: SBool = if s103 then s199 else s198+  s201 :: SBool = ~ s200+  s202 :: SBool = if s166 then s201 else s200+  s204 :: SWord64 = s11 & s203+  s205 :: SBool = s14 /= s204+  s206 :: SBool = ~ s205+  s207 :: SBool = if s73 then s206 else s205+  s208 :: SBool = ~ s207+  s209 :: SBool = if s112 then s208 else s207+  s210 :: SBool = ~ s209+  s211 :: SBool = if s175 then s210 else s209+  s213 :: SWord64 = s11 & s212+  s214 :: SBool = s14 /= s213+  s215 :: SBool = ~ s214+  s216 :: SBool = if s80 then s215 else s214+  s217 :: SBool = ~ s216+  s218 :: SBool = if s121 then s217 else s216+  s219 :: SBool = ~ s218+  s220 :: SBool = if s184 then s219 else s218+  s222 :: SWord64 = s11 & s221+  s223 :: SBool = s14 /= s222+  s224 :: SBool = ~ s223+  s225 :: SBool = if s87 then s224 else s223+  s226 :: SBool = ~ s225+  s227 :: SBool = if s130 then s226 else s225+  s228 :: SBool = ~ s227+  s229 :: SBool = if s193 then s228 else s227+  s231 :: SWord64 = s11 & s230+  s232 :: SBool = s14 /= s231+  s233 :: SBool = ~ s232+  s234 :: SBool = if s94 then s233 else s232+  s235 :: SBool = ~ s234+  s236 :: SBool = if s139 then s235 else s234+  s237 :: SBool = ~ s236+  s238 :: SBool = if s202 then s237 else s236+  s240 :: SWord64 = s11 & s239+  s241 :: SBool = s14 /= s240+  s242 :: SBool = ~ s241+  s243 :: SBool = if s103 then s242 else s241+  s244 :: SBool = ~ s243+  s245 :: SBool = if s148 then s244 else s243+  s246 :: SBool = ~ s245+  s247 :: SBool = if s211 then s246 else s245+  s249 :: SWord64 = s11 & s248+  s250 :: SBool = s14 /= s249+  s251 :: SBool = ~ s250+  s252 :: SBool = if s112 then s251 else s250+  s253 :: SBool = ~ s252+  s254 :: SBool = if s157 then s253 else s252+  s255 :: SBool = ~ s254+  s256 :: SBool = if s220 then s255 else s254+  s258 :: SWord64 = s11 & s257+  s259 :: SBool = s14 /= s258+  s260 :: SBool = ~ s259+  s261 :: SBool = if s121 then s260 else s259+  s262 :: SBool = ~ s261+  s263 :: SBool = if s166 then s262 else s261+  s264 :: SBool = ~ s263+  s265 :: SBool = if s229 then s264 else s263+  s267 :: SWord64 = s11 & s266+  s268 :: SBool = s14 /= s267+  s269 :: SBool = ~ s268+  s270 :: SBool = if s130 then s269 else s268+  s271 :: SBool = ~ s270+  s272 :: SBool = if s175 then s271 else s270+  s273 :: SBool = ~ s272+  s274 :: SBool = if s238 then s273 else s272+  s276 :: SWord64 = s11 & s275+  s277 :: SBool = s14 /= s276+  s278 :: SBool = ~ s277+  s279 :: SBool = if s139 then s278 else s277+  s280 :: SBool = ~ s279+  s281 :: SBool = if s184 then s280 else s279+  s282 :: SBool = ~ s281+  s283 :: SBool = if s247 then s282 else s281+  s285 :: SWord64 = s11 & s284+  s286 :: SBool = s14 /= s285+  s287 :: SBool = ~ s286+  s288 :: SBool = if s148 then s287 else s286+  s289 :: SBool = ~ s288+  s290 :: SBool = if s193 then s289 else s288+  s291 :: SBool = ~ s290+  s292 :: SBool = if s256 then s291 else s290+  s294 :: SWord64 = s11 & s293+  s295 :: SBool = s14 /= s294+  s296 :: SBool = ~ s295+  s297 :: SBool = if s157 then s296 else s295+  s298 :: SBool = ~ s297+  s299 :: SBool = if s202 then s298 else s297+  s300 :: SBool = ~ s299+  s301 :: SBool = if s265 then s300 else s299+  s303 :: SWord64 = s11 & s302+  s304 :: SBool = s14 /= s303+  s305 :: SBool = ~ s304+  s306 :: SBool = if s166 then s305 else s304+  s307 :: SBool = ~ s306+  s308 :: SBool = if s211 then s307 else s306+  s309 :: SBool = ~ s308+  s310 :: SBool = if s274 then s309 else s308+  s312 :: SWord64 = s11 & s311+  s313 :: SBool = s14 /= s312+  s314 :: SBool = ~ s313+  s315 :: SBool = if s175 then s314 else s313+  s316 :: SBool = ~ s315+  s317 :: SBool = if s220 then s316 else s315+  s318 :: SBool = ~ s317+  s319 :: SBool = if s283 then s318 else s317+  s321 :: SWord64 = s11 & s320+  s322 :: SBool = s14 /= s321+  s323 :: SBool = ~ s322+  s324 :: SBool = if s184 then s323 else s322+  s325 :: SBool = ~ s324+  s326 :: SBool = if s229 then s325 else s324+  s327 :: SBool = ~ s326+  s328 :: SBool = if s292 then s327 else s326+  s330 :: SWord64 = s11 & s329+  s331 :: SBool = s14 /= s330+  s332 :: SBool = ~ s331+  s333 :: SBool = if s193 then s332 else s331+  s334 :: SBool = ~ s333+  s335 :: SBool = if s238 then s334 else s333+  s336 :: SBool = ~ s335+  s337 :: SBool = if s301 then s336 else s335+  s339 :: SWord64 = s11 & s338+  s340 :: SBool = s14 /= s339+  s341 :: SBool = ~ s340+  s342 :: SBool = if s202 then s341 else s340+  s343 :: SBool = ~ s342+  s344 :: SBool = if s247 then s343 else s342+  s345 :: SBool = ~ s344+  s346 :: SBool = if s310 then s345 else s344+  s348 :: SWord64 = s11 & s347+  s349 :: SBool = s14 /= s348+  s350 :: SBool = ~ s349+  s351 :: SBool = if s211 then s350 else s349+  s352 :: SBool = ~ s351+  s353 :: SBool = if s256 then s352 else s351+  s354 :: SBool = ~ s353+  s355 :: SBool = if s319 then s354 else s353+  s357 :: SWord64 = s11 & s356+  s358 :: SBool = s14 /= s357+  s359 :: SBool = ~ s358+  s360 :: SBool = if s220 then s359 else s358+  s361 :: SBool = ~ s360+  s362 :: SBool = if s265 then s361 else s360+  s363 :: SBool = ~ s362+  s364 :: SBool = if s328 then s363 else s362+  s366 :: SWord64 = s11 & s365+  s367 :: SBool = s14 /= s366+  s368 :: SBool = ~ s367+  s369 :: SBool = if s229 then s368 else s367+  s370 :: SBool = ~ s369+  s371 :: SBool = if s274 then s370 else s369+  s372 :: SBool = ~ s371+  s373 :: SBool = if s337 then s372 else s371+  s375 :: SWord64 = s11 & s374+  s376 :: SBool = s14 /= s375+  s377 :: SBool = ~ s376+  s378 :: SBool = if s238 then s377 else s376+  s379 :: SBool = ~ s378+  s380 :: SBool = if s283 then s379 else s378+  s381 :: SBool = ~ s380+  s382 :: SBool = if s346 then s381 else s380+  s383 :: SBool = ~ s15+  s384 :: SBool = if s15 then s383 else s15+  s385 :: SBool = ~ s18+  s386 :: SBool = if s18 then s385 else s18+  s387 :: SBool = ~ s21+  s388 :: SBool = if s21 then s387 else s21+  s389 :: SBool = ~ s24+  s390 :: SBool = if s24 then s389 else s24+  s391 :: SBool = ~ s29+  s392 :: SBool = if s29 then s391 else s29+  s393 :: SBool = ~ s34+  s394 :: SBool = if s34 then s393 else s34+  s395 :: SBool = ~ s39+  s396 :: SBool = if s39 then s395 else s39+  s397 :: SBool = ~ s44+  s398 :: SBool = if s44 then s397 else s44+  s399 :: SBool = ~ s49+  s400 :: SBool = if s49 then s399 else s49+  s401 :: SBool = ~ s54+  s402 :: SBool = if s54 then s401 else s54+  s403 :: SBool = ~ s59+  s404 :: SBool = if s59 then s403 else s59+  s405 :: SBool = ~ s66+  s406 :: SBool = if s66 then s405 else s66+  s407 :: SBool = ~ s73+  s408 :: SBool = if s73 then s407 else s73+  s409 :: SBool = ~ s80+  s410 :: SBool = if s80 then s409 else s80+  s411 :: SBool = ~ s87+  s412 :: SBool = if s87 then s411 else s87+  s413 :: SBool = ~ s94+  s414 :: SBool = if s94 then s413 else s94+  s415 :: SBool = ~ s103+  s416 :: SBool = if s103 then s415 else s103+  s417 :: SBool = ~ s112+  s418 :: SBool = if s112 then s417 else s112+  s419 :: SBool = ~ s121+  s420 :: SBool = if s121 then s419 else s121+  s421 :: SBool = ~ s130+  s422 :: SBool = if s130 then s421 else s130+  s423 :: SBool = ~ s139+  s424 :: SBool = if s139 then s423 else s139+  s425 :: SBool = ~ s148+  s426 :: SBool = if s148 then s425 else s148+  s427 :: SBool = ~ s157+  s428 :: SBool = if s157 then s427 else s157+  s429 :: SBool = ~ s166+  s430 :: SBool = if s166 then s429 else s166+  s431 :: SBool = ~ s175+  s432 :: SBool = if s175 then s431 else s175+  s433 :: SBool = ~ s184+  s434 :: SBool = if s184 then s433 else s184+  s435 :: SBool = ~ s193+  s436 :: SBool = if s193 then s435 else s193+  s437 :: SBool = ~ s202+  s438 :: SBool = if s202 then s437 else s202+  s439 :: SBool = ~ s211+  s440 :: SBool = if s211 then s439 else s211+  s441 :: SBool = ~ s220+  s442 :: SBool = if s220 then s441 else s220+  s443 :: SBool = ~ s229+  s444 :: SBool = if s229 then s443 else s229+  s445 :: SBool = ~ s238+  s446 :: SBool = if s238 then s445 else s238+  s447 :: SBool = ~ s247+  s448 :: SBool = if s247 then s447 else s247+  s449 :: SBool = ~ s256+  s450 :: SBool = if s256 then s449 else s256+  s451 :: SBool = ~ s265+  s452 :: SBool = if s265 then s451 else s265+  s453 :: SBool = ~ s274+  s454 :: SBool = if s274 then s453 else s274+  s455 :: SBool = ~ s283+  s456 :: SBool = if s283 then s455 else s283+  s457 :: SBool = ~ s292+  s458 :: SBool = if s292 then s457 else s292+  s459 :: SBool = ~ s301+  s460 :: SBool = if s301 then s459 else s301+  s461 :: SBool = ~ s310+  s462 :: SBool = if s310 then s461 else s310+  s463 :: SBool = ~ s319+  s464 :: SBool = if s319 then s463 else s319+  s465 :: SBool = ~ s328+  s466 :: SBool = if s328 then s465 else s328+  s467 :: SBool = ~ s337+  s468 :: SBool = if s337 then s467 else s337+  s469 :: SBool = ~ s346+  s470 :: SBool = if s346 then s469 else s346+  s471 :: SBool = ~ s355+  s472 :: SBool = if s355 then s471 else s355+  s473 :: SBool = ~ s364+  s474 :: SBool = if s364 then s473 else s364+  s475 :: SBool = ~ s373+  s476 :: SBool = if s373 then s475 else s373+  s477 :: SBool = ~ s382+  s478 :: SBool = if s382 then s477 else s382+  s480 :: SWord64 = s11 & s479+  s481 :: SBool = s14 /= s480+  s482 :: SBool = ~ s481+  s483 :: SBool = if s247 then s482 else s481+  s484 :: SBool = ~ s483+  s485 :: SBool = if s292 then s484 else s483+  s486 :: SBool = ~ s485+  s487 :: SBool = if s355 then s486 else s485+  s489 :: SWord64 = s11 & s488+  s490 :: SBool = s14 /= s489+  s491 :: SBool = ~ s490+  s492 :: SBool = if s256 then s491 else s490+  s493 :: SBool = ~ s492+  s494 :: SBool = if s301 then s493 else s492+  s495 :: SBool = ~ s494+  s496 :: SBool = if s364 then s495 else s494+  s498 :: SWord64 = s11 & s497+  s499 :: SBool = s14 /= s498+  s500 :: SBool = ~ s499+  s501 :: SBool = if s265 then s500 else s499+  s502 :: SBool = ~ s501+  s503 :: SBool = if s310 then s502 else s501+  s504 :: SBool = ~ s503+  s505 :: SBool = if s373 then s504 else s503+  s507 :: SWord64 = s11 & s506+  s508 :: SBool = s14 /= s507+  s509 :: SBool = ~ s508+  s510 :: SBool = if s274 then s509 else s508+  s511 :: SBool = ~ s510+  s512 :: SBool = if s319 then s511 else s510+  s513 :: SBool = ~ s512+  s514 :: SBool = if s382 then s513 else s512+  s516 :: SWord64 = s11 & s515+  s517 :: SBool = s14 /= s516+  s518 :: SBool = ~ s517+  s519 :: SBool = if s283 then s518 else s517+  s520 :: SBool = ~ s519+  s521 :: SBool = if s328 then s520 else s519+  s523 :: SWord64 = s11 & s522+  s524 :: SBool = s14 /= s523+  s525 :: SBool = ~ s524+  s526 :: SBool = if s292 then s525 else s524+  s527 :: SBool = ~ s526+  s528 :: SBool = if s337 then s527 else s526+  s530 :: SWord64 = s11 & s529+  s531 :: SBool = s14 /= s530+  s532 :: SBool = ~ s531+  s533 :: SBool = if s301 then s532 else s531+  s534 :: SBool = ~ s533+  s535 :: SBool = if s346 then s534 else s533+  s537 :: SWord64 = s11 & s536+  s538 :: SBool = s14 /= s537+  s539 :: SBool = ~ s538+  s540 :: SBool = if s310 then s539 else s538+  s541 :: SBool = ~ s540+  s542 :: SBool = if s355 then s541 else s540+  s544 :: SWord64 = s11 & s543+  s545 :: SBool = s14 /= s544+  s546 :: SBool = ~ s545+  s547 :: SBool = if s319 then s546 else s545+  s548 :: SBool = ~ s547+  s549 :: SBool = if s364 then s548 else s547+  s551 :: SWord64 = s11 & s550+  s552 :: SBool = s14 /= s551+  s553 :: SBool = ~ s552+  s554 :: SBool = if s328 then s553 else s552+  s555 :: SBool = ~ s554+  s556 :: SBool = if s373 then s555 else s554+  s558 :: SWord64 = s11 & s557+  s559 :: SBool = s14 /= s558+  s560 :: SBool = ~ s559+  s561 :: SBool = if s337 then s560 else s559+  s562 :: SBool = ~ s561+  s563 :: SBool = if s382 then s562 else s561+  s565 :: SWord64 = s11 & s564+  s566 :: SBool = s14 /= s565+  s567 :: SBool = ~ s566+  s568 :: SBool = if s346 then s567 else s566+  s570 :: SWord64 = s11 & s569+  s571 :: SBool = s14 /= s570+  s572 :: SBool = ~ s571+  s573 :: SBool = if s355 then s572 else s571+  s575 :: SWord64 = s11 & s574+  s576 :: SBool = s14 /= s575+  s577 :: SBool = ~ s576+  s578 :: SBool = if s364 then s577 else s576+  s580 :: SWord64 = s11 & s579+  s581 :: SBool = s14 /= s580+  s582 :: SBool = ~ s581+  s583 :: SBool = if s373 then s582 else s581+  s585 :: SWord64 = s11 & s584+  s586 :: SBool = s14 /= s585+  s587 :: SBool = ~ s586+  s588 :: SBool = if s382 then s587 else s586+  s589 :: SWord64 = if s588 then s584 else s14+  s590 :: SWord64 = s579 | s589+  s591 :: SWord64 = if s583 then s590 else s589+  s592 :: SWord64 = s574 | s591+  s593 :: SWord64 = if s578 then s592 else s591+  s594 :: SWord64 = s569 | s593+  s595 :: SWord64 = if s573 then s594 else s593+  s596 :: SWord64 = s564 | s595+  s597 :: SWord64 = if s568 then s596 else s595+  s598 :: SWord64 = s557 | s597+  s599 :: SWord64 = if s563 then s598 else s597+  s600 :: SWord64 = s550 | s599+  s601 :: SWord64 = if s556 then s600 else s599+  s602 :: SWord64 = s543 | s601+  s603 :: SWord64 = if s549 then s602 else s601+  s604 :: SWord64 = s536 | s603+  s605 :: SWord64 = if s542 then s604 else s603+  s606 :: SWord64 = s529 | s605+  s607 :: SWord64 = if s535 then s606 else s605+  s608 :: SWord64 = s522 | s607+  s609 :: SWord64 = if s528 then s608 else s607+  s610 :: SWord64 = s515 | s609+  s611 :: SWord64 = if s521 then s610 else s609+  s612 :: SWord64 = s506 | s611+  s613 :: SWord64 = if s514 then s612 else s611+  s614 :: SWord64 = s497 | s613+  s615 :: SWord64 = if s505 then s614 else s613+  s616 :: SWord64 = s488 | s615+  s617 :: SWord64 = if s496 then s616 else s615+  s618 :: SWord64 = s479 | s617+  s619 :: SWord64 = if s487 then s618 else s617+  s620 :: SWord64 = s374 | s619+  s621 :: SWord64 = if s478 then s620 else s619+  s622 :: SWord64 = s365 | s621+  s623 :: SWord64 = if s476 then s622 else s621+  s624 :: SWord64 = s356 | s623+  s625 :: SWord64 = if s474 then s624 else s623+  s626 :: SWord64 = s347 | s625+  s627 :: SWord64 = if s472 then s626 else s625+  s628 :: SWord64 = s338 | s627+  s629 :: SWord64 = if s470 then s628 else s627+  s630 :: SWord64 = s329 | s629+  s631 :: SWord64 = if s468 then s630 else s629+  s632 :: SWord64 = s320 | s631+  s633 :: SWord64 = if s466 then s632 else s631+  s634 :: SWord64 = s311 | s633+  s635 :: SWord64 = if s464 then s634 else s633+  s636 :: SWord64 = s302 | s635+  s637 :: SWord64 = if s462 then s636 else s635+  s638 :: SWord64 = s293 | s637+  s639 :: SWord64 = if s460 then s638 else s637+  s640 :: SWord64 = s284 | s639+  s641 :: SWord64 = if s458 then s640 else s639+  s642 :: SWord64 = s275 | s641+  s643 :: SWord64 = if s456 then s642 else s641+  s644 :: SWord64 = s266 | s643+  s645 :: SWord64 = if s454 then s644 else s643+  s646 :: SWord64 = s257 | s645+  s647 :: SWord64 = if s452 then s646 else s645+  s648 :: SWord64 = s248 | s647+  s649 :: SWord64 = if s450 then s648 else s647+  s650 :: SWord64 = s239 | s649+  s651 :: SWord64 = if s448 then s650 else s649+  s652 :: SWord64 = s230 | s651+  s653 :: SWord64 = if s446 then s652 else s651+  s654 :: SWord64 = s221 | s653+  s655 :: SWord64 = if s444 then s654 else s653+  s656 :: SWord64 = s212 | s655+  s657 :: SWord64 = if s442 then s656 else s655+  s658 :: SWord64 = s203 | s657+  s659 :: SWord64 = if s440 then s658 else s657+  s660 :: SWord64 = s194 | s659+  s661 :: SWord64 = if s438 then s660 else s659+  s662 :: SWord64 = s185 | s661+  s663 :: SWord64 = if s436 then s662 else s661+  s664 :: SWord64 = s176 | s663+  s665 :: SWord64 = if s434 then s664 else s663+  s666 :: SWord64 = s167 | s665+  s667 :: SWord64 = if s432 then s666 else s665+  s668 :: SWord64 = s158 | s667+  s669 :: SWord64 = if s430 then s668 else s667+  s670 :: SWord64 = s149 | s669+  s671 :: SWord64 = if s428 then s670 else s669+  s672 :: SWord64 = s140 | s671+  s673 :: SWord64 = if s426 then s672 else s671+  s674 :: SWord64 = s131 | s673+  s675 :: SWord64 = if s424 then s674 else s673+  s676 :: SWord64 = s122 | s675+  s677 :: SWord64 = if s422 then s676 else s675+  s678 :: SWord64 = s113 | s677+  s679 :: SWord64 = if s420 then s678 else s677+  s680 :: SWord64 = s104 | s679+  s681 :: SWord64 = if s418 then s680 else s679+  s682 :: SWord64 = s95 | s681+  s683 :: SWord64 = if s416 then s682 else s681+  s684 :: SWord64 = s88 | s683+  s685 :: SWord64 = if s414 then s684 else s683+  s686 :: SWord64 = s81 | s685+  s687 :: SWord64 = if s412 then s686 else s685+  s688 :: SWord64 = s74 | s687+  s689 :: SWord64 = if s410 then s688 else s687+  s690 :: SWord64 = s67 | s689+  s691 :: SWord64 = if s408 then s690 else s689+  s692 :: SWord64 = s60 | s691+  s693 :: SWord64 = if s406 then s692 else s691+  s694 :: SWord64 = s55 | s693+  s695 :: SWord64 = if s404 then s694 else s693+  s696 :: SWord64 = s50 | s695+  s697 :: SWord64 = if s402 then s696 else s695+  s698 :: SWord64 = s45 | s697+  s699 :: SWord64 = if s400 then s698 else s697+  s700 :: SWord64 = s40 | s699+  s701 :: SWord64 = if s398 then s700 else s699+  s702 :: SWord64 = s35 | s701+  s703 :: SWord64 = if s396 then s702 else s701+  s704 :: SWord64 = s30 | s703+  s705 :: SWord64 = if s394 then s704 else s703+  s706 :: SWord64 = s25 | s705+  s707 :: SWord64 = if s392 then s706 else s705+  s708 :: SWord64 = s22 | s707+  s709 :: SWord64 = if s390 then s708 else s707+  s710 :: SWord64 = s19 | s709+  s711 :: SWord64 = if s388 then s710 else s709+  s712 :: SWord64 = s16 | s711+  s713 :: SWord64 = if s386 then s712 else s711+  s714 :: SWord64 = s12 | s713+  s715 :: SWord64 = if s384 then s714 else s713+  s716 :: SWord32 = choose [31:0] s715+  s717 :: SWord16 = choose [15:0] s716+  s718 :: SWord32 = s1 # s717+  s719 :: SWord64 = s0 # s718+  s720 :: SWord64 = s584 & s719+  s721 :: SBool = s14 /= s720+  s722 :: SWord32 = s3 # s9+  s723 :: SWord64 = s2 # s722+  s724 :: SWord64 = s12 & s723+  s725 :: SBool = s14 /= s724+  s726 :: SWord64 = s16 & s723+  s727 :: SBool = s14 /= s726+  s728 :: SWord64 = s19 & s723+  s729 :: SBool = s14 /= s728+  s730 :: SWord64 = s22 & s723+  s731 :: SBool = s14 /= s730+  s732 :: SWord64 = s25 & s723+  s733 :: SBool = s14 /= s732+  s734 :: SBool = ~ s733+  s735 :: SBool = if s725 then s734 else s733+  s736 :: SWord64 = s30 & s723+  s737 :: SBool = s14 /= s736+  s738 :: SBool = ~ s737+  s739 :: SBool = if s727 then s738 else s737+  s740 :: SWord64 = s35 & s723+  s741 :: SBool = s14 /= s740+  s742 :: SBool = ~ s741+  s743 :: SBool = if s729 then s742 else s741+  s744 :: SWord64 = s40 & s723+  s745 :: SBool = s14 /= s744+  s746 :: SBool = ~ s745+  s747 :: SBool = if s731 then s746 else s745+  s748 :: SWord64 = s45 & s723+  s749 :: SBool = s14 /= s748+  s750 :: SBool = ~ s749+  s751 :: SBool = if s735 then s750 else s749+  s752 :: SWord64 = s50 & s723+  s753 :: SBool = s14 /= s752+  s754 :: SBool = ~ s753+  s755 :: SBool = if s739 then s754 else s753+  s756 :: SWord64 = s55 & s723+  s757 :: SBool = s14 /= s756+  s758 :: SBool = ~ s757+  s759 :: SBool = if s743 then s758 else s757+  s760 :: SWord64 = s60 & s723+  s761 :: SBool = s14 /= s760+  s762 :: SBool = ~ s761+  s763 :: SBool = if s725 then s762 else s761+  s764 :: SBool = ~ s763+  s765 :: SBool = if s747 then s764 else s763+  s766 :: SWord64 = s67 & s723+  s767 :: SBool = s14 /= s766+  s768 :: SBool = ~ s767+  s769 :: SBool = if s727 then s768 else s767+  s770 :: SBool = ~ s769+  s771 :: SBool = if s751 then s770 else s769+  s772 :: SWord64 = s74 & s723+  s773 :: SBool = s14 /= s772+  s774 :: SBool = ~ s773+  s775 :: SBool = if s729 then s774 else s773+  s776 :: SBool = ~ s775+  s777 :: SBool = if s755 then s776 else s775+  s778 :: SWord64 = s81 & s723+  s779 :: SBool = s14 /= s778+  s780 :: SBool = ~ s779+  s781 :: SBool = if s731 then s780 else s779+  s782 :: SBool = ~ s781+  s783 :: SBool = if s759 then s782 else s781+  s784 :: SWord64 = s88 & s723+  s785 :: SBool = s14 /= s784+  s786 :: SBool = ~ s785+  s787 :: SBool = if s735 then s786 else s785+  s788 :: SBool = ~ s787+  s789 :: SBool = if s765 then s788 else s787+  s790 :: SWord64 = s95 & s723+  s791 :: SBool = s14 /= s790+  s792 :: SBool = ~ s791+  s793 :: SBool = if s725 then s792 else s791+  s794 :: SBool = ~ s793+  s795 :: SBool = if s739 then s794 else s793+  s796 :: SBool = ~ s795+  s797 :: SBool = if s771 then s796 else s795+  s798 :: SWord64 = s104 & s723+  s799 :: SBool = s14 /= s798+  s800 :: SBool = ~ s799+  s801 :: SBool = if s727 then s800 else s799+  s802 :: SBool = ~ s801+  s803 :: SBool = if s743 then s802 else s801+  s804 :: SBool = ~ s803+  s805 :: SBool = if s777 then s804 else s803+  s806 :: SWord64 = s113 & s723+  s807 :: SBool = s14 /= s806+  s808 :: SBool = ~ s807+  s809 :: SBool = if s729 then s808 else s807+  s810 :: SBool = ~ s809+  s811 :: SBool = if s747 then s810 else s809+  s812 :: SBool = ~ s811+  s813 :: SBool = if s783 then s812 else s811+  s814 :: SWord64 = s122 & s723+  s815 :: SBool = s14 /= s814+  s816 :: SBool = ~ s815+  s817 :: SBool = if s731 then s816 else s815+  s818 :: SBool = ~ s817+  s819 :: SBool = if s751 then s818 else s817+  s820 :: SBool = ~ s819+  s821 :: SBool = if s789 then s820 else s819+  s822 :: SWord64 = s131 & s723+  s823 :: SBool = s14 /= s822+  s824 :: SBool = ~ s823+  s825 :: SBool = if s735 then s824 else s823+  s826 :: SBool = ~ s825+  s827 :: SBool = if s755 then s826 else s825+  s828 :: SBool = ~ s827+  s829 :: SBool = if s797 then s828 else s827+  s830 :: SWord64 = s140 & s723+  s831 :: SBool = s14 /= s830+  s832 :: SBool = ~ s831+  s833 :: SBool = if s739 then s832 else s831+  s834 :: SBool = ~ s833+  s835 :: SBool = if s759 then s834 else s833+  s836 :: SBool = ~ s835+  s837 :: SBool = if s805 then s836 else s835+  s838 :: SWord64 = s149 & s723+  s839 :: SBool = s14 /= s838+  s840 :: SBool = ~ s839+  s841 :: SBool = if s743 then s840 else s839+  s842 :: SBool = ~ s841+  s843 :: SBool = if s765 then s842 else s841+  s844 :: SBool = ~ s843+  s845 :: SBool = if s813 then s844 else s843+  s846 :: SWord64 = s158 & s723+  s847 :: SBool = s14 /= s846+  s848 :: SBool = ~ s847+  s849 :: SBool = if s747 then s848 else s847+  s850 :: SBool = ~ s849+  s851 :: SBool = if s771 then s850 else s849+  s852 :: SBool = ~ s851+  s853 :: SBool = if s821 then s852 else s851+  s854 :: SWord64 = s167 & s723+  s855 :: SBool = s14 /= s854+  s856 :: SBool = ~ s855+  s857 :: SBool = if s751 then s856 else s855+  s858 :: SBool = ~ s857+  s859 :: SBool = if s777 then s858 else s857+  s860 :: SBool = ~ s859+  s861 :: SBool = if s829 then s860 else s859+  s862 :: SWord64 = s176 & s723+  s863 :: SBool = s14 /= s862+  s864 :: SBool = ~ s863+  s865 :: SBool = if s755 then s864 else s863+  s866 :: SBool = ~ s865+  s867 :: SBool = if s783 then s866 else s865+  s868 :: SBool = ~ s867+  s869 :: SBool = if s837 then s868 else s867+  s870 :: SWord64 = s185 & s723+  s871 :: SBool = s14 /= s870+  s872 :: SBool = ~ s871+  s873 :: SBool = if s759 then s872 else s871+  s874 :: SBool = ~ s873+  s875 :: SBool = if s789 then s874 else s873+  s876 :: SBool = ~ s875+  s877 :: SBool = if s845 then s876 else s875+  s878 :: SWord64 = s194 & s723+  s879 :: SBool = s14 /= s878+  s880 :: SBool = ~ s879+  s881 :: SBool = if s765 then s880 else s879+  s882 :: SBool = ~ s881+  s883 :: SBool = if s797 then s882 else s881+  s884 :: SBool = ~ s883+  s885 :: SBool = if s853 then s884 else s883+  s886 :: SWord64 = s203 & s723+  s887 :: SBool = s14 /= s886+  s888 :: SBool = ~ s887+  s889 :: SBool = if s771 then s888 else s887+  s890 :: SBool = ~ s889+  s891 :: SBool = if s805 then s890 else s889+  s892 :: SBool = ~ s891+  s893 :: SBool = if s861 then s892 else s891+  s894 :: SWord64 = s212 & s723+  s895 :: SBool = s14 /= s894+  s896 :: SBool = ~ s895+  s897 :: SBool = if s777 then s896 else s895+  s898 :: SBool = ~ s897+  s899 :: SBool = if s813 then s898 else s897+  s900 :: SBool = ~ s899+  s901 :: SBool = if s869 then s900 else s899+  s902 :: SWord64 = s221 & s723+  s903 :: SBool = s14 /= s902+  s904 :: SBool = ~ s903+  s905 :: SBool = if s783 then s904 else s903+  s906 :: SBool = ~ s905+  s907 :: SBool = if s821 then s906 else s905+  s908 :: SBool = ~ s907+  s909 :: SBool = if s877 then s908 else s907+  s910 :: SWord64 = s230 & s723+  s911 :: SBool = s14 /= s910+  s912 :: SBool = ~ s911+  s913 :: SBool = if s789 then s912 else s911+  s914 :: SBool = ~ s913+  s915 :: SBool = if s829 then s914 else s913+  s916 :: SBool = ~ s915+  s917 :: SBool = if s885 then s916 else s915+  s918 :: SWord64 = s239 & s723+  s919 :: SBool = s14 /= s918+  s920 :: SBool = ~ s919+  s921 :: SBool = if s797 then s920 else s919+  s922 :: SBool = ~ s921+  s923 :: SBool = if s837 then s922 else s921+  s924 :: SBool = ~ s923+  s925 :: SBool = if s893 then s924 else s923+  s926 :: SWord64 = s248 & s723+  s927 :: SBool = s14 /= s926+  s928 :: SBool = ~ s927+  s929 :: SBool = if s805 then s928 else s927+  s930 :: SBool = ~ s929+  s931 :: SBool = if s845 then s930 else s929+  s932 :: SBool = ~ s931+  s933 :: SBool = if s901 then s932 else s931+  s934 :: SWord64 = s257 & s723+  s935 :: SBool = s14 /= s934+  s936 :: SBool = ~ s935+  s937 :: SBool = if s813 then s936 else s935+  s938 :: SBool = ~ s937+  s939 :: SBool = if s853 then s938 else s937+  s940 :: SBool = ~ s939+  s941 :: SBool = if s909 then s940 else s939+  s942 :: SWord64 = s266 & s723+  s943 :: SBool = s14 /= s942+  s944 :: SBool = ~ s943+  s945 :: SBool = if s821 then s944 else s943+  s946 :: SBool = ~ s945+  s947 :: SBool = if s861 then s946 else s945+  s948 :: SBool = ~ s947+  s949 :: SBool = if s917 then s948 else s947+  s950 :: SWord64 = s275 & s723+  s951 :: SBool = s14 /= s950+  s952 :: SBool = ~ s951+  s953 :: SBool = if s829 then s952 else s951+  s954 :: SBool = ~ s953+  s955 :: SBool = if s869 then s954 else s953+  s956 :: SBool = ~ s955+  s957 :: SBool = if s925 then s956 else s955+  s958 :: SWord64 = s284 & s723+  s959 :: SBool = s14 /= s958+  s960 :: SBool = ~ s959+  s961 :: SBool = if s837 then s960 else s959+  s962 :: SBool = ~ s961+  s963 :: SBool = if s877 then s962 else s961+  s964 :: SBool = ~ s963+  s965 :: SBool = if s933 then s964 else s963+  s966 :: SWord64 = s293 & s723+  s967 :: SBool = s14 /= s966+  s968 :: SBool = ~ s967+  s969 :: SBool = if s845 then s968 else s967+  s970 :: SBool = ~ s969+  s971 :: SBool = if s885 then s970 else s969+  s972 :: SBool = ~ s971+  s973 :: SBool = if s941 then s972 else s971+  s974 :: SWord64 = s302 & s723+  s975 :: SBool = s14 /= s974+  s976 :: SBool = ~ s975+  s977 :: SBool = if s853 then s976 else s975+  s978 :: SBool = ~ s977+  s979 :: SBool = if s893 then s978 else s977+  s980 :: SBool = ~ s979+  s981 :: SBool = if s949 then s980 else s979+  s982 :: SWord64 = s311 & s723+  s983 :: SBool = s14 /= s982+  s984 :: SBool = ~ s983+  s985 :: SBool = if s861 then s984 else s983+  s986 :: SBool = ~ s985+  s987 :: SBool = if s901 then s986 else s985+  s988 :: SBool = ~ s987+  s989 :: SBool = if s957 then s988 else s987+  s990 :: SWord64 = s320 & s723+  s991 :: SBool = s14 /= s990+  s992 :: SBool = ~ s991+  s993 :: SBool = if s869 then s992 else s991+  s994 :: SBool = ~ s993+  s995 :: SBool = if s909 then s994 else s993+  s996 :: SBool = ~ s995+  s997 :: SBool = if s965 then s996 else s995+  s998 :: SWord64 = s329 & s723+  s999 :: SBool = s14 /= s998+  s1000 :: SBool = ~ s999+  s1001 :: SBool = if s877 then s1000 else s999+  s1002 :: SBool = ~ s1001+  s1003 :: SBool = if s917 then s1002 else s1001+  s1004 :: SBool = ~ s1003+  s1005 :: SBool = if s973 then s1004 else s1003+  s1006 :: SWord64 = s338 & s723+  s1007 :: SBool = s14 /= s1006+  s1008 :: SBool = ~ s1007+  s1009 :: SBool = if s885 then s1008 else s1007+  s1010 :: SBool = ~ s1009+  s1011 :: SBool = if s925 then s1010 else s1009+  s1012 :: SBool = ~ s1011+  s1013 :: SBool = if s981 then s1012 else s1011+  s1014 :: SWord64 = s347 & s723+  s1015 :: SBool = s14 /= s1014+  s1016 :: SBool = ~ s1015+  s1017 :: SBool = if s893 then s1016 else s1015+  s1018 :: SBool = ~ s1017+  s1019 :: SBool = if s933 then s1018 else s1017+  s1020 :: SBool = ~ s1019+  s1021 :: SBool = if s989 then s1020 else s1019+  s1022 :: SWord64 = s356 & s723+  s1023 :: SBool = s14 /= s1022+  s1024 :: SBool = ~ s1023+  s1025 :: SBool = if s901 then s1024 else s1023+  s1026 :: SBool = ~ s1025+  s1027 :: SBool = if s941 then s1026 else s1025+  s1028 :: SBool = ~ s1027+  s1029 :: SBool = if s997 then s1028 else s1027+  s1030 :: SWord64 = s365 & s723+  s1031 :: SBool = s14 /= s1030+  s1032 :: SBool = ~ s1031+  s1033 :: SBool = if s909 then s1032 else s1031+  s1034 :: SBool = ~ s1033+  s1035 :: SBool = if s949 then s1034 else s1033+  s1036 :: SBool = ~ s1035+  s1037 :: SBool = if s1005 then s1036 else s1035+  s1038 :: SWord64 = s374 & s723+  s1039 :: SBool = s14 /= s1038+  s1040 :: SBool = ~ s1039+  s1041 :: SBool = if s917 then s1040 else s1039+  s1042 :: SBool = ~ s1041+  s1043 :: SBool = if s957 then s1042 else s1041+  s1044 :: SBool = ~ s1043+  s1045 :: SBool = if s1013 then s1044 else s1043+  s1046 :: SBool = ~ s725+  s1047 :: SBool = if s725 then s1046 else s725+  s1048 :: SBool = ~ s727+  s1049 :: SBool = if s727 then s1048 else s727+  s1050 :: SBool = ~ s729+  s1051 :: SBool = if s729 then s1050 else s729+  s1052 :: SBool = ~ s731+  s1053 :: SBool = if s731 then s1052 else s731+  s1054 :: SBool = ~ s735+  s1055 :: SBool = if s735 then s1054 else s735+  s1056 :: SBool = ~ s739+  s1057 :: SBool = if s739 then s1056 else s739+  s1058 :: SBool = ~ s743+  s1059 :: SBool = if s743 then s1058 else s743+  s1060 :: SBool = ~ s747+  s1061 :: SBool = if s747 then s1060 else s747+  s1062 :: SBool = ~ s751+  s1063 :: SBool = if s751 then s1062 else s751+  s1064 :: SBool = ~ s755+  s1065 :: SBool = if s755 then s1064 else s755+  s1066 :: SBool = ~ s759+  s1067 :: SBool = if s759 then s1066 else s759+  s1068 :: SBool = ~ s765+  s1069 :: SBool = if s765 then s1068 else s765+  s1070 :: SBool = ~ s771+  s1071 :: SBool = if s771 then s1070 else s771+  s1072 :: SBool = ~ s777+  s1073 :: SBool = if s777 then s1072 else s777+  s1074 :: SBool = ~ s783+  s1075 :: SBool = if s783 then s1074 else s783+  s1076 :: SBool = ~ s789+  s1077 :: SBool = if s789 then s1076 else s789+  s1078 :: SBool = ~ s797+  s1079 :: SBool = if s797 then s1078 else s797+  s1080 :: SBool = ~ s805+  s1081 :: SBool = if s805 then s1080 else s805+  s1082 :: SBool = ~ s813+  s1083 :: SBool = if s813 then s1082 else s813+  s1084 :: SBool = ~ s821+  s1085 :: SBool = if s821 then s1084 else s821+  s1086 :: SBool = ~ s829+  s1087 :: SBool = if s829 then s1086 else s829+  s1088 :: SBool = ~ s837+  s1089 :: SBool = if s837 then s1088 else s837+  s1090 :: SBool = ~ s845+  s1091 :: SBool = if s845 then s1090 else s845+  s1092 :: SBool = ~ s853+  s1093 :: SBool = if s853 then s1092 else s853+  s1094 :: SBool = ~ s861+  s1095 :: SBool = if s861 then s1094 else s861+  s1096 :: SBool = ~ s869+  s1097 :: SBool = if s869 then s1096 else s869+  s1098 :: SBool = ~ s877+  s1099 :: SBool = if s877 then s1098 else s877+  s1100 :: SBool = ~ s885+  s1101 :: SBool = if s885 then s1100 else s885+  s1102 :: SBool = ~ s893+  s1103 :: SBool = if s893 then s1102 else s893+  s1104 :: SBool = ~ s901+  s1105 :: SBool = if s901 then s1104 else s901+  s1106 :: SBool = ~ s909+  s1107 :: SBool = if s909 then s1106 else s909+  s1108 :: SBool = ~ s917+  s1109 :: SBool = if s917 then s1108 else s917+  s1110 :: SBool = ~ s925+  s1111 :: SBool = if s925 then s1110 else s925+  s1112 :: SBool = ~ s933+  s1113 :: SBool = if s933 then s1112 else s933+  s1114 :: SBool = ~ s941+  s1115 :: SBool = if s941 then s1114 else s941+  s1116 :: SBool = ~ s949+  s1117 :: SBool = if s949 then s1116 else s949+  s1118 :: SBool = ~ s957+  s1119 :: SBool = if s957 then s1118 else s957+  s1120 :: SBool = ~ s965+  s1121 :: SBool = if s965 then s1120 else s965+  s1122 :: SBool = ~ s973+  s1123 :: SBool = if s973 then s1122 else s973+  s1124 :: SBool = ~ s981+  s1125 :: SBool = if s981 then s1124 else s981+  s1126 :: SBool = ~ s989+  s1127 :: SBool = if s989 then s1126 else s989+  s1128 :: SBool = ~ s997+  s1129 :: SBool = if s997 then s1128 else s997+  s1130 :: SBool = ~ s1005+  s1131 :: SBool = if s1005 then s1130 else s1005+  s1132 :: SBool = ~ s1013+  s1133 :: SBool = if s1013 then s1132 else s1013+  s1134 :: SBool = ~ s1021+  s1135 :: SBool = if s1021 then s1134 else s1021+  s1136 :: SBool = ~ s1029+  s1137 :: SBool = if s1029 then s1136 else s1029+  s1138 :: SBool = ~ s1037+  s1139 :: SBool = if s1037 then s1138 else s1037+  s1140 :: SBool = ~ s1045+  s1141 :: SBool = if s1045 then s1140 else s1045+  s1142 :: SWord64 = s479 & s723+  s1143 :: SBool = s14 /= s1142+  s1144 :: SBool = ~ s1143+  s1145 :: SBool = if s925 then s1144 else s1143+  s1146 :: SBool = ~ s1145+  s1147 :: SBool = if s965 then s1146 else s1145+  s1148 :: SBool = ~ s1147+  s1149 :: SBool = if s1021 then s1148 else s1147+  s1150 :: SWord64 = s488 & s723+  s1151 :: SBool = s14 /= s1150+  s1152 :: SBool = ~ s1151+  s1153 :: SBool = if s933 then s1152 else s1151+  s1154 :: SBool = ~ s1153+  s1155 :: SBool = if s973 then s1154 else s1153+  s1156 :: SBool = ~ s1155+  s1157 :: SBool = if s1029 then s1156 else s1155+  s1158 :: SWord64 = s497 & s723+  s1159 :: SBool = s14 /= s1158+  s1160 :: SBool = ~ s1159+  s1161 :: SBool = if s941 then s1160 else s1159+  s1162 :: SBool = ~ s1161+  s1163 :: SBool = if s981 then s1162 else s1161+  s1164 :: SBool = ~ s1163+  s1165 :: SBool = if s1037 then s1164 else s1163+  s1166 :: SWord64 = s506 & s723+  s1167 :: SBool = s14 /= s1166+  s1168 :: SBool = ~ s1167+  s1169 :: SBool = if s949 then s1168 else s1167+  s1170 :: SBool = ~ s1169+  s1171 :: SBool = if s989 then s1170 else s1169+  s1172 :: SBool = ~ s1171+  s1173 :: SBool = if s1045 then s1172 else s1171+  s1174 :: SWord64 = s515 & s723+  s1175 :: SBool = s14 /= s1174+  s1176 :: SBool = ~ s1175+  s1177 :: SBool = if s957 then s1176 else s1175+  s1178 :: SBool = ~ s1177+  s1179 :: SBool = if s997 then s1178 else s1177+  s1180 :: SWord64 = s522 & s723+  s1181 :: SBool = s14 /= s1180+  s1182 :: SBool = ~ s1181+  s1183 :: SBool = if s965 then s1182 else s1181+  s1184 :: SBool = ~ s1183+  s1185 :: SBool = if s1005 then s1184 else s1183+  s1186 :: SWord64 = s529 & s723+  s1187 :: SBool = s14 /= s1186+  s1188 :: SBool = ~ s1187+  s1189 :: SBool = if s973 then s1188 else s1187+  s1190 :: SBool = ~ s1189+  s1191 :: SBool = if s1013 then s1190 else s1189+  s1192 :: SWord64 = s536 & s723+  s1193 :: SBool = s14 /= s1192+  s1194 :: SBool = ~ s1193+  s1195 :: SBool = if s981 then s1194 else s1193+  s1196 :: SBool = ~ s1195+  s1197 :: SBool = if s1021 then s1196 else s1195+  s1198 :: SWord64 = s543 & s723+  s1199 :: SBool = s14 /= s1198+  s1200 :: SBool = ~ s1199+  s1201 :: SBool = if s989 then s1200 else s1199+  s1202 :: SBool = ~ s1201+  s1203 :: SBool = if s1029 then s1202 else s1201+  s1204 :: SWord64 = s550 & s723+  s1205 :: SBool = s14 /= s1204+  s1206 :: SBool = ~ s1205+  s1207 :: SBool = if s997 then s1206 else s1205+  s1208 :: SBool = ~ s1207+  s1209 :: SBool = if s1037 then s1208 else s1207+  s1210 :: SWord64 = s557 & s723+  s1211 :: SBool = s14 /= s1210+  s1212 :: SBool = ~ s1211+  s1213 :: SBool = if s1005 then s1212 else s1211+  s1214 :: SBool = ~ s1213+  s1215 :: SBool = if s1045 then s1214 else s1213+  s1216 :: SWord64 = s564 & s723+  s1217 :: SBool = s14 /= s1216+  s1218 :: SBool = ~ s1217+  s1219 :: SBool = if s1013 then s1218 else s1217+  s1220 :: SWord64 = s569 & s723+  s1221 :: SBool = s14 /= s1220+  s1222 :: SBool = ~ s1221+  s1223 :: SBool = if s1021 then s1222 else s1221+  s1224 :: SWord64 = s574 & s723+  s1225 :: SBool = s14 /= s1224+  s1226 :: SBool = ~ s1225+  s1227 :: SBool = if s1029 then s1226 else s1225+  s1228 :: SWord64 = s579 & s723+  s1229 :: SBool = s14 /= s1228+  s1230 :: SBool = ~ s1229+  s1231 :: SBool = if s1037 then s1230 else s1229+  s1232 :: SWord64 = s584 & s723+  s1233 :: SBool = s14 /= s1232+  s1234 :: SBool = ~ s1233+  s1235 :: SBool = if s1045 then s1234 else s1233+  s1236 :: SWord64 = if s1235 then s584 else s14+  s1237 :: SWord64 = s579 | s1236+  s1238 :: SWord64 = if s1231 then s1237 else s1236+  s1239 :: SWord64 = s574 | s1238+  s1240 :: SWord64 = if s1227 then s1239 else s1238+  s1241 :: SWord64 = s569 | s1240+  s1242 :: SWord64 = if s1223 then s1241 else s1240+  s1243 :: SWord64 = s564 | s1242+  s1244 :: SWord64 = if s1219 then s1243 else s1242+  s1245 :: SWord64 = s557 | s1244+  s1246 :: SWord64 = if s1215 then s1245 else s1244+  s1247 :: SWord64 = s550 | s1246+  s1248 :: SWord64 = if s1209 then s1247 else s1246+  s1249 :: SWord64 = s543 | s1248+  s1250 :: SWord64 = if s1203 then s1249 else s1248+  s1251 :: SWord64 = s536 | s1250+  s1252 :: SWord64 = if s1197 then s1251 else s1250+  s1253 :: SWord64 = s529 | s1252+  s1254 :: SWord64 = if s1191 then s1253 else s1252+  s1255 :: SWord64 = s522 | s1254+  s1256 :: SWord64 = if s1185 then s1255 else s1254+  s1257 :: SWord64 = s515 | s1256+  s1258 :: SWord64 = if s1179 then s1257 else s1256+  s1259 :: SWord64 = s506 | s1258+  s1260 :: SWord64 = if s1173 then s1259 else s1258+  s1261 :: SWord64 = s497 | s1260+  s1262 :: SWord64 = if s1165 then s1261 else s1260+  s1263 :: SWord64 = s488 | s1262+  s1264 :: SWord64 = if s1157 then s1263 else s1262+  s1265 :: SWord64 = s479 | s1264+  s1266 :: SWord64 = if s1149 then s1265 else s1264+  s1267 :: SWord64 = s374 | s1266+  s1268 :: SWord64 = if s1141 then s1267 else s1266+  s1269 :: SWord64 = s365 | s1268+  s1270 :: SWord64 = if s1139 then s1269 else s1268+  s1271 :: SWord64 = s356 | s1270+  s1272 :: SWord64 = if s1137 then s1271 else s1270+  s1273 :: SWord64 = s347 | s1272+  s1274 :: SWord64 = if s1135 then s1273 else s1272+  s1275 :: SWord64 = s338 | s1274+  s1276 :: SWord64 = if s1133 then s1275 else s1274+  s1277 :: SWord64 = s329 | s1276+  s1278 :: SWord64 = if s1131 then s1277 else s1276+  s1279 :: SWord64 = s320 | s1278+  s1280 :: SWord64 = if s1129 then s1279 else s1278+  s1281 :: SWord64 = s311 | s1280+  s1282 :: SWord64 = if s1127 then s1281 else s1280+  s1283 :: SWord64 = s302 | s1282+  s1284 :: SWord64 = if s1125 then s1283 else s1282+  s1285 :: SWord64 = s293 | s1284+  s1286 :: SWord64 = if s1123 then s1285 else s1284+  s1287 :: SWord64 = s284 | s1286+  s1288 :: SWord64 = if s1121 then s1287 else s1286+  s1289 :: SWord64 = s275 | s1288+  s1290 :: SWord64 = if s1119 then s1289 else s1288+  s1291 :: SWord64 = s266 | s1290+  s1292 :: SWord64 = if s1117 then s1291 else s1290+  s1293 :: SWord64 = s257 | s1292+  s1294 :: SWord64 = if s1115 then s1293 else s1292+  s1295 :: SWord64 = s248 | s1294+  s1296 :: SWord64 = if s1113 then s1295 else s1294+  s1297 :: SWord64 = s239 | s1296+  s1298 :: SWord64 = if s1111 then s1297 else s1296+  s1299 :: SWord64 = s230 | s1298+  s1300 :: SWord64 = if s1109 then s1299 else s1298+  s1301 :: SWord64 = s221 | s1300+  s1302 :: SWord64 = if s1107 then s1301 else s1300+  s1303 :: SWord64 = s212 | s1302+  s1304 :: SWord64 = if s1105 then s1303 else s1302+  s1305 :: SWord64 = s203 | s1304+  s1306 :: SWord64 = if s1103 then s1305 else s1304+  s1307 :: SWord64 = s194 | s1306+  s1308 :: SWord64 = if s1101 then s1307 else s1306+  s1309 :: SWord64 = s185 | s1308+  s1310 :: SWord64 = if s1099 then s1309 else s1308+  s1311 :: SWord64 = s176 | s1310+  s1312 :: SWord64 = if s1097 then s1311 else s1310+  s1313 :: SWord64 = s167 | s1312+  s1314 :: SWord64 = if s1095 then s1313 else s1312+  s1315 :: SWord64 = s158 | s1314+  s1316 :: SWord64 = if s1093 then s1315 else s1314+  s1317 :: SWord64 = s149 | s1316+  s1318 :: SWord64 = if s1091 then s1317 else s1316+  s1319 :: SWord64 = s140 | s1318+  s1320 :: SWord64 = if s1089 then s1319 else s1318+  s1321 :: SWord64 = s131 | s1320+  s1322 :: SWord64 = if s1087 then s1321 else s1320+  s1323 :: SWord64 = s122 | s1322+  s1324 :: SWord64 = if s1085 then s1323 else s1322+  s1325 :: SWord64 = s113 | s1324+  s1326 :: SWord64 = if s1083 then s1325 else s1324+  s1327 :: SWord64 = s104 | s1326+  s1328 :: SWord64 = if s1081 then s1327 else s1326+  s1329 :: SWord64 = s95 | s1328+  s1330 :: SWord64 = if s1079 then s1329 else s1328+  s1331 :: SWord64 = s88 | s1330+  s1332 :: SWord64 = if s1077 then s1331 else s1330+  s1333 :: SWord64 = s81 | s1332+  s1334 :: SWord64 = if s1075 then s1333 else s1332+  s1335 :: SWord64 = s74 | s1334+  s1336 :: SWord64 = if s1073 then s1335 else s1334+  s1337 :: SWord64 = s67 | s1336+  s1338 :: SWord64 = if s1071 then s1337 else s1336+  s1339 :: SWord64 = s60 | s1338+  s1340 :: SWord64 = if s1069 then s1339 else s1338+  s1341 :: SWord64 = s55 | s1340+  s1342 :: SWord64 = if s1067 then s1341 else s1340+  s1343 :: SWord64 = s50 | s1342+  s1344 :: SWord64 = if s1065 then s1343 else s1342+  s1345 :: SWord64 = s45 | s1344+  s1346 :: SWord64 = if s1063 then s1345 else s1344+  s1347 :: SWord64 = s40 | s1346+  s1348 :: SWord64 = if s1061 then s1347 else s1346+  s1349 :: SWord64 = s35 | s1348+  s1350 :: SWord64 = if s1059 then s1349 else s1348+  s1351 :: SWord64 = s30 | s1350+  s1352 :: SWord64 = if s1057 then s1351 else s1350+  s1353 :: SWord64 = s25 | s1352+  s1354 :: SWord64 = if s1055 then s1353 else s1352+  s1355 :: SWord64 = s22 | s1354+  s1356 :: SWord64 = if s1053 then s1355 else s1354+  s1357 :: SWord64 = s19 | s1356+  s1358 :: SWord64 = if s1051 then s1357 else s1356+  s1359 :: SWord64 = s16 | s1358+  s1360 :: SWord64 = if s1049 then s1359 else s1358+  s1361 :: SWord64 = s12 | s1360+  s1362 :: SWord64 = if s1047 then s1361 else s1360+  s1363 :: SWord32 = choose [31:0] s1362+  s1364 :: SWord16 = choose [15:0] s1363+  s1365 :: SWord32 = s3 # s1364+  s1366 :: SWord64 = s2 # s1365+  s1367 :: SWord64 = s584 & s1366+  s1368 :: SBool = s14 /= s1367+  s1369 :: SBool = s721 == s1368+  s1370 :: SWord64 = s579 & s719+  s1371 :: SBool = s14 /= s1370+  s1372 :: SWord64 = s579 & s1366+  s1373 :: SBool = s14 /= s1372+  s1374 :: SBool = s1371 == s1373+  s1375 :: SWord64 = s574 & s719+  s1376 :: SBool = s14 /= s1375+  s1377 :: SWord64 = s574 & s1366+  s1378 :: SBool = s14 /= s1377+  s1379 :: SBool = s1376 == s1378+  s1380 :: SWord64 = s569 & s719+  s1381 :: SBool = s14 /= s1380+  s1382 :: SWord64 = s569 & s1366+  s1383 :: SBool = s14 /= s1382+  s1384 :: SBool = s1381 == s1383+  s1385 :: SWord64 = s564 & s719+  s1386 :: SBool = s14 /= s1385+  s1387 :: SWord64 = s564 & s1366+  s1388 :: SBool = s14 /= s1387+  s1389 :: SBool = s1386 == s1388+  s1390 :: SWord64 = s557 & s719+  s1391 :: SBool = s14 /= s1390+  s1392 :: SWord64 = s557 & s1366+  s1393 :: SBool = s14 /= s1392+  s1394 :: SBool = s1391 == s1393+  s1395 :: SWord64 = s550 & s719+  s1396 :: SBool = s14 /= s1395+  s1397 :: SWord64 = s550 & s1366+  s1398 :: SBool = s14 /= s1397+  s1399 :: SBool = s1396 == s1398+  s1400 :: SWord64 = s543 & s719+  s1401 :: SBool = s14 /= s1400+  s1402 :: SWord64 = s543 & s1366+  s1403 :: SBool = s14 /= s1402+  s1404 :: SBool = s1401 == s1403+  s1405 :: SWord64 = s536 & s719+  s1406 :: SBool = s14 /= s1405+  s1407 :: SWord64 = s536 & s1366+  s1408 :: SBool = s14 /= s1407+  s1409 :: SBool = s1406 == s1408+  s1410 :: SWord64 = s529 & s719+  s1411 :: SBool = s14 /= s1410+  s1412 :: SWord64 = s529 & s1366+  s1413 :: SBool = s14 /= s1412+  s1414 :: SBool = s1411 == s1413+  s1415 :: SWord64 = s522 & s719+  s1416 :: SBool = s14 /= s1415+  s1417 :: SWord64 = s522 & s1366+  s1418 :: SBool = s14 /= s1417+  s1419 :: SBool = s1416 == s1418+  s1420 :: SWord64 = s515 & s719+  s1421 :: SBool = s14 /= s1420+  s1422 :: SWord64 = s515 & s1366+  s1423 :: SBool = s14 /= s1422+  s1424 :: SBool = s1421 == s1423+  s1425 :: SWord64 = s506 & s719+  s1426 :: SBool = s14 /= s1425+  s1427 :: SWord64 = s506 & s1366+  s1428 :: SBool = s14 /= s1427+  s1429 :: SBool = s1426 == s1428+  s1430 :: SWord64 = s497 & s719+  s1431 :: SBool = s14 /= s1430+  s1432 :: SWord64 = s497 & s1366+  s1433 :: SBool = s14 /= s1432+  s1434 :: SBool = s1431 == s1433+  s1435 :: SWord64 = s488 & s719+  s1436 :: SBool = s14 /= s1435+  s1437 :: SWord64 = s488 & s1366+  s1438 :: SBool = s14 /= s1437+  s1439 :: SBool = s1436 == s1438+  s1440 :: SWord64 = s479 & s719+  s1441 :: SBool = s14 /= s1440+  s1442 :: SWord64 = s479 & s1366+  s1443 :: SBool = s14 /= s1442+  s1444 :: SBool = s1441 == s1443+  s1445 :: SWord64 = s374 & s719+  s1446 :: SBool = s14 /= s1445+  s1447 :: SWord64 = s374 & s1366+  s1448 :: SBool = s14 /= s1447+  s1449 :: SBool = s1446 == s1448+  s1450 :: SWord64 = s365 & s719+  s1451 :: SBool = s14 /= s1450+  s1452 :: SWord64 = s365 & s1366+  s1453 :: SBool = s14 /= s1452+  s1454 :: SBool = s1451 == s1453+  s1455 :: SWord64 = s356 & s719+  s1456 :: SBool = s14 /= s1455+  s1457 :: SWord64 = s356 & s1366+  s1458 :: SBool = s14 /= s1457+  s1459 :: SBool = s1456 == s1458+  s1460 :: SWord64 = s347 & s719+  s1461 :: SBool = s14 /= s1460+  s1462 :: SWord64 = s347 & s1366+  s1463 :: SBool = s14 /= s1462+  s1464 :: SBool = s1461 == s1463+  s1465 :: SWord64 = s338 & s719+  s1466 :: SBool = s14 /= s1465+  s1467 :: SWord64 = s338 & s1366+  s1468 :: SBool = s14 /= s1467+  s1469 :: SBool = s1466 == s1468+  s1470 :: SWord64 = s329 & s719+  s1471 :: SBool = s14 /= s1470+  s1472 :: SWord64 = s329 & s1366+  s1473 :: SBool = s14 /= s1472+  s1474 :: SBool = s1471 == s1473+  s1475 :: SWord64 = s320 & s719+  s1476 :: SBool = s14 /= s1475+  s1477 :: SWord64 = s320 & s1366+  s1478 :: SBool = s14 /= s1477+  s1479 :: SBool = s1476 == s1478+  s1480 :: SWord64 = s311 & s719+  s1481 :: SBool = s14 /= s1480+  s1482 :: SWord64 = s311 & s1366+  s1483 :: SBool = s14 /= s1482+  s1484 :: SBool = s1481 == s1483+  s1485 :: SWord64 = s302 & s719+  s1486 :: SBool = s14 /= s1485+  s1487 :: SWord64 = s302 & s1366+  s1488 :: SBool = s14 /= s1487+  s1489 :: SBool = s1486 == s1488+  s1490 :: SWord64 = s293 & s719+  s1491 :: SBool = s14 /= s1490+  s1492 :: SWord64 = s293 & s1366+  s1493 :: SBool = s14 /= s1492+  s1494 :: SBool = s1491 == s1493+  s1495 :: SWord64 = s284 & s719+  s1496 :: SBool = s14 /= s1495+  s1497 :: SWord64 = s284 & s1366+  s1498 :: SBool = s14 /= s1497+  s1499 :: SBool = s1496 == s1498+  s1500 :: SWord64 = s275 & s719+  s1501 :: SBool = s14 /= s1500+  s1502 :: SWord64 = s275 & s1366+  s1503 :: SBool = s14 /= s1502+  s1504 :: SBool = s1501 == s1503+  s1505 :: SWord64 = s266 & s719+  s1506 :: SBool = s14 /= s1505+  s1507 :: SWord64 = s266 & s1366+  s1508 :: SBool = s14 /= s1507+  s1509 :: SBool = s1506 == s1508+  s1510 :: SWord64 = s257 & s719+  s1511 :: SBool = s14 /= s1510+  s1512 :: SWord64 = s257 & s1366+  s1513 :: SBool = s14 /= s1512+  s1514 :: SBool = s1511 == s1513+  s1515 :: SWord64 = s248 & s719+  s1516 :: SBool = s14 /= s1515+  s1517 :: SWord64 = s248 & s1366+  s1518 :: SBool = s14 /= s1517+  s1519 :: SBool = s1516 == s1518+  s1520 :: SWord64 = s239 & s719+  s1521 :: SBool = s14 /= s1520+  s1522 :: SWord64 = s239 & s1366+  s1523 :: SBool = s14 /= s1522+  s1524 :: SBool = s1521 == s1523+  s1525 :: SWord64 = s230 & s719+  s1526 :: SBool = s14 /= s1525+  s1527 :: SWord64 = s230 & s1366+  s1528 :: SBool = s14 /= s1527+  s1529 :: SBool = s1526 == s1528+  s1530 :: SWord64 = s221 & s719+  s1531 :: SBool = s14 /= s1530+  s1532 :: SWord64 = s221 & s1366+  s1533 :: SBool = s14 /= s1532+  s1534 :: SBool = s1531 == s1533+  s1535 :: SWord64 = s212 & s719+  s1536 :: SBool = s14 /= s1535+  s1537 :: SWord64 = s212 & s1366+  s1538 :: SBool = s14 /= s1537+  s1539 :: SBool = s1536 == s1538+  s1540 :: SWord64 = s203 & s719+  s1541 :: SBool = s14 /= s1540+  s1542 :: SWord64 = s203 & s1366+  s1543 :: SBool = s14 /= s1542+  s1544 :: SBool = s1541 == s1543+  s1545 :: SWord64 = s194 & s719+  s1546 :: SBool = s14 /= s1545+  s1547 :: SWord64 = s194 & s1366+  s1548 :: SBool = s14 /= s1547+  s1549 :: SBool = s1546 == s1548+  s1550 :: SWord64 = s185 & s719+  s1551 :: SBool = s14 /= s1550+  s1552 :: SWord64 = s185 & s1366+  s1553 :: SBool = s14 /= s1552+  s1554 :: SBool = s1551 == s1553+  s1555 :: SWord64 = s176 & s719+  s1556 :: SBool = s14 /= s1555+  s1557 :: SWord64 = s176 & s1366+  s1558 :: SBool = s14 /= s1557+  s1559 :: SBool = s1556 == s1558+  s1560 :: SWord64 = s167 & s719+  s1561 :: SBool = s14 /= s1560+  s1562 :: SWord64 = s167 & s1366+  s1563 :: SBool = s14 /= s1562+  s1564 :: SBool = s1561 == s1563+  s1565 :: SWord64 = s158 & s719+  s1566 :: SBool = s14 /= s1565+  s1567 :: SWord64 = s158 & s1366+  s1568 :: SBool = s14 /= s1567+  s1569 :: SBool = s1566 == s1568+  s1570 :: SWord64 = s149 & s719+  s1571 :: SBool = s14 /= s1570+  s1572 :: SWord64 = s149 & s1366+  s1573 :: SBool = s14 /= s1572+  s1574 :: SBool = s1571 == s1573+  s1575 :: SWord64 = s140 & s719+  s1576 :: SBool = s14 /= s1575+  s1577 :: SWord64 = s140 & s1366+  s1578 :: SBool = s14 /= s1577+  s1579 :: SBool = s1576 == s1578+  s1580 :: SWord64 = s131 & s719+  s1581 :: SBool = s14 /= s1580+  s1582 :: SWord64 = s131 & s1366+  s1583 :: SBool = s14 /= s1582+  s1584 :: SBool = s1581 == s1583+  s1585 :: SWord64 = s122 & s719+  s1586 :: SBool = s14 /= s1585+  s1587 :: SWord64 = s122 & s1366+  s1588 :: SBool = s14 /= s1587+  s1589 :: SBool = s1586 == s1588+  s1590 :: SWord64 = s113 & s719+  s1591 :: SBool = s14 /= s1590+  s1592 :: SWord64 = s113 & s1366+  s1593 :: SBool = s14 /= s1592+  s1594 :: SBool = s1591 == s1593+  s1595 :: SWord64 = s104 & s719+  s1596 :: SBool = s14 /= s1595+  s1597 :: SWord64 = s104 & s1366+  s1598 :: SBool = s14 /= s1597+  s1599 :: SBool = s1596 == s1598+  s1600 :: SWord64 = s95 & s719+  s1601 :: SBool = s14 /= s1600+  s1602 :: SWord64 = s95 & s1366+  s1603 :: SBool = s14 /= s1602+  s1604 :: SBool = s1601 == s1603+  s1605 :: SWord64 = s88 & s719+  s1606 :: SBool = s14 /= s1605+  s1607 :: SWord64 = s88 & s1366+  s1608 :: SBool = s14 /= s1607+  s1609 :: SBool = s1606 == s1608+  s1610 :: SWord64 = s81 & s719+  s1611 :: SBool = s14 /= s1610+  s1612 :: SWord64 = s81 & s1366+  s1613 :: SBool = s14 /= s1612+  s1614 :: SBool = s1611 == s1613+  s1615 :: SWord64 = s74 & s719+  s1616 :: SBool = s14 /= s1615+  s1617 :: SWord64 = s74 & s1366+  s1618 :: SBool = s14 /= s1617+  s1619 :: SBool = s1616 == s1618+  s1620 :: SWord64 = s67 & s719+  s1621 :: SBool = s14 /= s1620+  s1622 :: SWord64 = s67 & s1366+  s1623 :: SBool = s14 /= s1622+  s1624 :: SBool = s1621 == s1623+  s1625 :: SWord64 = s60 & s719+  s1626 :: SBool = s14 /= s1625+  s1627 :: SWord64 = s60 & s1366+  s1628 :: SBool = s14 /= s1627+  s1629 :: SBool = s1626 == s1628+  s1630 :: SWord64 = s55 & s719+  s1631 :: SBool = s14 /= s1630+  s1632 :: SWord64 = s55 & s1366+  s1633 :: SBool = s14 /= s1632+  s1634 :: SBool = s1631 == s1633+  s1635 :: SWord64 = s50 & s719+  s1636 :: SBool = s14 /= s1635+  s1637 :: SWord64 = s50 & s1366+  s1638 :: SBool = s14 /= s1637+  s1639 :: SBool = s1636 == s1638+  s1640 :: SWord64 = s45 & s719+  s1641 :: SBool = s14 /= s1640+  s1642 :: SWord64 = s45 & s1366+  s1643 :: SBool = s14 /= s1642+  s1644 :: SBool = s1641 == s1643+  s1645 :: SWord64 = s40 & s719+  s1646 :: SBool = s14 /= s1645+  s1647 :: SWord64 = s40 & s1366+  s1648 :: SBool = s14 /= s1647+  s1649 :: SBool = s1646 == s1648+  s1650 :: SWord64 = s35 & s719+  s1651 :: SBool = s14 /= s1650+  s1652 :: SWord64 = s35 & s1366+  s1653 :: SBool = s14 /= s1652+  s1654 :: SBool = s1651 == s1653+  s1655 :: SWord64 = s30 & s719+  s1656 :: SBool = s14 /= s1655+  s1657 :: SWord64 = s30 & s1366+  s1658 :: SBool = s14 /= s1657+  s1659 :: SBool = s1656 == s1658+  s1660 :: SWord64 = s25 & s719+  s1661 :: SBool = s14 /= s1660+  s1662 :: SWord64 = s25 & s1366+  s1663 :: SBool = s14 /= s1662+  s1664 :: SBool = s1661 == s1663+  s1665 :: SWord64 = s22 & s719+  s1666 :: SBool = s14 /= s1665+  s1667 :: SWord64 = s22 & s1366+  s1668 :: SBool = s14 /= s1667+  s1669 :: SBool = s1666 == s1668+  s1670 :: SWord64 = s19 & s719+  s1671 :: SBool = s14 /= s1670+  s1672 :: SWord64 = s19 & s1366+  s1673 :: SBool = s14 /= s1672+  s1674 :: SBool = s1671 == s1673+  s1675 :: SWord64 = s16 & s719+  s1676 :: SBool = s14 /= s1675+  s1677 :: SWord64 = s16 & s1366+  s1678 :: SBool = s14 /= s1677+  s1679 :: SBool = s1676 == s1678+  s1680 :: SWord64 = s12 & s719+  s1681 :: SBool = s14 /= s1680+  s1682 :: SWord64 = s12 & s1366+  s1683 :: SBool = s14 /= s1682+  s1684 :: SBool = s1681 == s1683+  s1687 :: SWord8 = if s1684 then s1685 else s1686+  s1688 :: SWord8 = s1686 + s1687+  s1689 :: SWord8 = if s1679 then s1687 else s1688+  s1690 :: SWord8 = s1686 + s1689+  s1691 :: SWord8 = if s1674 then s1689 else s1690+  s1692 :: SWord8 = s1686 + s1691+  s1693 :: SWord8 = if s1669 then s1691 else s1692+  s1694 :: SWord8 = s1686 + s1693+  s1695 :: SWord8 = if s1664 then s1693 else s1694+  s1696 :: SWord8 = s1686 + s1695+  s1697 :: SWord8 = if s1659 then s1695 else s1696+  s1698 :: SWord8 = s1686 + s1697+  s1699 :: SWord8 = if s1654 then s1697 else s1698+  s1700 :: SWord8 = s1686 + s1699+  s1701 :: SWord8 = if s1649 then s1699 else s1700+  s1702 :: SWord8 = s1686 + s1701+  s1703 :: SWord8 = if s1644 then s1701 else s1702+  s1704 :: SWord8 = s1686 + s1703+  s1705 :: SWord8 = if s1639 then s1703 else s1704+  s1706 :: SWord8 = s1686 + s1705+  s1707 :: SWord8 = if s1634 then s1705 else s1706+  s1708 :: SWord8 = s1686 + s1707+  s1709 :: SWord8 = if s1629 then s1707 else s1708+  s1710 :: SWord8 = s1686 + s1709+  s1711 :: SWord8 = if s1624 then s1709 else s1710+  s1712 :: SWord8 = s1686 + s1711+  s1713 :: SWord8 = if s1619 then s1711 else s1712+  s1714 :: SWord8 = s1686 + s1713+  s1715 :: SWord8 = if s1614 then s1713 else s1714+  s1716 :: SWord8 = s1686 + s1715+  s1717 :: SWord8 = if s1609 then s1715 else s1716+  s1718 :: SWord8 = s1686 + s1717+  s1719 :: SWord8 = if s1604 then s1717 else s1718+  s1720 :: SWord8 = s1686 + s1719+  s1721 :: SWord8 = if s1599 then s1719 else s1720+  s1722 :: SWord8 = s1686 + s1721+  s1723 :: SWord8 = if s1594 then s1721 else s1722+  s1724 :: SWord8 = s1686 + s1723+  s1725 :: SWord8 = if s1589 then s1723 else s1724+  s1726 :: SWord8 = s1686 + s1725+  s1727 :: SWord8 = if s1584 then s1725 else s1726+  s1728 :: SWord8 = s1686 + s1727+  s1729 :: SWord8 = if s1579 then s1727 else s1728+  s1730 :: SWord8 = s1686 + s1729+  s1731 :: SWord8 = if s1574 then s1729 else s1730+  s1732 :: SWord8 = s1686 + s1731+  s1733 :: SWord8 = if s1569 then s1731 else s1732+  s1734 :: SWord8 = s1686 + s1733+  s1735 :: SWord8 = if s1564 then s1733 else s1734+  s1736 :: SWord8 = s1686 + s1735+  s1737 :: SWord8 = if s1559 then s1735 else s1736+  s1738 :: SWord8 = s1686 + s1737+  s1739 :: SWord8 = if s1554 then s1737 else s1738+  s1740 :: SWord8 = s1686 + s1739+  s1741 :: SWord8 = if s1549 then s1739 else s1740+  s1742 :: SWord8 = s1686 + s1741+  s1743 :: SWord8 = if s1544 then s1741 else s1742+  s1744 :: SWord8 = s1686 + s1743+  s1745 :: SWord8 = if s1539 then s1743 else s1744+  s1746 :: SWord8 = s1686 + s1745+  s1747 :: SWord8 = if s1534 then s1745 else s1746+  s1748 :: SWord8 = s1686 + s1747+  s1749 :: SWord8 = if s1529 then s1747 else s1748+  s1750 :: SWord8 = s1686 + s1749+  s1751 :: SWord8 = if s1524 then s1749 else s1750+  s1752 :: SWord8 = s1686 + s1751+  s1753 :: SWord8 = if s1519 then s1751 else s1752+  s1754 :: SWord8 = s1686 + s1753+  s1755 :: SWord8 = if s1514 then s1753 else s1754+  s1756 :: SWord8 = s1686 + s1755+  s1757 :: SWord8 = if s1509 then s1755 else s1756+  s1758 :: SWord8 = s1686 + s1757+  s1759 :: SWord8 = if s1504 then s1757 else s1758+  s1760 :: SWord8 = s1686 + s1759+  s1761 :: SWord8 = if s1499 then s1759 else s1760+  s1762 :: SWord8 = s1686 + s1761+  s1763 :: SWord8 = if s1494 then s1761 else s1762+  s1764 :: SWord8 = s1686 + s1763+  s1765 :: SWord8 = if s1489 then s1763 else s1764+  s1766 :: SWord8 = s1686 + s1765+  s1767 :: SWord8 = if s1484 then s1765 else s1766+  s1768 :: SWord8 = s1686 + s1767+  s1769 :: SWord8 = if s1479 then s1767 else s1768+  s1770 :: SWord8 = s1686 + s1769+  s1771 :: SWord8 = if s1474 then s1769 else s1770+  s1772 :: SWord8 = s1686 + s1771+  s1773 :: SWord8 = if s1469 then s1771 else s1772+  s1774 :: SWord8 = s1686 + s1773+  s1775 :: SWord8 = if s1464 then s1773 else s1774+  s1776 :: SWord8 = s1686 + s1775+  s1777 :: SWord8 = if s1459 then s1775 else s1776+  s1778 :: SWord8 = s1686 + s1777+  s1779 :: SWord8 = if s1454 then s1777 else s1778+  s1780 :: SWord8 = s1686 + s1779+  s1781 :: SWord8 = if s1449 then s1779 else s1780+  s1782 :: SWord8 = s1686 + s1781+  s1783 :: SWord8 = if s1444 then s1781 else s1782+  s1784 :: SWord8 = s1686 + s1783+  s1785 :: SWord8 = if s1439 then s1783 else s1784+  s1786 :: SWord8 = s1686 + s1785+  s1787 :: SWord8 = if s1434 then s1785 else s1786+  s1788 :: SWord8 = s1686 + s1787+  s1789 :: SWord8 = if s1429 then s1787 else s1788+  s1790 :: SWord8 = s1686 + s1789+  s1791 :: SWord8 = if s1424 then s1789 else s1790+  s1792 :: SWord8 = s1686 + s1791+  s1793 :: SWord8 = if s1419 then s1791 else s1792+  s1794 :: SWord8 = s1686 + s1793+  s1795 :: SWord8 = if s1414 then s1793 else s1794+  s1796 :: SWord8 = s1686 + s1795+  s1797 :: SWord8 = if s1409 then s1795 else s1796+  s1798 :: SWord8 = s1686 + s1797+  s1799 :: SWord8 = if s1404 then s1797 else s1798+  s1800 :: SWord8 = s1686 + s1799+  s1801 :: SWord8 = if s1399 then s1799 else s1800+  s1802 :: SWord8 = s1686 + s1801+  s1803 :: SWord8 = if s1394 then s1801 else s1802+  s1804 :: SWord8 = s1686 + s1803+  s1805 :: SWord8 = if s1389 then s1803 else s1804+  s1806 :: SWord8 = s1686 + s1805+  s1807 :: SWord8 = if s1384 then s1805 else s1806+  s1808 :: SWord8 = s1686 + s1807+  s1809 :: SWord8 = if s1379 then s1807 else s1808+  s1810 :: SWord8 = s1686 + s1809+  s1811 :: SWord8 = if s1374 then s1809 else s1810+  s1812 :: SWord8 = s1686 + s1811+  s1813 :: SWord8 = if s1369 then s1811 else s1812+  s1815 :: SBool = s1813 > s1814+  s1816 :: SBool = s8 | s1815+OUTPUTS+  s1816
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/codeGen1.gold view
@@ -0,0 +1,218 @@+== BEGIN: "Makefile" ================+# Makefile for foo. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#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" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/dogCatMouse.gold view
@@ -0,0 +1,4 @@+Only one solution found:+  s0 = 3 :: SWord16+  s1 = 41 :: SWord16+  s2 = 56 :: SWord16
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/euler185.gold view
@@ -0,0 +1,17 @@+Only one solution found:+  s0 = 4 :: SWord8+  s1 = 6 :: SWord8+  s2 = 4 :: SWord8+  s3 = 0 :: SWord8+  s4 = 2 :: SWord8+  s5 = 6 :: SWord8+  s6 = 1 :: SWord8+  s7 = 5 :: SWord8+  s8 = 7 :: SWord8+  s9 = 1 :: SWord8+  s10 = 8 :: SWord8+  s11 = 4 :: SWord8+  s12 = 9 :: SWord8+  s13 = 5 :: SWord8+  s14 = 3 :: SWord8+  s15 = 3 :: SWord8
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/fib1.gold view
@@ -0,0 +1,210 @@+== BEGIN: "Makefile" ================+# Makefile for fib1. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 fib1(const SWord32 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 <inttypes.h>+#include <stdint.h>+#include <stdio.h>+#include "fib1.h"++int main(void)+{+  const SWord32 __result = fib1(0x0000000cUL);+  +  printf("fib1(0x0000000cUL) = 0x%08"PRIx32"UL\n", __result);++  return 0;+}+== END: "fib1_driver.c" ==================+== BEGIN: "fib1.c" ================+/* File: "fib1.c". Automatically generated by SBV. Do not edit! */++#include <inttypes.h>+#include <stdint.h>+#include "fib1.h"++SWord32 fib1(const SWord32 n)+{+  const SWord32 s0 = n;+  const SBool   s2 = s0 == 0x00000000UL;+  const SBool   s4 = s0 == 0x00000001UL;+  const SBool   s6 = s0 == 0x00000002UL;+  const SBool   s8 = s0 == 0x00000003UL;+  const SBool   s10 = s0 == 0x00000004UL;+  const SBool   s12 = s0 == 0x00000005UL;+  const SBool   s14 = s0 == 0x00000006UL;+  const SBool   s17 = s0 == 0x00000007UL;+  const SBool   s19 = s0 == 0x00000008UL;+  const SBool   s22 = s0 == 0x00000009UL;+  const SBool   s25 = s0 == 0x0000000aUL;+  const SBool   s28 = s0 == 0x0000000bUL;+  const SBool   s31 = s0 == 0x0000000cUL;+  const SBool   s33 = s0 == 0x0000000dUL;+  const SBool   s36 = s0 == 0x0000000eUL;+  const SBool   s39 = s0 == 0x0000000fUL;+  const SBool   s42 = s0 == 0x00000010UL;+  const SBool   s45 = s0 == 0x00000011UL;+  const SBool   s48 = s0 == 0x00000012UL;+  const SBool   s51 = s0 == 0x00000013UL;+  const SBool   s54 = s0 == 0x00000014UL;+  const SBool   s56 = s0 == 0x00000015UL;+  const SBool   s59 = s0 == 0x00000016UL;+  const SBool   s62 = s0 == 0x00000017UL;+  const SBool   s65 = s0 == 0x00000018UL;+  const SBool   s68 = s0 == 0x00000019UL;+  const SBool   s71 = s0 == 0x0000001aUL;+  const SBool   s74 = s0 == 0x0000001bUL;+  const SBool   s77 = s0 == 0x0000001cUL;+  const SBool   s80 = s0 == 0x0000001dUL;+  const SBool   s83 = s0 == 0x0000001eUL;+  const SBool   s86 = s0 == 0x0000001fUL;+  const SBool   s89 = s0 == 0x00000020UL;+  const SBool   s92 = s0 == 0x00000021UL;+  const SBool   s94 = s0 == 0x00000022UL;+  const SBool   s97 = s0 == 0x00000023UL;+  const SBool   s100 = s0 == 0x00000024UL;+  const SBool   s103 = s0 == 0x00000025UL;+  const SBool   s106 = s0 == 0x00000026UL;+  const SBool   s109 = s0 == 0x00000027UL;+  const SBool   s112 = s0 == 0x00000028UL;+  const SBool   s115 = s0 == 0x00000029UL;+  const SBool   s118 = s0 == 0x0000002aUL;+  const SBool   s121 = s0 == 0x0000002bUL;+  const SBool   s124 = s0 == 0x0000002cUL;+  const SBool   s127 = s0 == 0x0000002dUL;+  const SBool   s130 = s0 == 0x0000002eUL;+  const SBool   s133 = s0 == 0x0000002fUL;+  const SBool   s136 = s0 == 0x00000030UL;+  const SBool   s139 = s0 == 0x00000031UL;+  const SBool   s142 = s0 == 0x00000032UL;+  const SBool   s145 = s0 == 0x00000033UL;+  const SBool   s148 = s0 == 0x00000034UL;+  const SBool   s151 = s0 == 0x00000035UL;+  const SBool   s154 = s0 == 0x00000036UL;+  const SBool   s156 = s0 == 0x00000037UL;+  const SBool   s159 = s0 == 0x00000038UL;+  const SBool   s162 = s0 == 0x00000039UL;+  const SBool   s165 = s0 == 0x0000003aUL;+  const SBool   s168 = s0 == 0x0000003bUL;+  const SBool   s171 = s0 == 0x0000003cUL;+  const SBool   s174 = s0 == 0x0000003dUL;+  const SBool   s177 = s0 == 0x0000003eUL;+  const SBool   s180 = s0 == 0x0000003fUL;+  const SWord32 s183 = s180 ? 0xc7b064e2UL : 0x61ca20bbUL;+  const SWord32 s184 = s177 ? 0x9a19bbd9UL : s183;+  const SWord32 s185 = s174 ? 0x2d96a909UL : s184;+  const SWord32 s186 = s171 ? 0x6c8312d0UL : s185;+  const SWord32 s187 = s168 ? 0xc1139639UL : s186;+  const SWord32 s188 = s165 ? 0xab6f7c97UL : s187;+  const SWord32 s189 = s162 ? 0x15a419a2UL : s188;+  const SWord32 s190 = s159 ? 0x95cb62f5UL : s189;+  const SWord32 s191 = s156 ? 0x7fd8b6adUL : s190;+  const SWord32 s192 = s154 ? 0x15f2ac48UL : s191;+  const SWord32 s193 = s151 ? 0x69e60a65UL : s192;+  const SWord32 s194 = s148 ? 0xac0ca1e3UL : s193;+  const SWord32 s195 = s145 ? 0xbdd96882UL : s194;+  const SWord32 s196 = s142 ? 0xee333961UL : s195;+  const SWord32 s197 = s139 ? 0xcfa62f21UL : s196;+  const SWord32 s198 = s136 ? 0x1e8d0a40UL : s197;+  const SWord32 s199 = s133 ? 0xb11924e1UL : s198;+  const SWord32 s200 = s130 ? 0x6d73e55fUL : s199;+  const SWord32 s201 = s127 ? 0x43a53f82UL : s200;+  const SWord32 s202 = s124 ? 0x29cea5ddUL : s201;+  const SWord32 s203 = s121 ? 0x19d699a5UL : s202;+  const SWord32 s204 = s118 ? 0x0ff80c38UL : s203;+  const SWord32 s205 = s115 ? 0x09de8d6dUL : s204;+  const SWord32 s206 = s112 ? 0x06197ecbUL : s205;+  const SWord32 s207 = s109 ? 0x03c50ea2UL : s206;+  const SWord32 s208 = s106 ? 0x02547029UL : s207;+  const SWord32 s209 = s103 ? 0x01709e79UL : s208;+  const SWord32 s210 = s100 ? 0x00e3d1b0UL : s209;+  const SWord32 s211 = s97 ? 0x008cccc9UL : s210;+  const SWord32 s212 = s94 ? 0x005704e7UL : s211;+  const SWord32 s213 = s92 ? 0x0035c7e2UL : s212;+  const SWord32 s214 = s89 ? 0x00213d05UL : s213;+  const SWord32 s215 = s86 ? 0x00148addUL : s214;+  const SWord32 s216 = s83 ? 0x000cb228UL : s215;+  const SWord32 s217 = s80 ? 0x0007d8b5UL : s216;+  const SWord32 s218 = s77 ? 0x0004d973UL : s217;+  const SWord32 s219 = s74 ? 0x0002ff42UL : s218;+  const SWord32 s220 = s71 ? 0x0001da31UL : s219;+  const SWord32 s221 = s68 ? 0x00012511UL : s220;+  const SWord32 s222 = s65 ? 0x0000b520UL : s221;+  const SWord32 s223 = s62 ? 0x00006ff1UL : s222;+  const SWord32 s224 = s59 ? 0x0000452fUL : s223;+  const SWord32 s225 = s56 ? 0x00002ac2UL : s224;+  const SWord32 s226 = s54 ? 0x00001a6dUL : s225;+  const SWord32 s227 = s51 ? 0x00001055UL : s226;+  const SWord32 s228 = s48 ? 0x00000a18UL : s227;+  const SWord32 s229 = s45 ? 0x0000063dUL : s228;+  const SWord32 s230 = s42 ? 0x000003dbUL : s229;+  const SWord32 s231 = s39 ? 0x00000262UL : s230;+  const SWord32 s232 = s36 ? 0x00000179UL : s231;+  const SWord32 s233 = s33 ? 0x000000e9UL : s232;+  const SWord32 s234 = s31 ? 0x00000090UL : s233;+  const SWord32 s235 = s28 ? 0x00000059UL : s234;+  const SWord32 s236 = s25 ? 0x00000037UL : s235;+  const SWord32 s237 = s22 ? 0x00000022UL : s236;+  const SWord32 s238 = s19 ? 0x00000015UL : s237;+  const SWord32 s239 = s17 ? 0x0000000dUL : s238;+  const SWord32 s240 = s14 ? 0x00000008UL : s239;+  const SWord32 s241 = s12 ? 0x00000005UL : s240;+  const SWord32 s242 = s10 ? 0x00000003UL : s241;+  const SWord32 s243 = s8 ? 0x00000002UL : s242;+  const SWord32 s244 = s6 ? 0x00000001UL : s243;+  const SWord32 s245 = s4 ? 0x00000001UL : s244;+  const SWord32 s246 = s2 ? 0x00000000UL : s245;+  +  return s246;+}+== END: "fib1.c" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/fib2.gold view
@@ -0,0 +1,102 @@+== BEGIN: "Makefile" ================+# Makefile for fib2. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 fib2(const SWord32 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 <inttypes.h>+#include <stdint.h>+#include <stdio.h>+#include "fib2.h"++int main(void)+{+  const SWord32 __result = fib2(0x00000014UL);+  +  printf("fib2(0x00000014UL) = 0x%08"PRIx32"UL\n", __result);++  return 0;+}+== END: "fib2_driver.c" ==================+== BEGIN: "fib2.c" ================+/* File: "fib2.c". Automatically generated by SBV. Do not edit! */++#include <inttypes.h>+#include <stdint.h>+#include "fib2.h"++SWord32 fib2(const SWord32 n)+{+  const SWord32 s0 = n;+  static const SWord32 table0[] = {+      0x00000000UL, 0x00000001UL, 0x00000001UL, 0x00000002UL,+      0x00000003UL, 0x00000005UL, 0x00000008UL, 0x0000000dUL,+      0x00000015UL, 0x00000022UL, 0x00000037UL, 0x00000059UL,+      0x00000090UL, 0x000000e9UL, 0x00000179UL, 0x00000262UL,+      0x000003dbUL, 0x0000063dUL, 0x00000a18UL, 0x00001055UL,+      0x00001a6dUL, 0x00002ac2UL, 0x0000452fUL, 0x00006ff1UL,+      0x0000b520UL, 0x00012511UL, 0x0001da31UL, 0x0002ff42UL,+      0x0004d973UL, 0x0007d8b5UL, 0x000cb228UL, 0x00148addUL,+      0x00213d05UL, 0x0035c7e2UL, 0x005704e7UL, 0x008cccc9UL,+      0x00e3d1b0UL, 0x01709e79UL, 0x02547029UL, 0x03c50ea2UL,+      0x06197ecbUL, 0x09de8d6dUL, 0x0ff80c38UL, 0x19d699a5UL,+      0x29cea5ddUL, 0x43a53f82UL, 0x6d73e55fUL, 0xb11924e1UL,+      0x1e8d0a40UL, 0xcfa62f21UL, 0xee333961UL, 0xbdd96882UL,+      0xac0ca1e3UL, 0x69e60a65UL, 0x15f2ac48UL, 0x7fd8b6adUL,+      0x95cb62f5UL, 0x15a419a2UL, 0xab6f7c97UL, 0xc1139639UL,+      0x6c8312d0UL, 0x2d96a909UL, 0x9a19bbd9UL, 0xc7b064e2UL,+      0x61ca20bbUL+  };+  const SWord32 s65 = s0 >= 65 ? 0x00000000UL : table0[s0];+  +  return s65;+}+== END: "fib2.c" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/gcd.gold view
@@ -0,0 +1,129 @@+== BEGIN: "Makefile" ================+# Makefile for sgcd. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#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" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/higher-1.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/higher-2.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/higher-3.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/higher-4.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/higher-5.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/higher-6.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/higher-7.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/higher-8.gold view
@@ -0,0 +1,1 @@+Q.E.D.
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/higher-9.gold view
@@ -0,0 +1,2 @@+Falsifiable. Counter-example:+  s0 = 128 :: SWord8
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/legato.gold view
@@ -0,0 +1,8957 @@+INPUTS+  s0 :: SWord32, aliasing "addrX"+  s1 :: SWord8, aliasing "x"+  s2 :: SWord32, aliasing "addrY"+  s3 :: SWord8, aliasing "y"+  s4 :: SWord32, aliasing "addrLow"+  s5 :: SWord8, aliasing "regX"+  s6 :: SWord8, aliasing "regA"+  s7 :: SWord8, aliasing "memVals"+  s8 :: SBool, aliasing "flagC"+  s9 :: SBool, aliasing "flagZ"+CONSTANTS+  s_2 = False+  s_1 = True+  s17 = 0 :: SWord8+  s18 = 1 :: SWord8+  s24 = 128 :: SWord8+  s26 = 127 :: SWord8+  s16 = 256 :: SWord16+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+AXIOMS+DEFINE+  s10 :: SBool = s0 /= s2+  s11 :: SBool = s0 /= s4+  s12 :: SBool = s10 & s11+  s13 :: SBool = s2 /= s4+  s14 :: SBool = s12 & s13+  s15 :: SBool = ~ s14+  s19 :: SWord8 = s1 & s18+  s20 :: SBool = s17 /= s19+  s21 :: SBool = s_2 == s20+  s22 :: SBool = s0 == s4+  s23 :: SWord8 = s1 >>> 1+  s25 :: SWord8 = s23 | s24+  s27 :: SWord8 = s23 & s26+  s28 :: SWord8 = if s8 then s25 else s27+  s29 :: SBool = s2 == s4+  s30 :: SWord8 = if s29 then s3 else s7+  s31 :: SWord8 = if s22 then s1 else s30+  s32 :: SWord8 = if s22 then s28 else s31+  s33 :: SWord8 = s32 >>> 1+  s34 :: SWord8 = s26 & s33+  s35 :: SWord8 = if s22 then s34 else s28+  s36 :: SWord8 = s18 & s35+  s37 :: SBool = s17 /= s36+  s38 :: SBool = s_2 == s37+  s39 :: SWord8 = if s20 then s24 else s17+  s40 :: SWord8 = s18 & s39+  s41 :: SBool = s17 /= s40+  s42 :: SWord8 = s18 & s32+  s43 :: SBool = s17 /= s42+  s44 :: SWord8 = s35 >>> 1+  s45 :: SWord8 = s24 | s44+  s46 :: SWord8 = s26 & s44+  s47 :: SWord8 = if s43 then s45 else s46+  s48 :: SWord8 = if s22 then s47 else s34+  s49 :: SWord8 = s48 >>> 1+  s50 :: SWord8 = s24 | s49+  s51 :: SWord8 = s26 & s49+  s52 :: SWord8 = if s41 then s50 else s51+  s53 :: SWord8 = if s22 then s52 else s47+  s54 :: SWord8 = s18 & s53+  s55 :: SBool = s17 /= s54+  s56 :: SBool = s_2 == s55+  s57 :: SWord8 = s39 >>> 1+  s58 :: SWord8 = s24 | s57+  s59 :: SWord8 = s26 & s57+  s60 :: SWord8 = if s37 then s58 else s59+  s61 :: SWord8 = s18 & s60+  s62 :: SBool = s17 /= s61+  s63 :: SWord8 = s18 & s48+  s64 :: SBool = s17 /= s63+  s65 :: SWord8 = s53 >>> 1+  s66 :: SWord8 = s24 | s65+  s67 :: SWord8 = s26 & s65+  s68 :: SWord8 = if s64 then s66 else s67+  s69 :: SWord8 = if s22 then s68 else s52+  s70 :: SWord8 = s69 >>> 1+  s71 :: SWord8 = s24 | s70+  s72 :: SWord8 = s26 & s70+  s73 :: SWord8 = if s62 then s71 else s72+  s74 :: SWord8 = if s22 then s73 else s68+  s75 :: SWord8 = s18 & s74+  s76 :: SBool = s17 /= s75+  s77 :: SBool = s_2 == s76+  s78 :: SWord8 = s60 >>> 1+  s79 :: SWord8 = s24 | s78+  s80 :: SWord8 = s26 & s78+  s81 :: SWord8 = if s55 then s79 else s80+  s82 :: SWord8 = s18 & s81+  s83 :: SBool = s17 /= s82+  s84 :: SWord8 = s18 & s69+  s85 :: SBool = s17 /= s84+  s86 :: SWord8 = s74 >>> 1+  s87 :: SWord8 = s24 | s86+  s88 :: SWord8 = s26 & s86+  s89 :: SWord8 = if s85 then s87 else s88+  s90 :: SWord8 = if s22 then s89 else s73+  s91 :: SWord8 = s90 >>> 1+  s92 :: SWord8 = s24 | s91+  s93 :: SWord8 = s26 & s91+  s94 :: SWord8 = if s83 then s92 else s93+  s95 :: SWord8 = if s22 then s94 else s89+  s96 :: SWord8 = s18 & s95+  s97 :: SBool = s17 /= s96+  s98 :: SBool = s_2 == s97+  s99 :: SWord8 = s81 >>> 1+  s100 :: SWord8 = s24 | s99+  s101 :: SWord8 = s26 & s99+  s102 :: SWord8 = if s76 then s100 else s101+  s103 :: SWord8 = s18 & s102+  s104 :: SBool = s17 /= s103+  s105 :: SWord8 = s18 & s90+  s106 :: SBool = s17 /= s105+  s107 :: SWord8 = s95 >>> 1+  s108 :: SWord8 = s24 | s107+  s109 :: SWord8 = s26 & s107+  s110 :: SWord8 = if s106 then s108 else s109+  s111 :: SWord8 = if s22 then s110 else s94+  s112 :: SWord8 = s111 >>> 1+  s113 :: SWord8 = s24 | s112+  s114 :: SWord8 = s26 & s112+  s115 :: SWord8 = if s104 then s113 else s114+  s116 :: SWord8 = if s22 then s115 else s110+  s117 :: SWord8 = s18 & s116+  s118 :: SBool = s17 /= s117+  s119 :: SBool = s_2 == s118+  s120 :: SWord8 = s102 >>> 1+  s121 :: SWord8 = s24 | s120+  s122 :: SWord8 = s26 & s120+  s123 :: SWord8 = if s97 then s121 else s122+  s124 :: SWord8 = s18 & s123+  s125 :: SBool = s17 /= s124+  s126 :: SWord8 = s18 & s111+  s127 :: SBool = s17 /= s126+  s128 :: SWord8 = s116 >>> 1+  s129 :: SWord8 = s24 | s128+  s130 :: SWord8 = s26 & s128+  s131 :: SWord8 = if s127 then s129 else s130+  s132 :: SWord8 = if s22 then s131 else s115+  s133 :: SWord8 = s132 >>> 1+  s134 :: SWord8 = s24 | s133+  s135 :: SWord8 = s26 & s133+  s136 :: SWord8 = if s125 then s134 else s135+  s137 :: SWord8 = if s22 then s136 else s131+  s138 :: SWord8 = s18 & s137+  s139 :: SBool = s17 /= s138+  s140 :: SBool = s_2 == s139+  s141 :: SWord8 = s123 >>> 1+  s142 :: SWord8 = s24 | s141+  s143 :: SWord8 = s26 & s141+  s144 :: SWord8 = if s118 then s142 else s143+  s145 :: SWord8 = s18 & s144+  s146 :: SBool = s17 /= s145+  s147 :: SWord8 = s18 & s132+  s148 :: SBool = s17 /= s147+  s149 :: SWord8 = s137 >>> 1+  s150 :: SWord8 = s24 | s149+  s151 :: SWord8 = s26 & s149+  s152 :: SWord8 = if s148 then s150 else s151+  s153 :: SWord8 = if s22 then s152 else s136+  s154 :: SWord8 = s153 >>> 1+  s155 :: SWord8 = s24 | s154+  s156 :: SWord8 = s26 & s154+  s157 :: SWord8 = if s146 then s155 else s156+  s158 :: SWord8 = if s22 then s157 else s152+  s159 :: SWord8 = s18 & s158+  s160 :: SBool = s17 /= s159+  s161 :: SBool = s_2 == s160+  s162 :: SWord8 = s144 >>> 1+  s163 :: SWord8 = s24 | s162+  s164 :: SWord8 = s26 & s162+  s165 :: SWord8 = if s139 then s163 else s164+  s166 :: SWord8 = s165 >>> 1+  s167 :: SWord8 = s24 | s166+  s168 :: SWord8 = s26 & s166+  s169 :: SWord8 = if s160 then s167 else s168+  s170 :: SBool = s0 == s2+  s171 :: SWord8 = s18 & s153+  s172 :: SBool = s17 /= s171+  s173 :: SWord8 = s158 >>> 1+  s174 :: SWord8 = s24 | s173+  s175 :: SWord8 = s26 & s173+  s176 :: SWord8 = if s172 then s174 else s175+  s177 :: SWord8 = if s170 then s1 else s3+  s178 :: SWord8 = if s170 then s28 else s177+  s179 :: SWord8 = if s29 then s34 else s178+  s180 :: SWord8 = if s170 then s47 else s179+  s181 :: SWord8 = if s29 then s52 else s180+  s182 :: SWord8 = if s170 then s68 else s181+  s183 :: SWord8 = if s29 then s73 else s182+  s184 :: SWord8 = if s170 then s89 else s183+  s185 :: SWord8 = if s29 then s94 else s184+  s186 :: SWord8 = if s170 then s110 else s185+  s187 :: SWord8 = if s29 then s115 else s186+  s188 :: SWord8 = if s170 then s131 else s187+  s189 :: SWord8 = if s29 then s136 else s188+  s190 :: SWord8 = if s170 then s152 else s189+  s191 :: SWord8 = if s29 then s157 else s190+  s192 :: SWord8 = if s170 then s176 else s191+  s193 :: SWord8 = s165 + s192+  s194 :: SBool = s193 < s192+  s195 :: SBool = s193 < s165+  s196 :: SBool = s194 | s195+  s197 :: SWord8 = s193 >>> 1+  s198 :: SWord8 = s24 | s197+  s199 :: SWord8 = s26 & s197+  s200 :: SWord8 = if s196 then s198 else s199+  s201 :: SWord8 = if s161 then s169 else s200+  s202 :: SWord8 = s144 + s190+  s203 :: SWord8 = s18 & s202+  s204 :: SBool = s17 /= s203+  s205 :: SWord8 = if s204 then s155 else s156+  s206 :: SWord8 = if s22 then s205 else s152+  s207 :: SWord8 = s18 & s206+  s208 :: SBool = s17 /= s207+  s209 :: SBool = s_2 == s208+  s210 :: SBool = s202 < s190+  s211 :: SBool = s202 < s144+  s212 :: SBool = s210 | s211+  s213 :: SWord8 = s202 >>> 1+  s214 :: SWord8 = s24 | s213+  s215 :: SWord8 = s26 & s213+  s216 :: SWord8 = if s212 then s214 else s215+  s217 :: SWord8 = s216 >>> 1+  s218 :: SWord8 = s24 | s217+  s219 :: SWord8 = s26 & s217+  s220 :: SWord8 = if s208 then s218 else s219+  s221 :: SWord8 = s206 >>> 1+  s222 :: SWord8 = s24 | s221+  s223 :: SWord8 = s26 & s221+  s224 :: SWord8 = if s172 then s222 else s223+  s225 :: SWord8 = if s29 then s205 else s190+  s226 :: SWord8 = if s170 then s224 else s225+  s227 :: SWord8 = s216 + s226+  s228 :: SBool = s227 < s226+  s229 :: SBool = s227 < s216+  s230 :: SBool = s228 | s229+  s231 :: SWord8 = s227 >>> 1+  s232 :: SWord8 = s24 | s231+  s233 :: SWord8 = s26 & s231+  s234 :: SWord8 = if s230 then s232 else s233+  s235 :: SWord8 = if s209 then s220 else s234+  s236 :: SWord8 = if s140 then s201 else s235+  s237 :: SWord8 = s123 + s188+  s238 :: SWord8 = s18 & s237+  s239 :: SBool = s17 /= s238+  s240 :: SWord8 = if s239 then s134 else s135+  s241 :: SWord8 = if s22 then s240 else s131+  s242 :: SWord8 = s18 & s241+  s243 :: SBool = s17 /= s242+  s244 :: SBool = s_2 == s243+  s245 :: SBool = s237 < s188+  s246 :: SBool = s237 < s123+  s247 :: SBool = s245 | s246+  s248 :: SWord8 = s237 >>> 1+  s249 :: SWord8 = s24 | s248+  s250 :: SWord8 = s26 & s248+  s251 :: SWord8 = if s247 then s249 else s250+  s252 :: SWord8 = s18 & s251+  s253 :: SBool = s17 /= s252+  s254 :: SWord8 = s241 >>> 1+  s255 :: SWord8 = s24 | s254+  s256 :: SWord8 = s26 & s254+  s257 :: SWord8 = if s148 then s255 else s256+  s258 :: SWord8 = if s22 then s257 else s240+  s259 :: SWord8 = s258 >>> 1+  s260 :: SWord8 = s24 | s259+  s261 :: SWord8 = s26 & s259+  s262 :: SWord8 = if s253 then s260 else s261+  s263 :: SWord8 = if s22 then s262 else s257+  s264 :: SWord8 = s18 & s263+  s265 :: SBool = s17 /= s264+  s266 :: SBool = s_2 == s265+  s267 :: SWord8 = s251 >>> 1+  s268 :: SWord8 = s24 | s267+  s269 :: SWord8 = s26 & s267+  s270 :: SWord8 = if s243 then s268 else s269+  s271 :: SWord8 = s270 >>> 1+  s272 :: SWord8 = s24 | s271+  s273 :: SWord8 = s26 & s271+  s274 :: SWord8 = if s265 then s272 else s273+  s275 :: SWord8 = s18 & s258+  s276 :: SBool = s17 /= s275+  s277 :: SWord8 = s263 >>> 1+  s278 :: SWord8 = s24 | s277+  s279 :: SWord8 = s26 & s277+  s280 :: SWord8 = if s276 then s278 else s279+  s281 :: SWord8 = if s29 then s240 else s188+  s282 :: SWord8 = if s170 then s257 else s281+  s283 :: SWord8 = if s29 then s262 else s282+  s284 :: SWord8 = if s170 then s280 else s283+  s285 :: SWord8 = s270 + s284+  s286 :: SBool = s285 < s284+  s287 :: SBool = s285 < s270+  s288 :: SBool = s286 | s287+  s289 :: SWord8 = s285 >>> 1+  s290 :: SWord8 = s24 | s289+  s291 :: SWord8 = s26 & s289+  s292 :: SWord8 = if s288 then s290 else s291+  s293 :: SWord8 = if s266 then s274 else s292+  s294 :: SWord8 = s251 + s282+  s295 :: SWord8 = s18 & s294+  s296 :: SBool = s17 /= s295+  s297 :: SWord8 = if s296 then s260 else s261+  s298 :: SWord8 = if s22 then s297 else s257+  s299 :: SWord8 = s18 & s298+  s300 :: SBool = s17 /= s299+  s301 :: SBool = s_2 == s300+  s302 :: SBool = s294 < s282+  s303 :: SBool = s294 < s251+  s304 :: SBool = s302 | s303+  s305 :: SWord8 = s294 >>> 1+  s306 :: SWord8 = s24 | s305+  s307 :: SWord8 = s26 & s305+  s308 :: SWord8 = if s304 then s306 else s307+  s309 :: SWord8 = s308 >>> 1+  s310 :: SWord8 = s24 | s309+  s311 :: SWord8 = s26 & s309+  s312 :: SWord8 = if s300 then s310 else s311+  s313 :: SWord8 = s298 >>> 1+  s314 :: SWord8 = s24 | s313+  s315 :: SWord8 = s26 & s313+  s316 :: SWord8 = if s276 then s314 else s315+  s317 :: SWord8 = if s29 then s297 else s282+  s318 :: SWord8 = if s170 then s316 else s317+  s319 :: SWord8 = s308 + s318+  s320 :: SBool = s319 < s318+  s321 :: SBool = s319 < s308+  s322 :: SBool = s320 | s321+  s323 :: SWord8 = s319 >>> 1+  s324 :: SWord8 = s24 | s323+  s325 :: SWord8 = s26 & s323+  s326 :: SWord8 = if s322 then s324 else s325+  s327 :: SWord8 = if s301 then s312 else s326+  s328 :: SWord8 = if s244 then s293 else s327+  s329 :: SWord8 = if s119 then s236 else s328+  s330 :: SWord8 = s102 + s186+  s331 :: SWord8 = s18 & s330+  s332 :: SBool = s17 /= s331+  s333 :: SWord8 = if s332 then s113 else s114+  s334 :: SWord8 = if s22 then s333 else s110+  s335 :: SWord8 = s18 & s334+  s336 :: SBool = s17 /= s335+  s337 :: SBool = s_2 == s336+  s338 :: SBool = s330 < s186+  s339 :: SBool = s330 < s102+  s340 :: SBool = s338 | s339+  s341 :: SWord8 = s330 >>> 1+  s342 :: SWord8 = s24 | s341+  s343 :: SWord8 = s26 & s341+  s344 :: SWord8 = if s340 then s342 else s343+  s345 :: SWord8 = s18 & s344+  s346 :: SBool = s17 /= s345+  s347 :: SWord8 = s334 >>> 1+  s348 :: SWord8 = s24 | s347+  s349 :: SWord8 = s26 & s347+  s350 :: SWord8 = if s127 then s348 else s349+  s351 :: SWord8 = if s22 then s350 else s333+  s352 :: SWord8 = s351 >>> 1+  s353 :: SWord8 = s24 | s352+  s354 :: SWord8 = s26 & s352+  s355 :: SWord8 = if s346 then s353 else s354+  s356 :: SWord8 = if s22 then s355 else s350+  s357 :: SWord8 = s18 & s356+  s358 :: SBool = s17 /= s357+  s359 :: SBool = s_2 == s358+  s360 :: SWord8 = s344 >>> 1+  s361 :: SWord8 = s24 | s360+  s362 :: SWord8 = s26 & s360+  s363 :: SWord8 = if s336 then s361 else s362+  s364 :: SWord8 = s18 & s363+  s365 :: SBool = s17 /= s364+  s366 :: SWord8 = s18 & s351+  s367 :: SBool = s17 /= s366+  s368 :: SWord8 = s356 >>> 1+  s369 :: SWord8 = s24 | s368+  s370 :: SWord8 = s26 & s368+  s371 :: SWord8 = if s367 then s369 else s370+  s372 :: SWord8 = if s22 then s371 else s355+  s373 :: SWord8 = s372 >>> 1+  s374 :: SWord8 = s24 | s373+  s375 :: SWord8 = s26 & s373+  s376 :: SWord8 = if s365 then s374 else s375+  s377 :: SWord8 = if s22 then s376 else s371+  s378 :: SWord8 = s18 & s377+  s379 :: SBool = s17 /= s378+  s380 :: SBool = s_2 == s379+  s381 :: SWord8 = s363 >>> 1+  s382 :: SWord8 = s24 | s381+  s383 :: SWord8 = s26 & s381+  s384 :: SWord8 = if s358 then s382 else s383+  s385 :: SWord8 = s384 >>> 1+  s386 :: SWord8 = s24 | s385+  s387 :: SWord8 = s26 & s385+  s388 :: SWord8 = if s379 then s386 else s387+  s389 :: SWord8 = s18 & s372+  s390 :: SBool = s17 /= s389+  s391 :: SWord8 = s377 >>> 1+  s392 :: SWord8 = s24 | s391+  s393 :: SWord8 = s26 & s391+  s394 :: SWord8 = if s390 then s392 else s393+  s395 :: SWord8 = if s29 then s333 else s186+  s396 :: SWord8 = if s170 then s350 else s395+  s397 :: SWord8 = if s29 then s355 else s396+  s398 :: SWord8 = if s170 then s371 else s397+  s399 :: SWord8 = if s29 then s376 else s398+  s400 :: SWord8 = if s170 then s394 else s399+  s401 :: SWord8 = s384 + s400+  s402 :: SBool = s401 < s400+  s403 :: SBool = s401 < s384+  s404 :: SBool = s402 | s403+  s405 :: SWord8 = s401 >>> 1+  s406 :: SWord8 = s24 | s405+  s407 :: SWord8 = s26 & s405+  s408 :: SWord8 = if s404 then s406 else s407+  s409 :: SWord8 = if s380 then s388 else s408+  s410 :: SWord8 = s363 + s398+  s411 :: SWord8 = s18 & s410+  s412 :: SBool = s17 /= s411+  s413 :: SWord8 = if s412 then s374 else s375+  s414 :: SWord8 = if s22 then s413 else s371+  s415 :: SWord8 = s18 & s414+  s416 :: SBool = s17 /= s415+  s417 :: SBool = s_2 == s416+  s418 :: SBool = s410 < s398+  s419 :: SBool = s410 < s363+  s420 :: SBool = s418 | s419+  s421 :: SWord8 = s410 >>> 1+  s422 :: SWord8 = s24 | s421+  s423 :: SWord8 = s26 & s421+  s424 :: SWord8 = if s420 then s422 else s423+  s425 :: SWord8 = s424 >>> 1+  s426 :: SWord8 = s24 | s425+  s427 :: SWord8 = s26 & s425+  s428 :: SWord8 = if s416 then s426 else s427+  s429 :: SWord8 = s414 >>> 1+  s430 :: SWord8 = s24 | s429+  s431 :: SWord8 = s26 & s429+  s432 :: SWord8 = if s390 then s430 else s431+  s433 :: SWord8 = if s29 then s413 else s398+  s434 :: SWord8 = if s170 then s432 else s433+  s435 :: SWord8 = s424 + s434+  s436 :: SBool = s435 < s434+  s437 :: SBool = s435 < s424+  s438 :: SBool = s436 | s437+  s439 :: SWord8 = s435 >>> 1+  s440 :: SWord8 = s24 | s439+  s441 :: SWord8 = s26 & s439+  s442 :: SWord8 = if s438 then s440 else s441+  s443 :: SWord8 = if s417 then s428 else s442+  s444 :: SWord8 = if s359 then s409 else s443+  s445 :: SWord8 = s344 + s396+  s446 :: SWord8 = s18 & s445+  s447 :: SBool = s17 /= s446+  s448 :: SWord8 = if s447 then s353 else s354+  s449 :: SWord8 = if s22 then s448 else s350+  s450 :: SWord8 = s18 & s449+  s451 :: SBool = s17 /= s450+  s452 :: SBool = s_2 == s451+  s453 :: SBool = s445 < s396+  s454 :: SBool = s445 < s344+  s455 :: SBool = s453 | s454+  s456 :: SWord8 = s445 >>> 1+  s457 :: SWord8 = s24 | s456+  s458 :: SWord8 = s26 & s456+  s459 :: SWord8 = if s455 then s457 else s458+  s460 :: SWord8 = s18 & s459+  s461 :: SBool = s17 /= s460+  s462 :: SWord8 = s449 >>> 1+  s463 :: SWord8 = s24 | s462+  s464 :: SWord8 = s26 & s462+  s465 :: SWord8 = if s367 then s463 else s464+  s466 :: SWord8 = if s22 then s465 else s448+  s467 :: SWord8 = s466 >>> 1+  s468 :: SWord8 = s24 | s467+  s469 :: SWord8 = s26 & s467+  s470 :: SWord8 = if s461 then s468 else s469+  s471 :: SWord8 = if s22 then s470 else s465+  s472 :: SWord8 = s18 & s471+  s473 :: SBool = s17 /= s472+  s474 :: SBool = s_2 == s473+  s475 :: SWord8 = s459 >>> 1+  s476 :: SWord8 = s24 | s475+  s477 :: SWord8 = s26 & s475+  s478 :: SWord8 = if s451 then s476 else s477+  s479 :: SWord8 = s478 >>> 1+  s480 :: SWord8 = s24 | s479+  s481 :: SWord8 = s26 & s479+  s482 :: SWord8 = if s473 then s480 else s481+  s483 :: SWord8 = s18 & s466+  s484 :: SBool = s17 /= s483+  s485 :: SWord8 = s471 >>> 1+  s486 :: SWord8 = s24 | s485+  s487 :: SWord8 = s26 & s485+  s488 :: SWord8 = if s484 then s486 else s487+  s489 :: SWord8 = if s29 then s448 else s396+  s490 :: SWord8 = if s170 then s465 else s489+  s491 :: SWord8 = if s29 then s470 else s490+  s492 :: SWord8 = if s170 then s488 else s491+  s493 :: SWord8 = s478 + s492+  s494 :: SBool = s493 < s492+  s495 :: SBool = s493 < s478+  s496 :: SBool = s494 | s495+  s497 :: SWord8 = s493 >>> 1+  s498 :: SWord8 = s24 | s497+  s499 :: SWord8 = s26 & s497+  s500 :: SWord8 = if s496 then s498 else s499+  s501 :: SWord8 = if s474 then s482 else s500+  s502 :: SWord8 = s459 + s490+  s503 :: SWord8 = s18 & s502+  s504 :: SBool = s17 /= s503+  s505 :: SWord8 = if s504 then s468 else s469+  s506 :: SWord8 = if s22 then s505 else s465+  s507 :: SWord8 = s18 & s506+  s508 :: SBool = s17 /= s507+  s509 :: SBool = s_2 == s508+  s510 :: SBool = s502 < s490+  s511 :: SBool = s502 < s459+  s512 :: SBool = s510 | s511+  s513 :: SWord8 = s502 >>> 1+  s514 :: SWord8 = s24 | s513+  s515 :: SWord8 = s26 & s513+  s516 :: SWord8 = if s512 then s514 else s515+  s517 :: SWord8 = s516 >>> 1+  s518 :: SWord8 = s24 | s517+  s519 :: SWord8 = s26 & s517+  s520 :: SWord8 = if s508 then s518 else s519+  s521 :: SWord8 = s506 >>> 1+  s522 :: SWord8 = s24 | s521+  s523 :: SWord8 = s26 & s521+  s524 :: SWord8 = if s484 then s522 else s523+  s525 :: SWord8 = if s29 then s505 else s490+  s526 :: SWord8 = if s170 then s524 else s525+  s527 :: SWord8 = s516 + s526+  s528 :: SBool = s527 < s526+  s529 :: SBool = s527 < s516+  s530 :: SBool = s528 | s529+  s531 :: SWord8 = s527 >>> 1+  s532 :: SWord8 = s24 | s531+  s533 :: SWord8 = s26 & s531+  s534 :: SWord8 = if s530 then s532 else s533+  s535 :: SWord8 = if s509 then s520 else s534+  s536 :: SWord8 = if s452 then s501 else s535+  s537 :: SWord8 = if s337 then s444 else s536+  s538 :: SWord8 = if s98 then s329 else s537+  s539 :: SWord8 = s81 + s184+  s540 :: SWord8 = s18 & s539+  s541 :: SBool = s17 /= s540+  s542 :: SWord8 = if s541 then s92 else s93+  s543 :: SWord8 = if s22 then s542 else s89+  s544 :: SWord8 = s18 & s543+  s545 :: SBool = s17 /= s544+  s546 :: SBool = s_2 == s545+  s547 :: SBool = s539 < s184+  s548 :: SBool = s539 < s81+  s549 :: SBool = s547 | s548+  s550 :: SWord8 = s539 >>> 1+  s551 :: SWord8 = s24 | s550+  s552 :: SWord8 = s26 & s550+  s553 :: SWord8 = if s549 then s551 else s552+  s554 :: SWord8 = s18 & s553+  s555 :: SBool = s17 /= s554+  s556 :: SWord8 = s543 >>> 1+  s557 :: SWord8 = s24 | s556+  s558 :: SWord8 = s26 & s556+  s559 :: SWord8 = if s106 then s557 else s558+  s560 :: SWord8 = if s22 then s559 else s542+  s561 :: SWord8 = s560 >>> 1+  s562 :: SWord8 = s24 | s561+  s563 :: SWord8 = s26 & s561+  s564 :: SWord8 = if s555 then s562 else s563+  s565 :: SWord8 = if s22 then s564 else s559+  s566 :: SWord8 = s18 & s565+  s567 :: SBool = s17 /= s566+  s568 :: SBool = s_2 == s567+  s569 :: SWord8 = s553 >>> 1+  s570 :: SWord8 = s24 | s569+  s571 :: SWord8 = s26 & s569+  s572 :: SWord8 = if s545 then s570 else s571+  s573 :: SWord8 = s18 & s572+  s574 :: SBool = s17 /= s573+  s575 :: SWord8 = s18 & s560+  s576 :: SBool = s17 /= s575+  s577 :: SWord8 = s565 >>> 1+  s578 :: SWord8 = s24 | s577+  s579 :: SWord8 = s26 & s577+  s580 :: SWord8 = if s576 then s578 else s579+  s581 :: SWord8 = if s22 then s580 else s564+  s582 :: SWord8 = s581 >>> 1+  s583 :: SWord8 = s24 | s582+  s584 :: SWord8 = s26 & s582+  s585 :: SWord8 = if s574 then s583 else s584+  s586 :: SWord8 = if s22 then s585 else s580+  s587 :: SWord8 = s18 & s586+  s588 :: SBool = s17 /= s587+  s589 :: SBool = s_2 == s588+  s590 :: SWord8 = s572 >>> 1+  s591 :: SWord8 = s24 | s590+  s592 :: SWord8 = s26 & s590+  s593 :: SWord8 = if s567 then s591 else s592+  s594 :: SWord8 = s18 & s593+  s595 :: SBool = s17 /= s594+  s596 :: SWord8 = s18 & s581+  s597 :: SBool = s17 /= s596+  s598 :: SWord8 = s586 >>> 1+  s599 :: SWord8 = s24 | s598+  s600 :: SWord8 = s26 & s598+  s601 :: SWord8 = if s597 then s599 else s600+  s602 :: SWord8 = if s22 then s601 else s585+  s603 :: SWord8 = s602 >>> 1+  s604 :: SWord8 = s24 | s603+  s605 :: SWord8 = s26 & s603+  s606 :: SWord8 = if s595 then s604 else s605+  s607 :: SWord8 = if s22 then s606 else s601+  s608 :: SWord8 = s18 & s607+  s609 :: SBool = s17 /= s608+  s610 :: SBool = s_2 == s609+  s611 :: SWord8 = s593 >>> 1+  s612 :: SWord8 = s24 | s611+  s613 :: SWord8 = s26 & s611+  s614 :: SWord8 = if s588 then s612 else s613+  s615 :: SWord8 = s614 >>> 1+  s616 :: SWord8 = s24 | s615+  s617 :: SWord8 = s26 & s615+  s618 :: SWord8 = if s609 then s616 else s617+  s619 :: SWord8 = s18 & s602+  s620 :: SBool = s17 /= s619+  s621 :: SWord8 = s607 >>> 1+  s622 :: SWord8 = s24 | s621+  s623 :: SWord8 = s26 & s621+  s624 :: SWord8 = if s620 then s622 else s623+  s625 :: SWord8 = if s29 then s542 else s184+  s626 :: SWord8 = if s170 then s559 else s625+  s627 :: SWord8 = if s29 then s564 else s626+  s628 :: SWord8 = if s170 then s580 else s627+  s629 :: SWord8 = if s29 then s585 else s628+  s630 :: SWord8 = if s170 then s601 else s629+  s631 :: SWord8 = if s29 then s606 else s630+  s632 :: SWord8 = if s170 then s624 else s631+  s633 :: SWord8 = s614 + s632+  s634 :: SBool = s633 < s632+  s635 :: SBool = s633 < s614+  s636 :: SBool = s634 | s635+  s637 :: SWord8 = s633 >>> 1+  s638 :: SWord8 = s24 | s637+  s639 :: SWord8 = s26 & s637+  s640 :: SWord8 = if s636 then s638 else s639+  s641 :: SWord8 = if s610 then s618 else s640+  s642 :: SWord8 = s593 + s630+  s643 :: SWord8 = s18 & s642+  s644 :: SBool = s17 /= s643+  s645 :: SWord8 = if s644 then s604 else s605+  s646 :: SWord8 = if s22 then s645 else s601+  s647 :: SWord8 = s18 & s646+  s648 :: SBool = s17 /= s647+  s649 :: SBool = s_2 == s648+  s650 :: SBool = s642 < s630+  s651 :: SBool = s642 < s593+  s652 :: SBool = s650 | s651+  s653 :: SWord8 = s642 >>> 1+  s654 :: SWord8 = s24 | s653+  s655 :: SWord8 = s26 & s653+  s656 :: SWord8 = if s652 then s654 else s655+  s657 :: SWord8 = s656 >>> 1+  s658 :: SWord8 = s24 | s657+  s659 :: SWord8 = s26 & s657+  s660 :: SWord8 = if s648 then s658 else s659+  s661 :: SWord8 = s646 >>> 1+  s662 :: SWord8 = s24 | s661+  s663 :: SWord8 = s26 & s661+  s664 :: SWord8 = if s620 then s662 else s663+  s665 :: SWord8 = if s29 then s645 else s630+  s666 :: SWord8 = if s170 then s664 else s665+  s667 :: SWord8 = s656 + s666+  s668 :: SBool = s667 < s666+  s669 :: SBool = s667 < s656+  s670 :: SBool = s668 | s669+  s671 :: SWord8 = s667 >>> 1+  s672 :: SWord8 = s24 | s671+  s673 :: SWord8 = s26 & s671+  s674 :: SWord8 = if s670 then s672 else s673+  s675 :: SWord8 = if s649 then s660 else s674+  s676 :: SWord8 = if s589 then s641 else s675+  s677 :: SWord8 = s572 + s628+  s678 :: SWord8 = s18 & s677+  s679 :: SBool = s17 /= s678+  s680 :: SWord8 = if s679 then s583 else s584+  s681 :: SWord8 = if s22 then s680 else s580+  s682 :: SWord8 = s18 & s681+  s683 :: SBool = s17 /= s682+  s684 :: SBool = s_2 == s683+  s685 :: SBool = s677 < s628+  s686 :: SBool = s677 < s572+  s687 :: SBool = s685 | s686+  s688 :: SWord8 = s677 >>> 1+  s689 :: SWord8 = s24 | s688+  s690 :: SWord8 = s26 & s688+  s691 :: SWord8 = if s687 then s689 else s690+  s692 :: SWord8 = s18 & s691+  s693 :: SBool = s17 /= s692+  s694 :: SWord8 = s681 >>> 1+  s695 :: SWord8 = s24 | s694+  s696 :: SWord8 = s26 & s694+  s697 :: SWord8 = if s597 then s695 else s696+  s698 :: SWord8 = if s22 then s697 else s680+  s699 :: SWord8 = s698 >>> 1+  s700 :: SWord8 = s24 | s699+  s701 :: SWord8 = s26 & s699+  s702 :: SWord8 = if s693 then s700 else s701+  s703 :: SWord8 = if s22 then s702 else s697+  s704 :: SWord8 = s18 & s703+  s705 :: SBool = s17 /= s704+  s706 :: SBool = s_2 == s705+  s707 :: SWord8 = s691 >>> 1+  s708 :: SWord8 = s24 | s707+  s709 :: SWord8 = s26 & s707+  s710 :: SWord8 = if s683 then s708 else s709+  s711 :: SWord8 = s710 >>> 1+  s712 :: SWord8 = s24 | s711+  s713 :: SWord8 = s26 & s711+  s714 :: SWord8 = if s705 then s712 else s713+  s715 :: SWord8 = s18 & s698+  s716 :: SBool = s17 /= s715+  s717 :: SWord8 = s703 >>> 1+  s718 :: SWord8 = s24 | s717+  s719 :: SWord8 = s26 & s717+  s720 :: SWord8 = if s716 then s718 else s719+  s721 :: SWord8 = if s29 then s680 else s628+  s722 :: SWord8 = if s170 then s697 else s721+  s723 :: SWord8 = if s29 then s702 else s722+  s724 :: SWord8 = if s170 then s720 else s723+  s725 :: SWord8 = s710 + s724+  s726 :: SBool = s725 < s724+  s727 :: SBool = s725 < s710+  s728 :: SBool = s726 | s727+  s729 :: SWord8 = s725 >>> 1+  s730 :: SWord8 = s24 | s729+  s731 :: SWord8 = s26 & s729+  s732 :: SWord8 = if s728 then s730 else s731+  s733 :: SWord8 = if s706 then s714 else s732+  s734 :: SWord8 = s691 + s722+  s735 :: SWord8 = s18 & s734+  s736 :: SBool = s17 /= s735+  s737 :: SWord8 = if s736 then s700 else s701+  s738 :: SWord8 = if s22 then s737 else s697+  s739 :: SWord8 = s18 & s738+  s740 :: SBool = s17 /= s739+  s741 :: SBool = s_2 == s740+  s742 :: SBool = s734 < s722+  s743 :: SBool = s734 < s691+  s744 :: SBool = s742 | s743+  s745 :: SWord8 = s734 >>> 1+  s746 :: SWord8 = s24 | s745+  s747 :: SWord8 = s26 & s745+  s748 :: SWord8 = if s744 then s746 else s747+  s749 :: SWord8 = s748 >>> 1+  s750 :: SWord8 = s24 | s749+  s751 :: SWord8 = s26 & s749+  s752 :: SWord8 = if s740 then s750 else s751+  s753 :: SWord8 = s738 >>> 1+  s754 :: SWord8 = s24 | s753+  s755 :: SWord8 = s26 & s753+  s756 :: SWord8 = if s716 then s754 else s755+  s757 :: SWord8 = if s29 then s737 else s722+  s758 :: SWord8 = if s170 then s756 else s757+  s759 :: SWord8 = s748 + s758+  s760 :: SBool = s759 < s758+  s761 :: SBool = s759 < s748+  s762 :: SBool = s760 | s761+  s763 :: SWord8 = s759 >>> 1+  s764 :: SWord8 = s24 | s763+  s765 :: SWord8 = s26 & s763+  s766 :: SWord8 = if s762 then s764 else s765+  s767 :: SWord8 = if s741 then s752 else s766+  s768 :: SWord8 = if s684 then s733 else s767+  s769 :: SWord8 = if s568 then s676 else s768+  s770 :: SWord8 = s553 + s626+  s771 :: SWord8 = s18 & s770+  s772 :: SBool = s17 /= s771+  s773 :: SWord8 = if s772 then s562 else s563+  s774 :: SWord8 = if s22 then s773 else s559+  s775 :: SWord8 = s18 & s774+  s776 :: SBool = s17 /= s775+  s777 :: SBool = s_2 == s776+  s778 :: SBool = s770 < s626+  s779 :: SBool = s770 < s553+  s780 :: SBool = s778 | s779+  s781 :: SWord8 = s770 >>> 1+  s782 :: SWord8 = s24 | s781+  s783 :: SWord8 = s26 & s781+  s784 :: SWord8 = if s780 then s782 else s783+  s785 :: SWord8 = s18 & s784+  s786 :: SBool = s17 /= s785+  s787 :: SWord8 = s774 >>> 1+  s788 :: SWord8 = s24 | s787+  s789 :: SWord8 = s26 & s787+  s790 :: SWord8 = if s576 then s788 else s789+  s791 :: SWord8 = if s22 then s790 else s773+  s792 :: SWord8 = s791 >>> 1+  s793 :: SWord8 = s24 | s792+  s794 :: SWord8 = s26 & s792+  s795 :: SWord8 = if s786 then s793 else s794+  s796 :: SWord8 = if s22 then s795 else s790+  s797 :: SWord8 = s18 & s796+  s798 :: SBool = s17 /= s797+  s799 :: SBool = s_2 == s798+  s800 :: SWord8 = s784 >>> 1+  s801 :: SWord8 = s24 | s800+  s802 :: SWord8 = s26 & s800+  s803 :: SWord8 = if s776 then s801 else s802+  s804 :: SWord8 = s18 & s803+  s805 :: SBool = s17 /= s804+  s806 :: SWord8 = s18 & s791+  s807 :: SBool = s17 /= s806+  s808 :: SWord8 = s796 >>> 1+  s809 :: SWord8 = s24 | s808+  s810 :: SWord8 = s26 & s808+  s811 :: SWord8 = if s807 then s809 else s810+  s812 :: SWord8 = if s22 then s811 else s795+  s813 :: SWord8 = s812 >>> 1+  s814 :: SWord8 = s24 | s813+  s815 :: SWord8 = s26 & s813+  s816 :: SWord8 = if s805 then s814 else s815+  s817 :: SWord8 = if s22 then s816 else s811+  s818 :: SWord8 = s18 & s817+  s819 :: SBool = s17 /= s818+  s820 :: SBool = s_2 == s819+  s821 :: SWord8 = s803 >>> 1+  s822 :: SWord8 = s24 | s821+  s823 :: SWord8 = s26 & s821+  s824 :: SWord8 = if s798 then s822 else s823+  s825 :: SWord8 = s824 >>> 1+  s826 :: SWord8 = s24 | s825+  s827 :: SWord8 = s26 & s825+  s828 :: SWord8 = if s819 then s826 else s827+  s829 :: SWord8 = s18 & s812+  s830 :: SBool = s17 /= s829+  s831 :: SWord8 = s817 >>> 1+  s832 :: SWord8 = s24 | s831+  s833 :: SWord8 = s26 & s831+  s834 :: SWord8 = if s830 then s832 else s833+  s835 :: SWord8 = if s29 then s773 else s626+  s836 :: SWord8 = if s170 then s790 else s835+  s837 :: SWord8 = if s29 then s795 else s836+  s838 :: SWord8 = if s170 then s811 else s837+  s839 :: SWord8 = if s29 then s816 else s838+  s840 :: SWord8 = if s170 then s834 else s839+  s841 :: SWord8 = s824 + s840+  s842 :: SBool = s841 < s840+  s843 :: SBool = s841 < s824+  s844 :: SBool = s842 | s843+  s845 :: SWord8 = s841 >>> 1+  s846 :: SWord8 = s24 | s845+  s847 :: SWord8 = s26 & s845+  s848 :: SWord8 = if s844 then s846 else s847+  s849 :: SWord8 = if s820 then s828 else s848+  s850 :: SWord8 = s803 + s838+  s851 :: SWord8 = s18 & s850+  s852 :: SBool = s17 /= s851+  s853 :: SWord8 = if s852 then s814 else s815+  s854 :: SWord8 = if s22 then s853 else s811+  s855 :: SWord8 = s18 & s854+  s856 :: SBool = s17 /= s855+  s857 :: SBool = s_2 == s856+  s858 :: SBool = s850 < s838+  s859 :: SBool = s850 < s803+  s860 :: SBool = s858 | s859+  s861 :: SWord8 = s850 >>> 1+  s862 :: SWord8 = s24 | s861+  s863 :: SWord8 = s26 & s861+  s864 :: SWord8 = if s860 then s862 else s863+  s865 :: SWord8 = s864 >>> 1+  s866 :: SWord8 = s24 | s865+  s867 :: SWord8 = s26 & s865+  s868 :: SWord8 = if s856 then s866 else s867+  s869 :: SWord8 = s854 >>> 1+  s870 :: SWord8 = s24 | s869+  s871 :: SWord8 = s26 & s869+  s872 :: SWord8 = if s830 then s870 else s871+  s873 :: SWord8 = if s29 then s853 else s838+  s874 :: SWord8 = if s170 then s872 else s873+  s875 :: SWord8 = s864 + s874+  s876 :: SBool = s875 < s874+  s877 :: SBool = s875 < s864+  s878 :: SBool = s876 | s877+  s879 :: SWord8 = s875 >>> 1+  s880 :: SWord8 = s24 | s879+  s881 :: SWord8 = s26 & s879+  s882 :: SWord8 = if s878 then s880 else s881+  s883 :: SWord8 = if s857 then s868 else s882+  s884 :: SWord8 = if s799 then s849 else s883+  s885 :: SWord8 = s784 + s836+  s886 :: SWord8 = s18 & s885+  s887 :: SBool = s17 /= s886+  s888 :: SWord8 = if s887 then s793 else s794+  s889 :: SWord8 = if s22 then s888 else s790+  s890 :: SWord8 = s18 & s889+  s891 :: SBool = s17 /= s890+  s892 :: SBool = s_2 == s891+  s893 :: SBool = s885 < s836+  s894 :: SBool = s885 < s784+  s895 :: SBool = s893 | s894+  s896 :: SWord8 = s885 >>> 1+  s897 :: SWord8 = s24 | s896+  s898 :: SWord8 = s26 & s896+  s899 :: SWord8 = if s895 then s897 else s898+  s900 :: SWord8 = s18 & s899+  s901 :: SBool = s17 /= s900+  s902 :: SWord8 = s889 >>> 1+  s903 :: SWord8 = s24 | s902+  s904 :: SWord8 = s26 & s902+  s905 :: SWord8 = if s807 then s903 else s904+  s906 :: SWord8 = if s22 then s905 else s888+  s907 :: SWord8 = s906 >>> 1+  s908 :: SWord8 = s24 | s907+  s909 :: SWord8 = s26 & s907+  s910 :: SWord8 = if s901 then s908 else s909+  s911 :: SWord8 = if s22 then s910 else s905+  s912 :: SWord8 = s18 & s911+  s913 :: SBool = s17 /= s912+  s914 :: SBool = s_2 == s913+  s915 :: SWord8 = s899 >>> 1+  s916 :: SWord8 = s24 | s915+  s917 :: SWord8 = s26 & s915+  s918 :: SWord8 = if s891 then s916 else s917+  s919 :: SWord8 = s918 >>> 1+  s920 :: SWord8 = s24 | s919+  s921 :: SWord8 = s26 & s919+  s922 :: SWord8 = if s913 then s920 else s921+  s923 :: SWord8 = s18 & s906+  s924 :: SBool = s17 /= s923+  s925 :: SWord8 = s911 >>> 1+  s926 :: SWord8 = s24 | s925+  s927 :: SWord8 = s26 & s925+  s928 :: SWord8 = if s924 then s926 else s927+  s929 :: SWord8 = if s29 then s888 else s836+  s930 :: SWord8 = if s170 then s905 else s929+  s931 :: SWord8 = if s29 then s910 else s930+  s932 :: SWord8 = if s170 then s928 else s931+  s933 :: SWord8 = s918 + s932+  s934 :: SBool = s933 < s932+  s935 :: SBool = s933 < s918+  s936 :: SBool = s934 | s935+  s937 :: SWord8 = s933 >>> 1+  s938 :: SWord8 = s24 | s937+  s939 :: SWord8 = s26 & s937+  s940 :: SWord8 = if s936 then s938 else s939+  s941 :: SWord8 = if s914 then s922 else s940+  s942 :: SWord8 = s899 + s930+  s943 :: SWord8 = s18 & s942+  s944 :: SBool = s17 /= s943+  s945 :: SWord8 = if s944 then s908 else s909+  s946 :: SWord8 = if s22 then s945 else s905+  s947 :: SWord8 = s18 & s946+  s948 :: SBool = s17 /= s947+  s949 :: SBool = s_2 == s948+  s950 :: SBool = s942 < s930+  s951 :: SBool = s942 < s899+  s952 :: SBool = s950 | s951+  s953 :: SWord8 = s942 >>> 1+  s954 :: SWord8 = s24 | s953+  s955 :: SWord8 = s26 & s953+  s956 :: SWord8 = if s952 then s954 else s955+  s957 :: SWord8 = s956 >>> 1+  s958 :: SWord8 = s24 | s957+  s959 :: SWord8 = s26 & s957+  s960 :: SWord8 = if s948 then s958 else s959+  s961 :: SWord8 = s946 >>> 1+  s962 :: SWord8 = s24 | s961+  s963 :: SWord8 = s26 & s961+  s964 :: SWord8 = if s924 then s962 else s963+  s965 :: SWord8 = if s29 then s945 else s930+  s966 :: SWord8 = if s170 then s964 else s965+  s967 :: SWord8 = s956 + s966+  s968 :: SBool = s967 < s966+  s969 :: SBool = s967 < s956+  s970 :: SBool = s968 | s969+  s971 :: SWord8 = s967 >>> 1+  s972 :: SWord8 = s24 | s971+  s973 :: SWord8 = s26 & s971+  s974 :: SWord8 = if s970 then s972 else s973+  s975 :: SWord8 = if s949 then s960 else s974+  s976 :: SWord8 = if s892 then s941 else s975+  s977 :: SWord8 = if s777 then s884 else s976+  s978 :: SWord8 = if s546 then s769 else s977+  s979 :: SWord8 = if s77 then s538 else s978+  s980 :: SWord8 = s60 + s182+  s981 :: SWord8 = s18 & s980+  s982 :: SBool = s17 /= s981+  s983 :: SWord8 = if s982 then s71 else s72+  s984 :: SWord8 = if s22 then s983 else s68+  s985 :: SWord8 = s18 & s984+  s986 :: SBool = s17 /= s985+  s987 :: SBool = s_2 == s986+  s988 :: SBool = s980 < s182+  s989 :: SBool = s980 < s60+  s990 :: SBool = s988 | s989+  s991 :: SWord8 = s980 >>> 1+  s992 :: SWord8 = s24 | s991+  s993 :: SWord8 = s26 & s991+  s994 :: SWord8 = if s990 then s992 else s993+  s995 :: SWord8 = s18 & s994+  s996 :: SBool = s17 /= s995+  s997 :: SWord8 = s984 >>> 1+  s998 :: SWord8 = s24 | s997+  s999 :: SWord8 = s26 & s997+  s1000 :: SWord8 = if s85 then s998 else s999+  s1001 :: SWord8 = if s22 then s1000 else s983+  s1002 :: SWord8 = s1001 >>> 1+  s1003 :: SWord8 = s24 | s1002+  s1004 :: SWord8 = s26 & s1002+  s1005 :: SWord8 = if s996 then s1003 else s1004+  s1006 :: SWord8 = if s22 then s1005 else s1000+  s1007 :: SWord8 = s18 & s1006+  s1008 :: SBool = s17 /= s1007+  s1009 :: SBool = s_2 == s1008+  s1010 :: SWord8 = s994 >>> 1+  s1011 :: SWord8 = s24 | s1010+  s1012 :: SWord8 = s26 & s1010+  s1013 :: SWord8 = if s986 then s1011 else s1012+  s1014 :: SWord8 = s18 & s1013+  s1015 :: SBool = s17 /= s1014+  s1016 :: SWord8 = s18 & s1001+  s1017 :: SBool = s17 /= s1016+  s1018 :: SWord8 = s1006 >>> 1+  s1019 :: SWord8 = s24 | s1018+  s1020 :: SWord8 = s26 & s1018+  s1021 :: SWord8 = if s1017 then s1019 else s1020+  s1022 :: SWord8 = if s22 then s1021 else s1005+  s1023 :: SWord8 = s1022 >>> 1+  s1024 :: SWord8 = s24 | s1023+  s1025 :: SWord8 = s26 & s1023+  s1026 :: SWord8 = if s1015 then s1024 else s1025+  s1027 :: SWord8 = if s22 then s1026 else s1021+  s1028 :: SWord8 = s18 & s1027+  s1029 :: SBool = s17 /= s1028+  s1030 :: SBool = s_2 == s1029+  s1031 :: SWord8 = s1013 >>> 1+  s1032 :: SWord8 = s24 | s1031+  s1033 :: SWord8 = s26 & s1031+  s1034 :: SWord8 = if s1008 then s1032 else s1033+  s1035 :: SWord8 = s18 & s1034+  s1036 :: SBool = s17 /= s1035+  s1037 :: SWord8 = s18 & s1022+  s1038 :: SBool = s17 /= s1037+  s1039 :: SWord8 = s1027 >>> 1+  s1040 :: SWord8 = s24 | s1039+  s1041 :: SWord8 = s26 & s1039+  s1042 :: SWord8 = if s1038 then s1040 else s1041+  s1043 :: SWord8 = if s22 then s1042 else s1026+  s1044 :: SWord8 = s1043 >>> 1+  s1045 :: SWord8 = s24 | s1044+  s1046 :: SWord8 = s26 & s1044+  s1047 :: SWord8 = if s1036 then s1045 else s1046+  s1048 :: SWord8 = if s22 then s1047 else s1042+  s1049 :: SWord8 = s18 & s1048+  s1050 :: SBool = s17 /= s1049+  s1051 :: SBool = s_2 == s1050+  s1052 :: SWord8 = s1034 >>> 1+  s1053 :: SWord8 = s24 | s1052+  s1054 :: SWord8 = s26 & s1052+  s1055 :: SWord8 = if s1029 then s1053 else s1054+  s1056 :: SWord8 = s18 & s1055+  s1057 :: SBool = s17 /= s1056+  s1058 :: SWord8 = s18 & s1043+  s1059 :: SBool = s17 /= s1058+  s1060 :: SWord8 = s1048 >>> 1+  s1061 :: SWord8 = s24 | s1060+  s1062 :: SWord8 = s26 & s1060+  s1063 :: SWord8 = if s1059 then s1061 else s1062+  s1064 :: SWord8 = if s22 then s1063 else s1047+  s1065 :: SWord8 = s1064 >>> 1+  s1066 :: SWord8 = s24 | s1065+  s1067 :: SWord8 = s26 & s1065+  s1068 :: SWord8 = if s1057 then s1066 else s1067+  s1069 :: SWord8 = if s22 then s1068 else s1063+  s1070 :: SWord8 = s18 & s1069+  s1071 :: SBool = s17 /= s1070+  s1072 :: SBool = s_2 == s1071+  s1073 :: SWord8 = s1055 >>> 1+  s1074 :: SWord8 = s24 | s1073+  s1075 :: SWord8 = s26 & s1073+  s1076 :: SWord8 = if s1050 then s1074 else s1075+  s1077 :: SWord8 = s1076 >>> 1+  s1078 :: SWord8 = s24 | s1077+  s1079 :: SWord8 = s26 & s1077+  s1080 :: SWord8 = if s1071 then s1078 else s1079+  s1081 :: SWord8 = s18 & s1064+  s1082 :: SBool = s17 /= s1081+  s1083 :: SWord8 = s1069 >>> 1+  s1084 :: SWord8 = s24 | s1083+  s1085 :: SWord8 = s26 & s1083+  s1086 :: SWord8 = if s1082 then s1084 else s1085+  s1087 :: SWord8 = if s29 then s983 else s182+  s1088 :: SWord8 = if s170 then s1000 else s1087+  s1089 :: SWord8 = if s29 then s1005 else s1088+  s1090 :: SWord8 = if s170 then s1021 else s1089+  s1091 :: SWord8 = if s29 then s1026 else s1090+  s1092 :: SWord8 = if s170 then s1042 else s1091+  s1093 :: SWord8 = if s29 then s1047 else s1092+  s1094 :: SWord8 = if s170 then s1063 else s1093+  s1095 :: SWord8 = if s29 then s1068 else s1094+  s1096 :: SWord8 = if s170 then s1086 else s1095+  s1097 :: SWord8 = s1076 + s1096+  s1098 :: SBool = s1097 < s1096+  s1099 :: SBool = s1097 < s1076+  s1100 :: SBool = s1098 | s1099+  s1101 :: SWord8 = s1097 >>> 1+  s1102 :: SWord8 = s24 | s1101+  s1103 :: SWord8 = s26 & s1101+  s1104 :: SWord8 = if s1100 then s1102 else s1103+  s1105 :: SWord8 = if s1072 then s1080 else s1104+  s1106 :: SWord8 = s1055 + s1094+  s1107 :: SWord8 = s18 & s1106+  s1108 :: SBool = s17 /= s1107+  s1109 :: SWord8 = if s1108 then s1066 else s1067+  s1110 :: SWord8 = if s22 then s1109 else s1063+  s1111 :: SWord8 = s18 & s1110+  s1112 :: SBool = s17 /= s1111+  s1113 :: SBool = s_2 == s1112+  s1114 :: SBool = s1106 < s1094+  s1115 :: SBool = s1106 < s1055+  s1116 :: SBool = s1114 | s1115+  s1117 :: SWord8 = s1106 >>> 1+  s1118 :: SWord8 = s24 | s1117+  s1119 :: SWord8 = s26 & s1117+  s1120 :: SWord8 = if s1116 then s1118 else s1119+  s1121 :: SWord8 = s1120 >>> 1+  s1122 :: SWord8 = s24 | s1121+  s1123 :: SWord8 = s26 & s1121+  s1124 :: SWord8 = if s1112 then s1122 else s1123+  s1125 :: SWord8 = s1110 >>> 1+  s1126 :: SWord8 = s24 | s1125+  s1127 :: SWord8 = s26 & s1125+  s1128 :: SWord8 = if s1082 then s1126 else s1127+  s1129 :: SWord8 = if s29 then s1109 else s1094+  s1130 :: SWord8 = if s170 then s1128 else s1129+  s1131 :: SWord8 = s1120 + s1130+  s1132 :: SBool = s1131 < s1130+  s1133 :: SBool = s1131 < s1120+  s1134 :: SBool = s1132 | s1133+  s1135 :: SWord8 = s1131 >>> 1+  s1136 :: SWord8 = s24 | s1135+  s1137 :: SWord8 = s26 & s1135+  s1138 :: SWord8 = if s1134 then s1136 else s1137+  s1139 :: SWord8 = if s1113 then s1124 else s1138+  s1140 :: SWord8 = if s1051 then s1105 else s1139+  s1141 :: SWord8 = s1034 + s1092+  s1142 :: SWord8 = s18 & s1141+  s1143 :: SBool = s17 /= s1142+  s1144 :: SWord8 = if s1143 then s1045 else s1046+  s1145 :: SWord8 = if s22 then s1144 else s1042+  s1146 :: SWord8 = s18 & s1145+  s1147 :: SBool = s17 /= s1146+  s1148 :: SBool = s_2 == s1147+  s1149 :: SBool = s1141 < s1092+  s1150 :: SBool = s1141 < s1034+  s1151 :: SBool = s1149 | s1150+  s1152 :: SWord8 = s1141 >>> 1+  s1153 :: SWord8 = s24 | s1152+  s1154 :: SWord8 = s26 & s1152+  s1155 :: SWord8 = if s1151 then s1153 else s1154+  s1156 :: SWord8 = s18 & s1155+  s1157 :: SBool = s17 /= s1156+  s1158 :: SWord8 = s1145 >>> 1+  s1159 :: SWord8 = s24 | s1158+  s1160 :: SWord8 = s26 & s1158+  s1161 :: SWord8 = if s1059 then s1159 else s1160+  s1162 :: SWord8 = if s22 then s1161 else s1144+  s1163 :: SWord8 = s1162 >>> 1+  s1164 :: SWord8 = s24 | s1163+  s1165 :: SWord8 = s26 & s1163+  s1166 :: SWord8 = if s1157 then s1164 else s1165+  s1167 :: SWord8 = if s22 then s1166 else s1161+  s1168 :: SWord8 = s18 & s1167+  s1169 :: SBool = s17 /= s1168+  s1170 :: SBool = s_2 == s1169+  s1171 :: SWord8 = s1155 >>> 1+  s1172 :: SWord8 = s24 | s1171+  s1173 :: SWord8 = s26 & s1171+  s1174 :: SWord8 = if s1147 then s1172 else s1173+  s1175 :: SWord8 = s1174 >>> 1+  s1176 :: SWord8 = s24 | s1175+  s1177 :: SWord8 = s26 & s1175+  s1178 :: SWord8 = if s1169 then s1176 else s1177+  s1179 :: SWord8 = s18 & s1162+  s1180 :: SBool = s17 /= s1179+  s1181 :: SWord8 = s1167 >>> 1+  s1182 :: SWord8 = s24 | s1181+  s1183 :: SWord8 = s26 & s1181+  s1184 :: SWord8 = if s1180 then s1182 else s1183+  s1185 :: SWord8 = if s29 then s1144 else s1092+  s1186 :: SWord8 = if s170 then s1161 else s1185+  s1187 :: SWord8 = if s29 then s1166 else s1186+  s1188 :: SWord8 = if s170 then s1184 else s1187+  s1189 :: SWord8 = s1174 + s1188+  s1190 :: SBool = s1189 < s1188+  s1191 :: SBool = s1189 < s1174+  s1192 :: SBool = s1190 | s1191+  s1193 :: SWord8 = s1189 >>> 1+  s1194 :: SWord8 = s24 | s1193+  s1195 :: SWord8 = s26 & s1193+  s1196 :: SWord8 = if s1192 then s1194 else s1195+  s1197 :: SWord8 = if s1170 then s1178 else s1196+  s1198 :: SWord8 = s1155 + s1186+  s1199 :: SWord8 = s18 & s1198+  s1200 :: SBool = s17 /= s1199+  s1201 :: SWord8 = if s1200 then s1164 else s1165+  s1202 :: SWord8 = if s22 then s1201 else s1161+  s1203 :: SWord8 = s18 & s1202+  s1204 :: SBool = s17 /= s1203+  s1205 :: SBool = s_2 == s1204+  s1206 :: SBool = s1198 < s1186+  s1207 :: SBool = s1198 < s1155+  s1208 :: SBool = s1206 | s1207+  s1209 :: SWord8 = s1198 >>> 1+  s1210 :: SWord8 = s24 | s1209+  s1211 :: SWord8 = s26 & s1209+  s1212 :: SWord8 = if s1208 then s1210 else s1211+  s1213 :: SWord8 = s1212 >>> 1+  s1214 :: SWord8 = s24 | s1213+  s1215 :: SWord8 = s26 & s1213+  s1216 :: SWord8 = if s1204 then s1214 else s1215+  s1217 :: SWord8 = s1202 >>> 1+  s1218 :: SWord8 = s24 | s1217+  s1219 :: SWord8 = s26 & s1217+  s1220 :: SWord8 = if s1180 then s1218 else s1219+  s1221 :: SWord8 = if s29 then s1201 else s1186+  s1222 :: SWord8 = if s170 then s1220 else s1221+  s1223 :: SWord8 = s1212 + s1222+  s1224 :: SBool = s1223 < s1222+  s1225 :: SBool = s1223 < s1212+  s1226 :: SBool = s1224 | s1225+  s1227 :: SWord8 = s1223 >>> 1+  s1228 :: SWord8 = s24 | s1227+  s1229 :: SWord8 = s26 & s1227+  s1230 :: SWord8 = if s1226 then s1228 else s1229+  s1231 :: SWord8 = if s1205 then s1216 else s1230+  s1232 :: SWord8 = if s1148 then s1197 else s1231+  s1233 :: SWord8 = if s1030 then s1140 else s1232+  s1234 :: SWord8 = s1013 + s1090+  s1235 :: SWord8 = s18 & s1234+  s1236 :: SBool = s17 /= s1235+  s1237 :: SWord8 = if s1236 then s1024 else s1025+  s1238 :: SWord8 = if s22 then s1237 else s1021+  s1239 :: SWord8 = s18 & s1238+  s1240 :: SBool = s17 /= s1239+  s1241 :: SBool = s_2 == s1240+  s1242 :: SBool = s1234 < s1090+  s1243 :: SBool = s1234 < s1013+  s1244 :: SBool = s1242 | s1243+  s1245 :: SWord8 = s1234 >>> 1+  s1246 :: SWord8 = s24 | s1245+  s1247 :: SWord8 = s26 & s1245+  s1248 :: SWord8 = if s1244 then s1246 else s1247+  s1249 :: SWord8 = s18 & s1248+  s1250 :: SBool = s17 /= s1249+  s1251 :: SWord8 = s1238 >>> 1+  s1252 :: SWord8 = s24 | s1251+  s1253 :: SWord8 = s26 & s1251+  s1254 :: SWord8 = if s1038 then s1252 else s1253+  s1255 :: SWord8 = if s22 then s1254 else s1237+  s1256 :: SWord8 = s1255 >>> 1+  s1257 :: SWord8 = s24 | s1256+  s1258 :: SWord8 = s26 & s1256+  s1259 :: SWord8 = if s1250 then s1257 else s1258+  s1260 :: SWord8 = if s22 then s1259 else s1254+  s1261 :: SWord8 = s18 & s1260+  s1262 :: SBool = s17 /= s1261+  s1263 :: SBool = s_2 == s1262+  s1264 :: SWord8 = s1248 >>> 1+  s1265 :: SWord8 = s24 | s1264+  s1266 :: SWord8 = s26 & s1264+  s1267 :: SWord8 = if s1240 then s1265 else s1266+  s1268 :: SWord8 = s18 & s1267+  s1269 :: SBool = s17 /= s1268+  s1270 :: SWord8 = s18 & s1255+  s1271 :: SBool = s17 /= s1270+  s1272 :: SWord8 = s1260 >>> 1+  s1273 :: SWord8 = s24 | s1272+  s1274 :: SWord8 = s26 & s1272+  s1275 :: SWord8 = if s1271 then s1273 else s1274+  s1276 :: SWord8 = if s22 then s1275 else s1259+  s1277 :: SWord8 = s1276 >>> 1+  s1278 :: SWord8 = s24 | s1277+  s1279 :: SWord8 = s26 & s1277+  s1280 :: SWord8 = if s1269 then s1278 else s1279+  s1281 :: SWord8 = if s22 then s1280 else s1275+  s1282 :: SWord8 = s18 & s1281+  s1283 :: SBool = s17 /= s1282+  s1284 :: SBool = s_2 == s1283+  s1285 :: SWord8 = s1267 >>> 1+  s1286 :: SWord8 = s24 | s1285+  s1287 :: SWord8 = s26 & s1285+  s1288 :: SWord8 = if s1262 then s1286 else s1287+  s1289 :: SWord8 = s1288 >>> 1+  s1290 :: SWord8 = s24 | s1289+  s1291 :: SWord8 = s26 & s1289+  s1292 :: SWord8 = if s1283 then s1290 else s1291+  s1293 :: SWord8 = s18 & s1276+  s1294 :: SBool = s17 /= s1293+  s1295 :: SWord8 = s1281 >>> 1+  s1296 :: SWord8 = s24 | s1295+  s1297 :: SWord8 = s26 & s1295+  s1298 :: SWord8 = if s1294 then s1296 else s1297+  s1299 :: SWord8 = if s29 then s1237 else s1090+  s1300 :: SWord8 = if s170 then s1254 else s1299+  s1301 :: SWord8 = if s29 then s1259 else s1300+  s1302 :: SWord8 = if s170 then s1275 else s1301+  s1303 :: SWord8 = if s29 then s1280 else s1302+  s1304 :: SWord8 = if s170 then s1298 else s1303+  s1305 :: SWord8 = s1288 + s1304+  s1306 :: SBool = s1305 < s1304+  s1307 :: SBool = s1305 < s1288+  s1308 :: SBool = s1306 | s1307+  s1309 :: SWord8 = s1305 >>> 1+  s1310 :: SWord8 = s24 | s1309+  s1311 :: SWord8 = s26 & s1309+  s1312 :: SWord8 = if s1308 then s1310 else s1311+  s1313 :: SWord8 = if s1284 then s1292 else s1312+  s1314 :: SWord8 = s1267 + s1302+  s1315 :: SWord8 = s18 & s1314+  s1316 :: SBool = s17 /= s1315+  s1317 :: SWord8 = if s1316 then s1278 else s1279+  s1318 :: SWord8 = if s22 then s1317 else s1275+  s1319 :: SWord8 = s18 & s1318+  s1320 :: SBool = s17 /= s1319+  s1321 :: SBool = s_2 == s1320+  s1322 :: SBool = s1314 < s1302+  s1323 :: SBool = s1314 < s1267+  s1324 :: SBool = s1322 | s1323+  s1325 :: SWord8 = s1314 >>> 1+  s1326 :: SWord8 = s24 | s1325+  s1327 :: SWord8 = s26 & s1325+  s1328 :: SWord8 = if s1324 then s1326 else s1327+  s1329 :: SWord8 = s1328 >>> 1+  s1330 :: SWord8 = s24 | s1329+  s1331 :: SWord8 = s26 & s1329+  s1332 :: SWord8 = if s1320 then s1330 else s1331+  s1333 :: SWord8 = s1318 >>> 1+  s1334 :: SWord8 = s24 | s1333+  s1335 :: SWord8 = s26 & s1333+  s1336 :: SWord8 = if s1294 then s1334 else s1335+  s1337 :: SWord8 = if s29 then s1317 else s1302+  s1338 :: SWord8 = if s170 then s1336 else s1337+  s1339 :: SWord8 = s1328 + s1338+  s1340 :: SBool = s1339 < s1338+  s1341 :: SBool = s1339 < s1328+  s1342 :: SBool = s1340 | s1341+  s1343 :: SWord8 = s1339 >>> 1+  s1344 :: SWord8 = s24 | s1343+  s1345 :: SWord8 = s26 & s1343+  s1346 :: SWord8 = if s1342 then s1344 else s1345+  s1347 :: SWord8 = if s1321 then s1332 else s1346+  s1348 :: SWord8 = if s1263 then s1313 else s1347+  s1349 :: SWord8 = s1248 + s1300+  s1350 :: SWord8 = s18 & s1349+  s1351 :: SBool = s17 /= s1350+  s1352 :: SWord8 = if s1351 then s1257 else s1258+  s1353 :: SWord8 = if s22 then s1352 else s1254+  s1354 :: SWord8 = s18 & s1353+  s1355 :: SBool = s17 /= s1354+  s1356 :: SBool = s_2 == s1355+  s1357 :: SBool = s1349 < s1300+  s1358 :: SBool = s1349 < s1248+  s1359 :: SBool = s1357 | s1358+  s1360 :: SWord8 = s1349 >>> 1+  s1361 :: SWord8 = s24 | s1360+  s1362 :: SWord8 = s26 & s1360+  s1363 :: SWord8 = if s1359 then s1361 else s1362+  s1364 :: SWord8 = s18 & s1363+  s1365 :: SBool = s17 /= s1364+  s1366 :: SWord8 = s1353 >>> 1+  s1367 :: SWord8 = s24 | s1366+  s1368 :: SWord8 = s26 & s1366+  s1369 :: SWord8 = if s1271 then s1367 else s1368+  s1370 :: SWord8 = if s22 then s1369 else s1352+  s1371 :: SWord8 = s1370 >>> 1+  s1372 :: SWord8 = s24 | s1371+  s1373 :: SWord8 = s26 & s1371+  s1374 :: SWord8 = if s1365 then s1372 else s1373+  s1375 :: SWord8 = if s22 then s1374 else s1369+  s1376 :: SWord8 = s18 & s1375+  s1377 :: SBool = s17 /= s1376+  s1378 :: SBool = s_2 == s1377+  s1379 :: SWord8 = s1363 >>> 1+  s1380 :: SWord8 = s24 | s1379+  s1381 :: SWord8 = s26 & s1379+  s1382 :: SWord8 = if s1355 then s1380 else s1381+  s1383 :: SWord8 = s1382 >>> 1+  s1384 :: SWord8 = s24 | s1383+  s1385 :: SWord8 = s26 & s1383+  s1386 :: SWord8 = if s1377 then s1384 else s1385+  s1387 :: SWord8 = s18 & s1370+  s1388 :: SBool = s17 /= s1387+  s1389 :: SWord8 = s1375 >>> 1+  s1390 :: SWord8 = s24 | s1389+  s1391 :: SWord8 = s26 & s1389+  s1392 :: SWord8 = if s1388 then s1390 else s1391+  s1393 :: SWord8 = if s29 then s1352 else s1300+  s1394 :: SWord8 = if s170 then s1369 else s1393+  s1395 :: SWord8 = if s29 then s1374 else s1394+  s1396 :: SWord8 = if s170 then s1392 else s1395+  s1397 :: SWord8 = s1382 + s1396+  s1398 :: SBool = s1397 < s1396+  s1399 :: SBool = s1397 < s1382+  s1400 :: SBool = s1398 | s1399+  s1401 :: SWord8 = s1397 >>> 1+  s1402 :: SWord8 = s24 | s1401+  s1403 :: SWord8 = s26 & s1401+  s1404 :: SWord8 = if s1400 then s1402 else s1403+  s1405 :: SWord8 = if s1378 then s1386 else s1404+  s1406 :: SWord8 = s1363 + s1394+  s1407 :: SWord8 = s18 & s1406+  s1408 :: SBool = s17 /= s1407+  s1409 :: SWord8 = if s1408 then s1372 else s1373+  s1410 :: SWord8 = if s22 then s1409 else s1369+  s1411 :: SWord8 = s18 & s1410+  s1412 :: SBool = s17 /= s1411+  s1413 :: SBool = s_2 == s1412+  s1414 :: SBool = s1406 < s1394+  s1415 :: SBool = s1406 < s1363+  s1416 :: SBool = s1414 | s1415+  s1417 :: SWord8 = s1406 >>> 1+  s1418 :: SWord8 = s24 | s1417+  s1419 :: SWord8 = s26 & s1417+  s1420 :: SWord8 = if s1416 then s1418 else s1419+  s1421 :: SWord8 = s1420 >>> 1+  s1422 :: SWord8 = s24 | s1421+  s1423 :: SWord8 = s26 & s1421+  s1424 :: SWord8 = if s1412 then s1422 else s1423+  s1425 :: SWord8 = s1410 >>> 1+  s1426 :: SWord8 = s24 | s1425+  s1427 :: SWord8 = s26 & s1425+  s1428 :: SWord8 = if s1388 then s1426 else s1427+  s1429 :: SWord8 = if s29 then s1409 else s1394+  s1430 :: SWord8 = if s170 then s1428 else s1429+  s1431 :: SWord8 = s1420 + s1430+  s1432 :: SBool = s1431 < s1430+  s1433 :: SBool = s1431 < s1420+  s1434 :: SBool = s1432 | s1433+  s1435 :: SWord8 = s1431 >>> 1+  s1436 :: SWord8 = s24 | s1435+  s1437 :: SWord8 = s26 & s1435+  s1438 :: SWord8 = if s1434 then s1436 else s1437+  s1439 :: SWord8 = if s1413 then s1424 else s1438+  s1440 :: SWord8 = if s1356 then s1405 else s1439+  s1441 :: SWord8 = if s1241 then s1348 else s1440+  s1442 :: SWord8 = if s1009 then s1233 else s1441+  s1443 :: SWord8 = s994 + s1088+  s1444 :: SWord8 = s18 & s1443+  s1445 :: SBool = s17 /= s1444+  s1446 :: SWord8 = if s1445 then s1003 else s1004+  s1447 :: SWord8 = if s22 then s1446 else s1000+  s1448 :: SWord8 = s18 & s1447+  s1449 :: SBool = s17 /= s1448+  s1450 :: SBool = s_2 == s1449+  s1451 :: SBool = s1443 < s1088+  s1452 :: SBool = s1443 < s994+  s1453 :: SBool = s1451 | s1452+  s1454 :: SWord8 = s1443 >>> 1+  s1455 :: SWord8 = s24 | s1454+  s1456 :: SWord8 = s26 & s1454+  s1457 :: SWord8 = if s1453 then s1455 else s1456+  s1458 :: SWord8 = s18 & s1457+  s1459 :: SBool = s17 /= s1458+  s1460 :: SWord8 = s1447 >>> 1+  s1461 :: SWord8 = s24 | s1460+  s1462 :: SWord8 = s26 & s1460+  s1463 :: SWord8 = if s1017 then s1461 else s1462+  s1464 :: SWord8 = if s22 then s1463 else s1446+  s1465 :: SWord8 = s1464 >>> 1+  s1466 :: SWord8 = s24 | s1465+  s1467 :: SWord8 = s26 & s1465+  s1468 :: SWord8 = if s1459 then s1466 else s1467+  s1469 :: SWord8 = if s22 then s1468 else s1463+  s1470 :: SWord8 = s18 & s1469+  s1471 :: SBool = s17 /= s1470+  s1472 :: SBool = s_2 == s1471+  s1473 :: SWord8 = s1457 >>> 1+  s1474 :: SWord8 = s24 | s1473+  s1475 :: SWord8 = s26 & s1473+  s1476 :: SWord8 = if s1449 then s1474 else s1475+  s1477 :: SWord8 = s18 & s1476+  s1478 :: SBool = s17 /= s1477+  s1479 :: SWord8 = s18 & s1464+  s1480 :: SBool = s17 /= s1479+  s1481 :: SWord8 = s1469 >>> 1+  s1482 :: SWord8 = s24 | s1481+  s1483 :: SWord8 = s26 & s1481+  s1484 :: SWord8 = if s1480 then s1482 else s1483+  s1485 :: SWord8 = if s22 then s1484 else s1468+  s1486 :: SWord8 = s1485 >>> 1+  s1487 :: SWord8 = s24 | s1486+  s1488 :: SWord8 = s26 & s1486+  s1489 :: SWord8 = if s1478 then s1487 else s1488+  s1490 :: SWord8 = if s22 then s1489 else s1484+  s1491 :: SWord8 = s18 & s1490+  s1492 :: SBool = s17 /= s1491+  s1493 :: SBool = s_2 == s1492+  s1494 :: SWord8 = s1476 >>> 1+  s1495 :: SWord8 = s24 | s1494+  s1496 :: SWord8 = s26 & s1494+  s1497 :: SWord8 = if s1471 then s1495 else s1496+  s1498 :: SWord8 = s18 & s1497+  s1499 :: SBool = s17 /= s1498+  s1500 :: SWord8 = s18 & s1485+  s1501 :: SBool = s17 /= s1500+  s1502 :: SWord8 = s1490 >>> 1+  s1503 :: SWord8 = s24 | s1502+  s1504 :: SWord8 = s26 & s1502+  s1505 :: SWord8 = if s1501 then s1503 else s1504+  s1506 :: SWord8 = if s22 then s1505 else s1489+  s1507 :: SWord8 = s1506 >>> 1+  s1508 :: SWord8 = s24 | s1507+  s1509 :: SWord8 = s26 & s1507+  s1510 :: SWord8 = if s1499 then s1508 else s1509+  s1511 :: SWord8 = if s22 then s1510 else s1505+  s1512 :: SWord8 = s18 & s1511+  s1513 :: SBool = s17 /= s1512+  s1514 :: SBool = s_2 == s1513+  s1515 :: SWord8 = s1497 >>> 1+  s1516 :: SWord8 = s24 | s1515+  s1517 :: SWord8 = s26 & s1515+  s1518 :: SWord8 = if s1492 then s1516 else s1517+  s1519 :: SWord8 = s1518 >>> 1+  s1520 :: SWord8 = s24 | s1519+  s1521 :: SWord8 = s26 & s1519+  s1522 :: SWord8 = if s1513 then s1520 else s1521+  s1523 :: SWord8 = s18 & s1506+  s1524 :: SBool = s17 /= s1523+  s1525 :: SWord8 = s1511 >>> 1+  s1526 :: SWord8 = s24 | s1525+  s1527 :: SWord8 = s26 & s1525+  s1528 :: SWord8 = if s1524 then s1526 else s1527+  s1529 :: SWord8 = if s29 then s1446 else s1088+  s1530 :: SWord8 = if s170 then s1463 else s1529+  s1531 :: SWord8 = if s29 then s1468 else s1530+  s1532 :: SWord8 = if s170 then s1484 else s1531+  s1533 :: SWord8 = if s29 then s1489 else s1532+  s1534 :: SWord8 = if s170 then s1505 else s1533+  s1535 :: SWord8 = if s29 then s1510 else s1534+  s1536 :: SWord8 = if s170 then s1528 else s1535+  s1537 :: SWord8 = s1518 + s1536+  s1538 :: SBool = s1537 < s1536+  s1539 :: SBool = s1537 < s1518+  s1540 :: SBool = s1538 | s1539+  s1541 :: SWord8 = s1537 >>> 1+  s1542 :: SWord8 = s24 | s1541+  s1543 :: SWord8 = s26 & s1541+  s1544 :: SWord8 = if s1540 then s1542 else s1543+  s1545 :: SWord8 = if s1514 then s1522 else s1544+  s1546 :: SWord8 = s1497 + s1534+  s1547 :: SWord8 = s18 & s1546+  s1548 :: SBool = s17 /= s1547+  s1549 :: SWord8 = if s1548 then s1508 else s1509+  s1550 :: SWord8 = if s22 then s1549 else s1505+  s1551 :: SWord8 = s18 & s1550+  s1552 :: SBool = s17 /= s1551+  s1553 :: SBool = s_2 == s1552+  s1554 :: SBool = s1546 < s1534+  s1555 :: SBool = s1546 < s1497+  s1556 :: SBool = s1554 | s1555+  s1557 :: SWord8 = s1546 >>> 1+  s1558 :: SWord8 = s24 | s1557+  s1559 :: SWord8 = s26 & s1557+  s1560 :: SWord8 = if s1556 then s1558 else s1559+  s1561 :: SWord8 = s1560 >>> 1+  s1562 :: SWord8 = s24 | s1561+  s1563 :: SWord8 = s26 & s1561+  s1564 :: SWord8 = if s1552 then s1562 else s1563+  s1565 :: SWord8 = s1550 >>> 1+  s1566 :: SWord8 = s24 | s1565+  s1567 :: SWord8 = s26 & s1565+  s1568 :: SWord8 = if s1524 then s1566 else s1567+  s1569 :: SWord8 = if s29 then s1549 else s1534+  s1570 :: SWord8 = if s170 then s1568 else s1569+  s1571 :: SWord8 = s1560 + s1570+  s1572 :: SBool = s1571 < s1570+  s1573 :: SBool = s1571 < s1560+  s1574 :: SBool = s1572 | s1573+  s1575 :: SWord8 = s1571 >>> 1+  s1576 :: SWord8 = s24 | s1575+  s1577 :: SWord8 = s26 & s1575+  s1578 :: SWord8 = if s1574 then s1576 else s1577+  s1579 :: SWord8 = if s1553 then s1564 else s1578+  s1580 :: SWord8 = if s1493 then s1545 else s1579+  s1581 :: SWord8 = s1476 + s1532+  s1582 :: SWord8 = s18 & s1581+  s1583 :: SBool = s17 /= s1582+  s1584 :: SWord8 = if s1583 then s1487 else s1488+  s1585 :: SWord8 = if s22 then s1584 else s1484+  s1586 :: SWord8 = s18 & s1585+  s1587 :: SBool = s17 /= s1586+  s1588 :: SBool = s_2 == s1587+  s1589 :: SBool = s1581 < s1532+  s1590 :: SBool = s1581 < s1476+  s1591 :: SBool = s1589 | s1590+  s1592 :: SWord8 = s1581 >>> 1+  s1593 :: SWord8 = s24 | s1592+  s1594 :: SWord8 = s26 & s1592+  s1595 :: SWord8 = if s1591 then s1593 else s1594+  s1596 :: SWord8 = s18 & s1595+  s1597 :: SBool = s17 /= s1596+  s1598 :: SWord8 = s1585 >>> 1+  s1599 :: SWord8 = s24 | s1598+  s1600 :: SWord8 = s26 & s1598+  s1601 :: SWord8 = if s1501 then s1599 else s1600+  s1602 :: SWord8 = if s22 then s1601 else s1584+  s1603 :: SWord8 = s1602 >>> 1+  s1604 :: SWord8 = s24 | s1603+  s1605 :: SWord8 = s26 & s1603+  s1606 :: SWord8 = if s1597 then s1604 else s1605+  s1607 :: SWord8 = if s22 then s1606 else s1601+  s1608 :: SWord8 = s18 & s1607+  s1609 :: SBool = s17 /= s1608+  s1610 :: SBool = s_2 == s1609+  s1611 :: SWord8 = s1595 >>> 1+  s1612 :: SWord8 = s24 | s1611+  s1613 :: SWord8 = s26 & s1611+  s1614 :: SWord8 = if s1587 then s1612 else s1613+  s1615 :: SWord8 = s1614 >>> 1+  s1616 :: SWord8 = s24 | s1615+  s1617 :: SWord8 = s26 & s1615+  s1618 :: SWord8 = if s1609 then s1616 else s1617+  s1619 :: SWord8 = s18 & s1602+  s1620 :: SBool = s17 /= s1619+  s1621 :: SWord8 = s1607 >>> 1+  s1622 :: SWord8 = s24 | s1621+  s1623 :: SWord8 = s26 & s1621+  s1624 :: SWord8 = if s1620 then s1622 else s1623+  s1625 :: SWord8 = if s29 then s1584 else s1532+  s1626 :: SWord8 = if s170 then s1601 else s1625+  s1627 :: SWord8 = if s29 then s1606 else s1626+  s1628 :: SWord8 = if s170 then s1624 else s1627+  s1629 :: SWord8 = s1614 + s1628+  s1630 :: SBool = s1629 < s1628+  s1631 :: SBool = s1629 < s1614+  s1632 :: SBool = s1630 | s1631+  s1633 :: SWord8 = s1629 >>> 1+  s1634 :: SWord8 = s24 | s1633+  s1635 :: SWord8 = s26 & s1633+  s1636 :: SWord8 = if s1632 then s1634 else s1635+  s1637 :: SWord8 = if s1610 then s1618 else s1636+  s1638 :: SWord8 = s1595 + s1626+  s1639 :: SWord8 = s18 & s1638+  s1640 :: SBool = s17 /= s1639+  s1641 :: SWord8 = if s1640 then s1604 else s1605+  s1642 :: SWord8 = if s22 then s1641 else s1601+  s1643 :: SWord8 = s18 & s1642+  s1644 :: SBool = s17 /= s1643+  s1645 :: SBool = s_2 == s1644+  s1646 :: SBool = s1638 < s1626+  s1647 :: SBool = s1638 < s1595+  s1648 :: SBool = s1646 | s1647+  s1649 :: SWord8 = s1638 >>> 1+  s1650 :: SWord8 = s24 | s1649+  s1651 :: SWord8 = s26 & s1649+  s1652 :: SWord8 = if s1648 then s1650 else s1651+  s1653 :: SWord8 = s1652 >>> 1+  s1654 :: SWord8 = s24 | s1653+  s1655 :: SWord8 = s26 & s1653+  s1656 :: SWord8 = if s1644 then s1654 else s1655+  s1657 :: SWord8 = s1642 >>> 1+  s1658 :: SWord8 = s24 | s1657+  s1659 :: SWord8 = s26 & s1657+  s1660 :: SWord8 = if s1620 then s1658 else s1659+  s1661 :: SWord8 = if s29 then s1641 else s1626+  s1662 :: SWord8 = if s170 then s1660 else s1661+  s1663 :: SWord8 = s1652 + s1662+  s1664 :: SBool = s1663 < s1662+  s1665 :: SBool = s1663 < s1652+  s1666 :: SBool = s1664 | s1665+  s1667 :: SWord8 = s1663 >>> 1+  s1668 :: SWord8 = s24 | s1667+  s1669 :: SWord8 = s26 & s1667+  s1670 :: SWord8 = if s1666 then s1668 else s1669+  s1671 :: SWord8 = if s1645 then s1656 else s1670+  s1672 :: SWord8 = if s1588 then s1637 else s1671+  s1673 :: SWord8 = if s1472 then s1580 else s1672+  s1674 :: SWord8 = s1457 + s1530+  s1675 :: SWord8 = s18 & s1674+  s1676 :: SBool = s17 /= s1675+  s1677 :: SWord8 = if s1676 then s1466 else s1467+  s1678 :: SWord8 = if s22 then s1677 else s1463+  s1679 :: SWord8 = s18 & s1678+  s1680 :: SBool = s17 /= s1679+  s1681 :: SBool = s_2 == s1680+  s1682 :: SBool = s1674 < s1530+  s1683 :: SBool = s1674 < s1457+  s1684 :: SBool = s1682 | s1683+  s1685 :: SWord8 = s1674 >>> 1+  s1686 :: SWord8 = s24 | s1685+  s1687 :: SWord8 = s26 & s1685+  s1688 :: SWord8 = if s1684 then s1686 else s1687+  s1689 :: SWord8 = s18 & s1688+  s1690 :: SBool = s17 /= s1689+  s1691 :: SWord8 = s1678 >>> 1+  s1692 :: SWord8 = s24 | s1691+  s1693 :: SWord8 = s26 & s1691+  s1694 :: SWord8 = if s1480 then s1692 else s1693+  s1695 :: SWord8 = if s22 then s1694 else s1677+  s1696 :: SWord8 = s1695 >>> 1+  s1697 :: SWord8 = s24 | s1696+  s1698 :: SWord8 = s26 & s1696+  s1699 :: SWord8 = if s1690 then s1697 else s1698+  s1700 :: SWord8 = if s22 then s1699 else s1694+  s1701 :: SWord8 = s18 & s1700+  s1702 :: SBool = s17 /= s1701+  s1703 :: SBool = s_2 == s1702+  s1704 :: SWord8 = s1688 >>> 1+  s1705 :: SWord8 = s24 | s1704+  s1706 :: SWord8 = s26 & s1704+  s1707 :: SWord8 = if s1680 then s1705 else s1706+  s1708 :: SWord8 = s18 & s1707+  s1709 :: SBool = s17 /= s1708+  s1710 :: SWord8 = s18 & s1695+  s1711 :: SBool = s17 /= s1710+  s1712 :: SWord8 = s1700 >>> 1+  s1713 :: SWord8 = s24 | s1712+  s1714 :: SWord8 = s26 & s1712+  s1715 :: SWord8 = if s1711 then s1713 else s1714+  s1716 :: SWord8 = if s22 then s1715 else s1699+  s1717 :: SWord8 = s1716 >>> 1+  s1718 :: SWord8 = s24 | s1717+  s1719 :: SWord8 = s26 & s1717+  s1720 :: SWord8 = if s1709 then s1718 else s1719+  s1721 :: SWord8 = if s22 then s1720 else s1715+  s1722 :: SWord8 = s18 & s1721+  s1723 :: SBool = s17 /= s1722+  s1724 :: SBool = s_2 == s1723+  s1725 :: SWord8 = s1707 >>> 1+  s1726 :: SWord8 = s24 | s1725+  s1727 :: SWord8 = s26 & s1725+  s1728 :: SWord8 = if s1702 then s1726 else s1727+  s1729 :: SWord8 = s1728 >>> 1+  s1730 :: SWord8 = s24 | s1729+  s1731 :: SWord8 = s26 & s1729+  s1732 :: SWord8 = if s1723 then s1730 else s1731+  s1733 :: SWord8 = s18 & s1716+  s1734 :: SBool = s17 /= s1733+  s1735 :: SWord8 = s1721 >>> 1+  s1736 :: SWord8 = s24 | s1735+  s1737 :: SWord8 = s26 & s1735+  s1738 :: SWord8 = if s1734 then s1736 else s1737+  s1739 :: SWord8 = if s29 then s1677 else s1530+  s1740 :: SWord8 = if s170 then s1694 else s1739+  s1741 :: SWord8 = if s29 then s1699 else s1740+  s1742 :: SWord8 = if s170 then s1715 else s1741+  s1743 :: SWord8 = if s29 then s1720 else s1742+  s1744 :: SWord8 = if s170 then s1738 else s1743+  s1745 :: SWord8 = s1728 + s1744+  s1746 :: SBool = s1745 < s1744+  s1747 :: SBool = s1745 < s1728+  s1748 :: SBool = s1746 | s1747+  s1749 :: SWord8 = s1745 >>> 1+  s1750 :: SWord8 = s24 | s1749+  s1751 :: SWord8 = s26 & s1749+  s1752 :: SWord8 = if s1748 then s1750 else s1751+  s1753 :: SWord8 = if s1724 then s1732 else s1752+  s1754 :: SWord8 = s1707 + s1742+  s1755 :: SWord8 = s18 & s1754+  s1756 :: SBool = s17 /= s1755+  s1757 :: SWord8 = if s1756 then s1718 else s1719+  s1758 :: SWord8 = if s22 then s1757 else s1715+  s1759 :: SWord8 = s18 & s1758+  s1760 :: SBool = s17 /= s1759+  s1761 :: SBool = s_2 == s1760+  s1762 :: SBool = s1754 < s1742+  s1763 :: SBool = s1754 < s1707+  s1764 :: SBool = s1762 | s1763+  s1765 :: SWord8 = s1754 >>> 1+  s1766 :: SWord8 = s24 | s1765+  s1767 :: SWord8 = s26 & s1765+  s1768 :: SWord8 = if s1764 then s1766 else s1767+  s1769 :: SWord8 = s1768 >>> 1+  s1770 :: SWord8 = s24 | s1769+  s1771 :: SWord8 = s26 & s1769+  s1772 :: SWord8 = if s1760 then s1770 else s1771+  s1773 :: SWord8 = s1758 >>> 1+  s1774 :: SWord8 = s24 | s1773+  s1775 :: SWord8 = s26 & s1773+  s1776 :: SWord8 = if s1734 then s1774 else s1775+  s1777 :: SWord8 = if s29 then s1757 else s1742+  s1778 :: SWord8 = if s170 then s1776 else s1777+  s1779 :: SWord8 = s1768 + s1778+  s1780 :: SBool = s1779 < s1778+  s1781 :: SBool = s1779 < s1768+  s1782 :: SBool = s1780 | s1781+  s1783 :: SWord8 = s1779 >>> 1+  s1784 :: SWord8 = s24 | s1783+  s1785 :: SWord8 = s26 & s1783+  s1786 :: SWord8 = if s1782 then s1784 else s1785+  s1787 :: SWord8 = if s1761 then s1772 else s1786+  s1788 :: SWord8 = if s1703 then s1753 else s1787+  s1789 :: SWord8 = s1688 + s1740+  s1790 :: SWord8 = s18 & s1789+  s1791 :: SBool = s17 /= s1790+  s1792 :: SWord8 = if s1791 then s1697 else s1698+  s1793 :: SWord8 = if s22 then s1792 else s1694+  s1794 :: SWord8 = s18 & s1793+  s1795 :: SBool = s17 /= s1794+  s1796 :: SBool = s_2 == s1795+  s1797 :: SBool = s1789 < s1740+  s1798 :: SBool = s1789 < s1688+  s1799 :: SBool = s1797 | s1798+  s1800 :: SWord8 = s1789 >>> 1+  s1801 :: SWord8 = s24 | s1800+  s1802 :: SWord8 = s26 & s1800+  s1803 :: SWord8 = if s1799 then s1801 else s1802+  s1804 :: SWord8 = s18 & s1803+  s1805 :: SBool = s17 /= s1804+  s1806 :: SWord8 = s1793 >>> 1+  s1807 :: SWord8 = s24 | s1806+  s1808 :: SWord8 = s26 & s1806+  s1809 :: SWord8 = if s1711 then s1807 else s1808+  s1810 :: SWord8 = if s22 then s1809 else s1792+  s1811 :: SWord8 = s1810 >>> 1+  s1812 :: SWord8 = s24 | s1811+  s1813 :: SWord8 = s26 & s1811+  s1814 :: SWord8 = if s1805 then s1812 else s1813+  s1815 :: SWord8 = if s22 then s1814 else s1809+  s1816 :: SWord8 = s18 & s1815+  s1817 :: SBool = s17 /= s1816+  s1818 :: SBool = s_2 == s1817+  s1819 :: SWord8 = s1803 >>> 1+  s1820 :: SWord8 = s24 | s1819+  s1821 :: SWord8 = s26 & s1819+  s1822 :: SWord8 = if s1795 then s1820 else s1821+  s1823 :: SWord8 = s1822 >>> 1+  s1824 :: SWord8 = s24 | s1823+  s1825 :: SWord8 = s26 & s1823+  s1826 :: SWord8 = if s1817 then s1824 else s1825+  s1827 :: SWord8 = s18 & s1810+  s1828 :: SBool = s17 /= s1827+  s1829 :: SWord8 = s1815 >>> 1+  s1830 :: SWord8 = s24 | s1829+  s1831 :: SWord8 = s26 & s1829+  s1832 :: SWord8 = if s1828 then s1830 else s1831+  s1833 :: SWord8 = if s29 then s1792 else s1740+  s1834 :: SWord8 = if s170 then s1809 else s1833+  s1835 :: SWord8 = if s29 then s1814 else s1834+  s1836 :: SWord8 = if s170 then s1832 else s1835+  s1837 :: SWord8 = s1822 + s1836+  s1838 :: SBool = s1837 < s1836+  s1839 :: SBool = s1837 < s1822+  s1840 :: SBool = s1838 | s1839+  s1841 :: SWord8 = s1837 >>> 1+  s1842 :: SWord8 = s24 | s1841+  s1843 :: SWord8 = s26 & s1841+  s1844 :: SWord8 = if s1840 then s1842 else s1843+  s1845 :: SWord8 = if s1818 then s1826 else s1844+  s1846 :: SWord8 = s1803 + s1834+  s1847 :: SWord8 = s18 & s1846+  s1848 :: SBool = s17 /= s1847+  s1849 :: SWord8 = if s1848 then s1812 else s1813+  s1850 :: SWord8 = if s22 then s1849 else s1809+  s1851 :: SWord8 = s18 & s1850+  s1852 :: SBool = s17 /= s1851+  s1853 :: SBool = s_2 == s1852+  s1854 :: SBool = s1846 < s1834+  s1855 :: SBool = s1846 < s1803+  s1856 :: SBool = s1854 | s1855+  s1857 :: SWord8 = s1846 >>> 1+  s1858 :: SWord8 = s24 | s1857+  s1859 :: SWord8 = s26 & s1857+  s1860 :: SWord8 = if s1856 then s1858 else s1859+  s1861 :: SWord8 = s1860 >>> 1+  s1862 :: SWord8 = s24 | s1861+  s1863 :: SWord8 = s26 & s1861+  s1864 :: SWord8 = if s1852 then s1862 else s1863+  s1865 :: SWord8 = s1850 >>> 1+  s1866 :: SWord8 = s24 | s1865+  s1867 :: SWord8 = s26 & s1865+  s1868 :: SWord8 = if s1828 then s1866 else s1867+  s1869 :: SWord8 = if s29 then s1849 else s1834+  s1870 :: SWord8 = if s170 then s1868 else s1869+  s1871 :: SWord8 = s1860 + s1870+  s1872 :: SBool = s1871 < s1870+  s1873 :: SBool = s1871 < s1860+  s1874 :: SBool = s1872 | s1873+  s1875 :: SWord8 = s1871 >>> 1+  s1876 :: SWord8 = s24 | s1875+  s1877 :: SWord8 = s26 & s1875+  s1878 :: SWord8 = if s1874 then s1876 else s1877+  s1879 :: SWord8 = if s1853 then s1864 else s1878+  s1880 :: SWord8 = if s1796 then s1845 else s1879+  s1881 :: SWord8 = if s1681 then s1788 else s1880+  s1882 :: SWord8 = if s1450 then s1673 else s1881+  s1883 :: SWord8 = if s987 then s1442 else s1882+  s1884 :: SWord8 = if s56 then s979 else s1883+  s1885 :: SWord8 = s39 + s180+  s1886 :: SWord8 = s18 & s1885+  s1887 :: SBool = s17 /= s1886+  s1888 :: SWord8 = if s1887 then s50 else s51+  s1889 :: SWord8 = if s22 then s1888 else s47+  s1890 :: SWord8 = s18 & s1889+  s1891 :: SBool = s17 /= s1890+  s1892 :: SBool = s_2 == s1891+  s1893 :: SBool = s1885 < s180+  s1894 :: SBool = s1885 < s39+  s1895 :: SBool = s1893 | s1894+  s1896 :: SWord8 = s1885 >>> 1+  s1897 :: SWord8 = s24 | s1896+  s1898 :: SWord8 = s26 & s1896+  s1899 :: SWord8 = if s1895 then s1897 else s1898+  s1900 :: SWord8 = s18 & s1899+  s1901 :: SBool = s17 /= s1900+  s1902 :: SWord8 = s1889 >>> 1+  s1903 :: SWord8 = s24 | s1902+  s1904 :: SWord8 = s26 & s1902+  s1905 :: SWord8 = if s64 then s1903 else s1904+  s1906 :: SWord8 = if s22 then s1905 else s1888+  s1907 :: SWord8 = s1906 >>> 1+  s1908 :: SWord8 = s24 | s1907+  s1909 :: SWord8 = s26 & s1907+  s1910 :: SWord8 = if s1901 then s1908 else s1909+  s1911 :: SWord8 = if s22 then s1910 else s1905+  s1912 :: SWord8 = s18 & s1911+  s1913 :: SBool = s17 /= s1912+  s1914 :: SBool = s_2 == s1913+  s1915 :: SWord8 = s1899 >>> 1+  s1916 :: SWord8 = s24 | s1915+  s1917 :: SWord8 = s26 & s1915+  s1918 :: SWord8 = if s1891 then s1916 else s1917+  s1919 :: SWord8 = s18 & s1918+  s1920 :: SBool = s17 /= s1919+  s1921 :: SWord8 = s18 & s1906+  s1922 :: SBool = s17 /= s1921+  s1923 :: SWord8 = s1911 >>> 1+  s1924 :: SWord8 = s24 | s1923+  s1925 :: SWord8 = s26 & s1923+  s1926 :: SWord8 = if s1922 then s1924 else s1925+  s1927 :: SWord8 = if s22 then s1926 else s1910+  s1928 :: SWord8 = s1927 >>> 1+  s1929 :: SWord8 = s24 | s1928+  s1930 :: SWord8 = s26 & s1928+  s1931 :: SWord8 = if s1920 then s1929 else s1930+  s1932 :: SWord8 = if s22 then s1931 else s1926+  s1933 :: SWord8 = s18 & s1932+  s1934 :: SBool = s17 /= s1933+  s1935 :: SBool = s_2 == s1934+  s1936 :: SWord8 = s1918 >>> 1+  s1937 :: SWord8 = s24 | s1936+  s1938 :: SWord8 = s26 & s1936+  s1939 :: SWord8 = if s1913 then s1937 else s1938+  s1940 :: SWord8 = s18 & s1939+  s1941 :: SBool = s17 /= s1940+  s1942 :: SWord8 = s18 & s1927+  s1943 :: SBool = s17 /= s1942+  s1944 :: SWord8 = s1932 >>> 1+  s1945 :: SWord8 = s24 | s1944+  s1946 :: SWord8 = s26 & s1944+  s1947 :: SWord8 = if s1943 then s1945 else s1946+  s1948 :: SWord8 = if s22 then s1947 else s1931+  s1949 :: SWord8 = s1948 >>> 1+  s1950 :: SWord8 = s24 | s1949+  s1951 :: SWord8 = s26 & s1949+  s1952 :: SWord8 = if s1941 then s1950 else s1951+  s1953 :: SWord8 = if s22 then s1952 else s1947+  s1954 :: SWord8 = s18 & s1953+  s1955 :: SBool = s17 /= s1954+  s1956 :: SBool = s_2 == s1955+  s1957 :: SWord8 = s1939 >>> 1+  s1958 :: SWord8 = s24 | s1957+  s1959 :: SWord8 = s26 & s1957+  s1960 :: SWord8 = if s1934 then s1958 else s1959+  s1961 :: SWord8 = s18 & s1960+  s1962 :: SBool = s17 /= s1961+  s1963 :: SWord8 = s18 & s1948+  s1964 :: SBool = s17 /= s1963+  s1965 :: SWord8 = s1953 >>> 1+  s1966 :: SWord8 = s24 | s1965+  s1967 :: SWord8 = s26 & s1965+  s1968 :: SWord8 = if s1964 then s1966 else s1967+  s1969 :: SWord8 = if s22 then s1968 else s1952+  s1970 :: SWord8 = s1969 >>> 1+  s1971 :: SWord8 = s24 | s1970+  s1972 :: SWord8 = s26 & s1970+  s1973 :: SWord8 = if s1962 then s1971 else s1972+  s1974 :: SWord8 = if s22 then s1973 else s1968+  s1975 :: SWord8 = s18 & s1974+  s1976 :: SBool = s17 /= s1975+  s1977 :: SBool = s_2 == s1976+  s1978 :: SWord8 = s1960 >>> 1+  s1979 :: SWord8 = s24 | s1978+  s1980 :: SWord8 = s26 & s1978+  s1981 :: SWord8 = if s1955 then s1979 else s1980+  s1982 :: SWord8 = s18 & s1981+  s1983 :: SBool = s17 /= s1982+  s1984 :: SWord8 = s18 & s1969+  s1985 :: SBool = s17 /= s1984+  s1986 :: SWord8 = s1974 >>> 1+  s1987 :: SWord8 = s24 | s1986+  s1988 :: SWord8 = s26 & s1986+  s1989 :: SWord8 = if s1985 then s1987 else s1988+  s1990 :: SWord8 = if s22 then s1989 else s1973+  s1991 :: SWord8 = s1990 >>> 1+  s1992 :: SWord8 = s24 | s1991+  s1993 :: SWord8 = s26 & s1991+  s1994 :: SWord8 = if s1983 then s1992 else s1993+  s1995 :: SWord8 = if s22 then s1994 else s1989+  s1996 :: SWord8 = s18 & s1995+  s1997 :: SBool = s17 /= s1996+  s1998 :: SBool = s_2 == s1997+  s1999 :: SWord8 = s1981 >>> 1+  s2000 :: SWord8 = s24 | s1999+  s2001 :: SWord8 = s26 & s1999+  s2002 :: SWord8 = if s1976 then s2000 else s2001+  s2003 :: SWord8 = s2002 >>> 1+  s2004 :: SWord8 = s24 | s2003+  s2005 :: SWord8 = s26 & s2003+  s2006 :: SWord8 = if s1997 then s2004 else s2005+  s2007 :: SWord8 = s18 & s1990+  s2008 :: SBool = s17 /= s2007+  s2009 :: SWord8 = s1995 >>> 1+  s2010 :: SWord8 = s24 | s2009+  s2011 :: SWord8 = s26 & s2009+  s2012 :: SWord8 = if s2008 then s2010 else s2011+  s2013 :: SWord8 = if s29 then s1888 else s180+  s2014 :: SWord8 = if s170 then s1905 else s2013+  s2015 :: SWord8 = if s29 then s1910 else s2014+  s2016 :: SWord8 = if s170 then s1926 else s2015+  s2017 :: SWord8 = if s29 then s1931 else s2016+  s2018 :: SWord8 = if s170 then s1947 else s2017+  s2019 :: SWord8 = if s29 then s1952 else s2018+  s2020 :: SWord8 = if s170 then s1968 else s2019+  s2021 :: SWord8 = if s29 then s1973 else s2020+  s2022 :: SWord8 = if s170 then s1989 else s2021+  s2023 :: SWord8 = if s29 then s1994 else s2022+  s2024 :: SWord8 = if s170 then s2012 else s2023+  s2025 :: SWord8 = s2002 + s2024+  s2026 :: SBool = s2025 < s2024+  s2027 :: SBool = s2025 < s2002+  s2028 :: SBool = s2026 | s2027+  s2029 :: SWord8 = s2025 >>> 1+  s2030 :: SWord8 = s24 | s2029+  s2031 :: SWord8 = s26 & s2029+  s2032 :: SWord8 = if s2028 then s2030 else s2031+  s2033 :: SWord8 = if s1998 then s2006 else s2032+  s2034 :: SWord8 = s1981 + s2022+  s2035 :: SWord8 = s18 & s2034+  s2036 :: SBool = s17 /= s2035+  s2037 :: SWord8 = if s2036 then s1992 else s1993+  s2038 :: SWord8 = if s22 then s2037 else s1989+  s2039 :: SWord8 = s18 & s2038+  s2040 :: SBool = s17 /= s2039+  s2041 :: SBool = s_2 == s2040+  s2042 :: SBool = s2034 < s2022+  s2043 :: SBool = s2034 < s1981+  s2044 :: SBool = s2042 | s2043+  s2045 :: SWord8 = s2034 >>> 1+  s2046 :: SWord8 = s24 | s2045+  s2047 :: SWord8 = s26 & s2045+  s2048 :: SWord8 = if s2044 then s2046 else s2047+  s2049 :: SWord8 = s2048 >>> 1+  s2050 :: SWord8 = s24 | s2049+  s2051 :: SWord8 = s26 & s2049+  s2052 :: SWord8 = if s2040 then s2050 else s2051+  s2053 :: SWord8 = s2038 >>> 1+  s2054 :: SWord8 = s24 | s2053+  s2055 :: SWord8 = s26 & s2053+  s2056 :: SWord8 = if s2008 then s2054 else s2055+  s2057 :: SWord8 = if s29 then s2037 else s2022+  s2058 :: SWord8 = if s170 then s2056 else s2057+  s2059 :: SWord8 = s2048 + s2058+  s2060 :: SBool = s2059 < s2058+  s2061 :: SBool = s2059 < s2048+  s2062 :: SBool = s2060 | s2061+  s2063 :: SWord8 = s2059 >>> 1+  s2064 :: SWord8 = s24 | s2063+  s2065 :: SWord8 = s26 & s2063+  s2066 :: SWord8 = if s2062 then s2064 else s2065+  s2067 :: SWord8 = if s2041 then s2052 else s2066+  s2068 :: SWord8 = if s1977 then s2033 else s2067+  s2069 :: SWord8 = s1960 + s2020+  s2070 :: SWord8 = s18 & s2069+  s2071 :: SBool = s17 /= s2070+  s2072 :: SWord8 = if s2071 then s1971 else s1972+  s2073 :: SWord8 = if s22 then s2072 else s1968+  s2074 :: SWord8 = s18 & s2073+  s2075 :: SBool = s17 /= s2074+  s2076 :: SBool = s_2 == s2075+  s2077 :: SBool = s2069 < s2020+  s2078 :: SBool = s2069 < s1960+  s2079 :: SBool = s2077 | s2078+  s2080 :: SWord8 = s2069 >>> 1+  s2081 :: SWord8 = s24 | s2080+  s2082 :: SWord8 = s26 & s2080+  s2083 :: SWord8 = if s2079 then s2081 else s2082+  s2084 :: SWord8 = s18 & s2083+  s2085 :: SBool = s17 /= s2084+  s2086 :: SWord8 = s2073 >>> 1+  s2087 :: SWord8 = s24 | s2086+  s2088 :: SWord8 = s26 & s2086+  s2089 :: SWord8 = if s1985 then s2087 else s2088+  s2090 :: SWord8 = if s22 then s2089 else s2072+  s2091 :: SWord8 = s2090 >>> 1+  s2092 :: SWord8 = s24 | s2091+  s2093 :: SWord8 = s26 & s2091+  s2094 :: SWord8 = if s2085 then s2092 else s2093+  s2095 :: SWord8 = if s22 then s2094 else s2089+  s2096 :: SWord8 = s18 & s2095+  s2097 :: SBool = s17 /= s2096+  s2098 :: SBool = s_2 == s2097+  s2099 :: SWord8 = s2083 >>> 1+  s2100 :: SWord8 = s24 | s2099+  s2101 :: SWord8 = s26 & s2099+  s2102 :: SWord8 = if s2075 then s2100 else s2101+  s2103 :: SWord8 = s2102 >>> 1+  s2104 :: SWord8 = s24 | s2103+  s2105 :: SWord8 = s26 & s2103+  s2106 :: SWord8 = if s2097 then s2104 else s2105+  s2107 :: SWord8 = s18 & s2090+  s2108 :: SBool = s17 /= s2107+  s2109 :: SWord8 = s2095 >>> 1+  s2110 :: SWord8 = s24 | s2109+  s2111 :: SWord8 = s26 & s2109+  s2112 :: SWord8 = if s2108 then s2110 else s2111+  s2113 :: SWord8 = if s29 then s2072 else s2020+  s2114 :: SWord8 = if s170 then s2089 else s2113+  s2115 :: SWord8 = if s29 then s2094 else s2114+  s2116 :: SWord8 = if s170 then s2112 else s2115+  s2117 :: SWord8 = s2102 + s2116+  s2118 :: SBool = s2117 < s2116+  s2119 :: SBool = s2117 < s2102+  s2120 :: SBool = s2118 | s2119+  s2121 :: SWord8 = s2117 >>> 1+  s2122 :: SWord8 = s24 | s2121+  s2123 :: SWord8 = s26 & s2121+  s2124 :: SWord8 = if s2120 then s2122 else s2123+  s2125 :: SWord8 = if s2098 then s2106 else s2124+  s2126 :: SWord8 = s2083 + s2114+  s2127 :: SWord8 = s18 & s2126+  s2128 :: SBool = s17 /= s2127+  s2129 :: SWord8 = if s2128 then s2092 else s2093+  s2130 :: SWord8 = if s22 then s2129 else s2089+  s2131 :: SWord8 = s18 & s2130+  s2132 :: SBool = s17 /= s2131+  s2133 :: SBool = s_2 == s2132+  s2134 :: SBool = s2126 < s2114+  s2135 :: SBool = s2126 < s2083+  s2136 :: SBool = s2134 | s2135+  s2137 :: SWord8 = s2126 >>> 1+  s2138 :: SWord8 = s24 | s2137+  s2139 :: SWord8 = s26 & s2137+  s2140 :: SWord8 = if s2136 then s2138 else s2139+  s2141 :: SWord8 = s2140 >>> 1+  s2142 :: SWord8 = s24 | s2141+  s2143 :: SWord8 = s26 & s2141+  s2144 :: SWord8 = if s2132 then s2142 else s2143+  s2145 :: SWord8 = s2130 >>> 1+  s2146 :: SWord8 = s24 | s2145+  s2147 :: SWord8 = s26 & s2145+  s2148 :: SWord8 = if s2108 then s2146 else s2147+  s2149 :: SWord8 = if s29 then s2129 else s2114+  s2150 :: SWord8 = if s170 then s2148 else s2149+  s2151 :: SWord8 = s2140 + s2150+  s2152 :: SBool = s2151 < s2150+  s2153 :: SBool = s2151 < s2140+  s2154 :: SBool = s2152 | s2153+  s2155 :: SWord8 = s2151 >>> 1+  s2156 :: SWord8 = s24 | s2155+  s2157 :: SWord8 = s26 & s2155+  s2158 :: SWord8 = if s2154 then s2156 else s2157+  s2159 :: SWord8 = if s2133 then s2144 else s2158+  s2160 :: SWord8 = if s2076 then s2125 else s2159+  s2161 :: SWord8 = if s1956 then s2068 else s2160+  s2162 :: SWord8 = s1939 + s2018+  s2163 :: SWord8 = s18 & s2162+  s2164 :: SBool = s17 /= s2163+  s2165 :: SWord8 = if s2164 then s1950 else s1951+  s2166 :: SWord8 = if s22 then s2165 else s1947+  s2167 :: SWord8 = s18 & s2166+  s2168 :: SBool = s17 /= s2167+  s2169 :: SBool = s_2 == s2168+  s2170 :: SBool = s2162 < s2018+  s2171 :: SBool = s2162 < s1939+  s2172 :: SBool = s2170 | s2171+  s2173 :: SWord8 = s2162 >>> 1+  s2174 :: SWord8 = s24 | s2173+  s2175 :: SWord8 = s26 & s2173+  s2176 :: SWord8 = if s2172 then s2174 else s2175+  s2177 :: SWord8 = s18 & s2176+  s2178 :: SBool = s17 /= s2177+  s2179 :: SWord8 = s2166 >>> 1+  s2180 :: SWord8 = s24 | s2179+  s2181 :: SWord8 = s26 & s2179+  s2182 :: SWord8 = if s1964 then s2180 else s2181+  s2183 :: SWord8 = if s22 then s2182 else s2165+  s2184 :: SWord8 = s2183 >>> 1+  s2185 :: SWord8 = s24 | s2184+  s2186 :: SWord8 = s26 & s2184+  s2187 :: SWord8 = if s2178 then s2185 else s2186+  s2188 :: SWord8 = if s22 then s2187 else s2182+  s2189 :: SWord8 = s18 & s2188+  s2190 :: SBool = s17 /= s2189+  s2191 :: SBool = s_2 == s2190+  s2192 :: SWord8 = s2176 >>> 1+  s2193 :: SWord8 = s24 | s2192+  s2194 :: SWord8 = s26 & s2192+  s2195 :: SWord8 = if s2168 then s2193 else s2194+  s2196 :: SWord8 = s18 & s2195+  s2197 :: SBool = s17 /= s2196+  s2198 :: SWord8 = s18 & s2183+  s2199 :: SBool = s17 /= s2198+  s2200 :: SWord8 = s2188 >>> 1+  s2201 :: SWord8 = s24 | s2200+  s2202 :: SWord8 = s26 & s2200+  s2203 :: SWord8 = if s2199 then s2201 else s2202+  s2204 :: SWord8 = if s22 then s2203 else s2187+  s2205 :: SWord8 = s2204 >>> 1+  s2206 :: SWord8 = s24 | s2205+  s2207 :: SWord8 = s26 & s2205+  s2208 :: SWord8 = if s2197 then s2206 else s2207+  s2209 :: SWord8 = if s22 then s2208 else s2203+  s2210 :: SWord8 = s18 & s2209+  s2211 :: SBool = s17 /= s2210+  s2212 :: SBool = s_2 == s2211+  s2213 :: SWord8 = s2195 >>> 1+  s2214 :: SWord8 = s24 | s2213+  s2215 :: SWord8 = s26 & s2213+  s2216 :: SWord8 = if s2190 then s2214 else s2215+  s2217 :: SWord8 = s2216 >>> 1+  s2218 :: SWord8 = s24 | s2217+  s2219 :: SWord8 = s26 & s2217+  s2220 :: SWord8 = if s2211 then s2218 else s2219+  s2221 :: SWord8 = s18 & s2204+  s2222 :: SBool = s17 /= s2221+  s2223 :: SWord8 = s2209 >>> 1+  s2224 :: SWord8 = s24 | s2223+  s2225 :: SWord8 = s26 & s2223+  s2226 :: SWord8 = if s2222 then s2224 else s2225+  s2227 :: SWord8 = if s29 then s2165 else s2018+  s2228 :: SWord8 = if s170 then s2182 else s2227+  s2229 :: SWord8 = if s29 then s2187 else s2228+  s2230 :: SWord8 = if s170 then s2203 else s2229+  s2231 :: SWord8 = if s29 then s2208 else s2230+  s2232 :: SWord8 = if s170 then s2226 else s2231+  s2233 :: SWord8 = s2216 + s2232+  s2234 :: SBool = s2233 < s2232+  s2235 :: SBool = s2233 < s2216+  s2236 :: SBool = s2234 | s2235+  s2237 :: SWord8 = s2233 >>> 1+  s2238 :: SWord8 = s24 | s2237+  s2239 :: SWord8 = s26 & s2237+  s2240 :: SWord8 = if s2236 then s2238 else s2239+  s2241 :: SWord8 = if s2212 then s2220 else s2240+  s2242 :: SWord8 = s2195 + s2230+  s2243 :: SWord8 = s18 & s2242+  s2244 :: SBool = s17 /= s2243+  s2245 :: SWord8 = if s2244 then s2206 else s2207+  s2246 :: SWord8 = if s22 then s2245 else s2203+  s2247 :: SWord8 = s18 & s2246+  s2248 :: SBool = s17 /= s2247+  s2249 :: SBool = s_2 == s2248+  s2250 :: SBool = s2242 < s2230+  s2251 :: SBool = s2242 < s2195+  s2252 :: SBool = s2250 | s2251+  s2253 :: SWord8 = s2242 >>> 1+  s2254 :: SWord8 = s24 | s2253+  s2255 :: SWord8 = s26 & s2253+  s2256 :: SWord8 = if s2252 then s2254 else s2255+  s2257 :: SWord8 = s2256 >>> 1+  s2258 :: SWord8 = s24 | s2257+  s2259 :: SWord8 = s26 & s2257+  s2260 :: SWord8 = if s2248 then s2258 else s2259+  s2261 :: SWord8 = s2246 >>> 1+  s2262 :: SWord8 = s24 | s2261+  s2263 :: SWord8 = s26 & s2261+  s2264 :: SWord8 = if s2222 then s2262 else s2263+  s2265 :: SWord8 = if s29 then s2245 else s2230+  s2266 :: SWord8 = if s170 then s2264 else s2265+  s2267 :: SWord8 = s2256 + s2266+  s2268 :: SBool = s2267 < s2266+  s2269 :: SBool = s2267 < s2256+  s2270 :: SBool = s2268 | s2269+  s2271 :: SWord8 = s2267 >>> 1+  s2272 :: SWord8 = s24 | s2271+  s2273 :: SWord8 = s26 & s2271+  s2274 :: SWord8 = if s2270 then s2272 else s2273+  s2275 :: SWord8 = if s2249 then s2260 else s2274+  s2276 :: SWord8 = if s2191 then s2241 else s2275+  s2277 :: SWord8 = s2176 + s2228+  s2278 :: SWord8 = s18 & s2277+  s2279 :: SBool = s17 /= s2278+  s2280 :: SWord8 = if s2279 then s2185 else s2186+  s2281 :: SWord8 = if s22 then s2280 else s2182+  s2282 :: SWord8 = s18 & s2281+  s2283 :: SBool = s17 /= s2282+  s2284 :: SBool = s_2 == s2283+  s2285 :: SBool = s2277 < s2228+  s2286 :: SBool = s2277 < s2176+  s2287 :: SBool = s2285 | s2286+  s2288 :: SWord8 = s2277 >>> 1+  s2289 :: SWord8 = s24 | s2288+  s2290 :: SWord8 = s26 & s2288+  s2291 :: SWord8 = if s2287 then s2289 else s2290+  s2292 :: SWord8 = s18 & s2291+  s2293 :: SBool = s17 /= s2292+  s2294 :: SWord8 = s2281 >>> 1+  s2295 :: SWord8 = s24 | s2294+  s2296 :: SWord8 = s26 & s2294+  s2297 :: SWord8 = if s2199 then s2295 else s2296+  s2298 :: SWord8 = if s22 then s2297 else s2280+  s2299 :: SWord8 = s2298 >>> 1+  s2300 :: SWord8 = s24 | s2299+  s2301 :: SWord8 = s26 & s2299+  s2302 :: SWord8 = if s2293 then s2300 else s2301+  s2303 :: SWord8 = if s22 then s2302 else s2297+  s2304 :: SWord8 = s18 & s2303+  s2305 :: SBool = s17 /= s2304+  s2306 :: SBool = s_2 == s2305+  s2307 :: SWord8 = s2291 >>> 1+  s2308 :: SWord8 = s24 | s2307+  s2309 :: SWord8 = s26 & s2307+  s2310 :: SWord8 = if s2283 then s2308 else s2309+  s2311 :: SWord8 = s2310 >>> 1+  s2312 :: SWord8 = s24 | s2311+  s2313 :: SWord8 = s26 & s2311+  s2314 :: SWord8 = if s2305 then s2312 else s2313+  s2315 :: SWord8 = s18 & s2298+  s2316 :: SBool = s17 /= s2315+  s2317 :: SWord8 = s2303 >>> 1+  s2318 :: SWord8 = s24 | s2317+  s2319 :: SWord8 = s26 & s2317+  s2320 :: SWord8 = if s2316 then s2318 else s2319+  s2321 :: SWord8 = if s29 then s2280 else s2228+  s2322 :: SWord8 = if s170 then s2297 else s2321+  s2323 :: SWord8 = if s29 then s2302 else s2322+  s2324 :: SWord8 = if s170 then s2320 else s2323+  s2325 :: SWord8 = s2310 + s2324+  s2326 :: SBool = s2325 < s2324+  s2327 :: SBool = s2325 < s2310+  s2328 :: SBool = s2326 | s2327+  s2329 :: SWord8 = s2325 >>> 1+  s2330 :: SWord8 = s24 | s2329+  s2331 :: SWord8 = s26 & s2329+  s2332 :: SWord8 = if s2328 then s2330 else s2331+  s2333 :: SWord8 = if s2306 then s2314 else s2332+  s2334 :: SWord8 = s2291 + s2322+  s2335 :: SWord8 = s18 & s2334+  s2336 :: SBool = s17 /= s2335+  s2337 :: SWord8 = if s2336 then s2300 else s2301+  s2338 :: SWord8 = if s22 then s2337 else s2297+  s2339 :: SWord8 = s18 & s2338+  s2340 :: SBool = s17 /= s2339+  s2341 :: SBool = s_2 == s2340+  s2342 :: SBool = s2334 < s2322+  s2343 :: SBool = s2334 < s2291+  s2344 :: SBool = s2342 | s2343+  s2345 :: SWord8 = s2334 >>> 1+  s2346 :: SWord8 = s24 | s2345+  s2347 :: SWord8 = s26 & s2345+  s2348 :: SWord8 = if s2344 then s2346 else s2347+  s2349 :: SWord8 = s2348 >>> 1+  s2350 :: SWord8 = s24 | s2349+  s2351 :: SWord8 = s26 & s2349+  s2352 :: SWord8 = if s2340 then s2350 else s2351+  s2353 :: SWord8 = s2338 >>> 1+  s2354 :: SWord8 = s24 | s2353+  s2355 :: SWord8 = s26 & s2353+  s2356 :: SWord8 = if s2316 then s2354 else s2355+  s2357 :: SWord8 = if s29 then s2337 else s2322+  s2358 :: SWord8 = if s170 then s2356 else s2357+  s2359 :: SWord8 = s2348 + s2358+  s2360 :: SBool = s2359 < s2358+  s2361 :: SBool = s2359 < s2348+  s2362 :: SBool = s2360 | s2361+  s2363 :: SWord8 = s2359 >>> 1+  s2364 :: SWord8 = s24 | s2363+  s2365 :: SWord8 = s26 & s2363+  s2366 :: SWord8 = if s2362 then s2364 else s2365+  s2367 :: SWord8 = if s2341 then s2352 else s2366+  s2368 :: SWord8 = if s2284 then s2333 else s2367+  s2369 :: SWord8 = if s2169 then s2276 else s2368+  s2370 :: SWord8 = if s1935 then s2161 else s2369+  s2371 :: SWord8 = s1918 + s2016+  s2372 :: SWord8 = s18 & s2371+  s2373 :: SBool = s17 /= s2372+  s2374 :: SWord8 = if s2373 then s1929 else s1930+  s2375 :: SWord8 = if s22 then s2374 else s1926+  s2376 :: SWord8 = s18 & s2375+  s2377 :: SBool = s17 /= s2376+  s2378 :: SBool = s_2 == s2377+  s2379 :: SBool = s2371 < s2016+  s2380 :: SBool = s2371 < s1918+  s2381 :: SBool = s2379 | s2380+  s2382 :: SWord8 = s2371 >>> 1+  s2383 :: SWord8 = s24 | s2382+  s2384 :: SWord8 = s26 & s2382+  s2385 :: SWord8 = if s2381 then s2383 else s2384+  s2386 :: SWord8 = s18 & s2385+  s2387 :: SBool = s17 /= s2386+  s2388 :: SWord8 = s2375 >>> 1+  s2389 :: SWord8 = s24 | s2388+  s2390 :: SWord8 = s26 & s2388+  s2391 :: SWord8 = if s1943 then s2389 else s2390+  s2392 :: SWord8 = if s22 then s2391 else s2374+  s2393 :: SWord8 = s2392 >>> 1+  s2394 :: SWord8 = s24 | s2393+  s2395 :: SWord8 = s26 & s2393+  s2396 :: SWord8 = if s2387 then s2394 else s2395+  s2397 :: SWord8 = if s22 then s2396 else s2391+  s2398 :: SWord8 = s18 & s2397+  s2399 :: SBool = s17 /= s2398+  s2400 :: SBool = s_2 == s2399+  s2401 :: SWord8 = s2385 >>> 1+  s2402 :: SWord8 = s24 | s2401+  s2403 :: SWord8 = s26 & s2401+  s2404 :: SWord8 = if s2377 then s2402 else s2403+  s2405 :: SWord8 = s18 & s2404+  s2406 :: SBool = s17 /= s2405+  s2407 :: SWord8 = s18 & s2392+  s2408 :: SBool = s17 /= s2407+  s2409 :: SWord8 = s2397 >>> 1+  s2410 :: SWord8 = s24 | s2409+  s2411 :: SWord8 = s26 & s2409+  s2412 :: SWord8 = if s2408 then s2410 else s2411+  s2413 :: SWord8 = if s22 then s2412 else s2396+  s2414 :: SWord8 = s2413 >>> 1+  s2415 :: SWord8 = s24 | s2414+  s2416 :: SWord8 = s26 & s2414+  s2417 :: SWord8 = if s2406 then s2415 else s2416+  s2418 :: SWord8 = if s22 then s2417 else s2412+  s2419 :: SWord8 = s18 & s2418+  s2420 :: SBool = s17 /= s2419+  s2421 :: SBool = s_2 == s2420+  s2422 :: SWord8 = s2404 >>> 1+  s2423 :: SWord8 = s24 | s2422+  s2424 :: SWord8 = s26 & s2422+  s2425 :: SWord8 = if s2399 then s2423 else s2424+  s2426 :: SWord8 = s18 & s2425+  s2427 :: SBool = s17 /= s2426+  s2428 :: SWord8 = s18 & s2413+  s2429 :: SBool = s17 /= s2428+  s2430 :: SWord8 = s2418 >>> 1+  s2431 :: SWord8 = s24 | s2430+  s2432 :: SWord8 = s26 & s2430+  s2433 :: SWord8 = if s2429 then s2431 else s2432+  s2434 :: SWord8 = if s22 then s2433 else s2417+  s2435 :: SWord8 = s2434 >>> 1+  s2436 :: SWord8 = s24 | s2435+  s2437 :: SWord8 = s26 & s2435+  s2438 :: SWord8 = if s2427 then s2436 else s2437+  s2439 :: SWord8 = if s22 then s2438 else s2433+  s2440 :: SWord8 = s18 & s2439+  s2441 :: SBool = s17 /= s2440+  s2442 :: SBool = s_2 == s2441+  s2443 :: SWord8 = s2425 >>> 1+  s2444 :: SWord8 = s24 | s2443+  s2445 :: SWord8 = s26 & s2443+  s2446 :: SWord8 = if s2420 then s2444 else s2445+  s2447 :: SWord8 = s2446 >>> 1+  s2448 :: SWord8 = s24 | s2447+  s2449 :: SWord8 = s26 & s2447+  s2450 :: SWord8 = if s2441 then s2448 else s2449+  s2451 :: SWord8 = s18 & s2434+  s2452 :: SBool = s17 /= s2451+  s2453 :: SWord8 = s2439 >>> 1+  s2454 :: SWord8 = s24 | s2453+  s2455 :: SWord8 = s26 & s2453+  s2456 :: SWord8 = if s2452 then s2454 else s2455+  s2457 :: SWord8 = if s29 then s2374 else s2016+  s2458 :: SWord8 = if s170 then s2391 else s2457+  s2459 :: SWord8 = if s29 then s2396 else s2458+  s2460 :: SWord8 = if s170 then s2412 else s2459+  s2461 :: SWord8 = if s29 then s2417 else s2460+  s2462 :: SWord8 = if s170 then s2433 else s2461+  s2463 :: SWord8 = if s29 then s2438 else s2462+  s2464 :: SWord8 = if s170 then s2456 else s2463+  s2465 :: SWord8 = s2446 + s2464+  s2466 :: SBool = s2465 < s2464+  s2467 :: SBool = s2465 < s2446+  s2468 :: SBool = s2466 | s2467+  s2469 :: SWord8 = s2465 >>> 1+  s2470 :: SWord8 = s24 | s2469+  s2471 :: SWord8 = s26 & s2469+  s2472 :: SWord8 = if s2468 then s2470 else s2471+  s2473 :: SWord8 = if s2442 then s2450 else s2472+  s2474 :: SWord8 = s2425 + s2462+  s2475 :: SWord8 = s18 & s2474+  s2476 :: SBool = s17 /= s2475+  s2477 :: SWord8 = if s2476 then s2436 else s2437+  s2478 :: SWord8 = if s22 then s2477 else s2433+  s2479 :: SWord8 = s18 & s2478+  s2480 :: SBool = s17 /= s2479+  s2481 :: SBool = s_2 == s2480+  s2482 :: SBool = s2474 < s2462+  s2483 :: SBool = s2474 < s2425+  s2484 :: SBool = s2482 | s2483+  s2485 :: SWord8 = s2474 >>> 1+  s2486 :: SWord8 = s24 | s2485+  s2487 :: SWord8 = s26 & s2485+  s2488 :: SWord8 = if s2484 then s2486 else s2487+  s2489 :: SWord8 = s2488 >>> 1+  s2490 :: SWord8 = s24 | s2489+  s2491 :: SWord8 = s26 & s2489+  s2492 :: SWord8 = if s2480 then s2490 else s2491+  s2493 :: SWord8 = s2478 >>> 1+  s2494 :: SWord8 = s24 | s2493+  s2495 :: SWord8 = s26 & s2493+  s2496 :: SWord8 = if s2452 then s2494 else s2495+  s2497 :: SWord8 = if s29 then s2477 else s2462+  s2498 :: SWord8 = if s170 then s2496 else s2497+  s2499 :: SWord8 = s2488 + s2498+  s2500 :: SBool = s2499 < s2498+  s2501 :: SBool = s2499 < s2488+  s2502 :: SBool = s2500 | s2501+  s2503 :: SWord8 = s2499 >>> 1+  s2504 :: SWord8 = s24 | s2503+  s2505 :: SWord8 = s26 & s2503+  s2506 :: SWord8 = if s2502 then s2504 else s2505+  s2507 :: SWord8 = if s2481 then s2492 else s2506+  s2508 :: SWord8 = if s2421 then s2473 else s2507+  s2509 :: SWord8 = s2404 + s2460+  s2510 :: SWord8 = s18 & s2509+  s2511 :: SBool = s17 /= s2510+  s2512 :: SWord8 = if s2511 then s2415 else s2416+  s2513 :: SWord8 = if s22 then s2512 else s2412+  s2514 :: SWord8 = s18 & s2513+  s2515 :: SBool = s17 /= s2514+  s2516 :: SBool = s_2 == s2515+  s2517 :: SBool = s2509 < s2460+  s2518 :: SBool = s2509 < s2404+  s2519 :: SBool = s2517 | s2518+  s2520 :: SWord8 = s2509 >>> 1+  s2521 :: SWord8 = s24 | s2520+  s2522 :: SWord8 = s26 & s2520+  s2523 :: SWord8 = if s2519 then s2521 else s2522+  s2524 :: SWord8 = s18 & s2523+  s2525 :: SBool = s17 /= s2524+  s2526 :: SWord8 = s2513 >>> 1+  s2527 :: SWord8 = s24 | s2526+  s2528 :: SWord8 = s26 & s2526+  s2529 :: SWord8 = if s2429 then s2527 else s2528+  s2530 :: SWord8 = if s22 then s2529 else s2512+  s2531 :: SWord8 = s2530 >>> 1+  s2532 :: SWord8 = s24 | s2531+  s2533 :: SWord8 = s26 & s2531+  s2534 :: SWord8 = if s2525 then s2532 else s2533+  s2535 :: SWord8 = if s22 then s2534 else s2529+  s2536 :: SWord8 = s18 & s2535+  s2537 :: SBool = s17 /= s2536+  s2538 :: SBool = s_2 == s2537+  s2539 :: SWord8 = s2523 >>> 1+  s2540 :: SWord8 = s24 | s2539+  s2541 :: SWord8 = s26 & s2539+  s2542 :: SWord8 = if s2515 then s2540 else s2541+  s2543 :: SWord8 = s2542 >>> 1+  s2544 :: SWord8 = s24 | s2543+  s2545 :: SWord8 = s26 & s2543+  s2546 :: SWord8 = if s2537 then s2544 else s2545+  s2547 :: SWord8 = s18 & s2530+  s2548 :: SBool = s17 /= s2547+  s2549 :: SWord8 = s2535 >>> 1+  s2550 :: SWord8 = s24 | s2549+  s2551 :: SWord8 = s26 & s2549+  s2552 :: SWord8 = if s2548 then s2550 else s2551+  s2553 :: SWord8 = if s29 then s2512 else s2460+  s2554 :: SWord8 = if s170 then s2529 else s2553+  s2555 :: SWord8 = if s29 then s2534 else s2554+  s2556 :: SWord8 = if s170 then s2552 else s2555+  s2557 :: SWord8 = s2542 + s2556+  s2558 :: SBool = s2557 < s2556+  s2559 :: SBool = s2557 < s2542+  s2560 :: SBool = s2558 | s2559+  s2561 :: SWord8 = s2557 >>> 1+  s2562 :: SWord8 = s24 | s2561+  s2563 :: SWord8 = s26 & s2561+  s2564 :: SWord8 = if s2560 then s2562 else s2563+  s2565 :: SWord8 = if s2538 then s2546 else s2564+  s2566 :: SWord8 = s2523 + s2554+  s2567 :: SWord8 = s18 & s2566+  s2568 :: SBool = s17 /= s2567+  s2569 :: SWord8 = if s2568 then s2532 else s2533+  s2570 :: SWord8 = if s22 then s2569 else s2529+  s2571 :: SWord8 = s18 & s2570+  s2572 :: SBool = s17 /= s2571+  s2573 :: SBool = s_2 == s2572+  s2574 :: SBool = s2566 < s2554+  s2575 :: SBool = s2566 < s2523+  s2576 :: SBool = s2574 | s2575+  s2577 :: SWord8 = s2566 >>> 1+  s2578 :: SWord8 = s24 | s2577+  s2579 :: SWord8 = s26 & s2577+  s2580 :: SWord8 = if s2576 then s2578 else s2579+  s2581 :: SWord8 = s2580 >>> 1+  s2582 :: SWord8 = s24 | s2581+  s2583 :: SWord8 = s26 & s2581+  s2584 :: SWord8 = if s2572 then s2582 else s2583+  s2585 :: SWord8 = s2570 >>> 1+  s2586 :: SWord8 = s24 | s2585+  s2587 :: SWord8 = s26 & s2585+  s2588 :: SWord8 = if s2548 then s2586 else s2587+  s2589 :: SWord8 = if s29 then s2569 else s2554+  s2590 :: SWord8 = if s170 then s2588 else s2589+  s2591 :: SWord8 = s2580 + s2590+  s2592 :: SBool = s2591 < s2590+  s2593 :: SBool = s2591 < s2580+  s2594 :: SBool = s2592 | s2593+  s2595 :: SWord8 = s2591 >>> 1+  s2596 :: SWord8 = s24 | s2595+  s2597 :: SWord8 = s26 & s2595+  s2598 :: SWord8 = if s2594 then s2596 else s2597+  s2599 :: SWord8 = if s2573 then s2584 else s2598+  s2600 :: SWord8 = if s2516 then s2565 else s2599+  s2601 :: SWord8 = if s2400 then s2508 else s2600+  s2602 :: SWord8 = s2385 + s2458+  s2603 :: SWord8 = s18 & s2602+  s2604 :: SBool = s17 /= s2603+  s2605 :: SWord8 = if s2604 then s2394 else s2395+  s2606 :: SWord8 = if s22 then s2605 else s2391+  s2607 :: SWord8 = s18 & s2606+  s2608 :: SBool = s17 /= s2607+  s2609 :: SBool = s_2 == s2608+  s2610 :: SBool = s2602 < s2458+  s2611 :: SBool = s2602 < s2385+  s2612 :: SBool = s2610 | s2611+  s2613 :: SWord8 = s2602 >>> 1+  s2614 :: SWord8 = s24 | s2613+  s2615 :: SWord8 = s26 & s2613+  s2616 :: SWord8 = if s2612 then s2614 else s2615+  s2617 :: SWord8 = s18 & s2616+  s2618 :: SBool = s17 /= s2617+  s2619 :: SWord8 = s2606 >>> 1+  s2620 :: SWord8 = s24 | s2619+  s2621 :: SWord8 = s26 & s2619+  s2622 :: SWord8 = if s2408 then s2620 else s2621+  s2623 :: SWord8 = if s22 then s2622 else s2605+  s2624 :: SWord8 = s2623 >>> 1+  s2625 :: SWord8 = s24 | s2624+  s2626 :: SWord8 = s26 & s2624+  s2627 :: SWord8 = if s2618 then s2625 else s2626+  s2628 :: SWord8 = if s22 then s2627 else s2622+  s2629 :: SWord8 = s18 & s2628+  s2630 :: SBool = s17 /= s2629+  s2631 :: SBool = s_2 == s2630+  s2632 :: SWord8 = s2616 >>> 1+  s2633 :: SWord8 = s24 | s2632+  s2634 :: SWord8 = s26 & s2632+  s2635 :: SWord8 = if s2608 then s2633 else s2634+  s2636 :: SWord8 = s18 & s2635+  s2637 :: SBool = s17 /= s2636+  s2638 :: SWord8 = s18 & s2623+  s2639 :: SBool = s17 /= s2638+  s2640 :: SWord8 = s2628 >>> 1+  s2641 :: SWord8 = s24 | s2640+  s2642 :: SWord8 = s26 & s2640+  s2643 :: SWord8 = if s2639 then s2641 else s2642+  s2644 :: SWord8 = if s22 then s2643 else s2627+  s2645 :: SWord8 = s2644 >>> 1+  s2646 :: SWord8 = s24 | s2645+  s2647 :: SWord8 = s26 & s2645+  s2648 :: SWord8 = if s2637 then s2646 else s2647+  s2649 :: SWord8 = if s22 then s2648 else s2643+  s2650 :: SWord8 = s18 & s2649+  s2651 :: SBool = s17 /= s2650+  s2652 :: SBool = s_2 == s2651+  s2653 :: SWord8 = s2635 >>> 1+  s2654 :: SWord8 = s24 | s2653+  s2655 :: SWord8 = s26 & s2653+  s2656 :: SWord8 = if s2630 then s2654 else s2655+  s2657 :: SWord8 = s2656 >>> 1+  s2658 :: SWord8 = s24 | s2657+  s2659 :: SWord8 = s26 & s2657+  s2660 :: SWord8 = if s2651 then s2658 else s2659+  s2661 :: SWord8 = s18 & s2644+  s2662 :: SBool = s17 /= s2661+  s2663 :: SWord8 = s2649 >>> 1+  s2664 :: SWord8 = s24 | s2663+  s2665 :: SWord8 = s26 & s2663+  s2666 :: SWord8 = if s2662 then s2664 else s2665+  s2667 :: SWord8 = if s29 then s2605 else s2458+  s2668 :: SWord8 = if s170 then s2622 else s2667+  s2669 :: SWord8 = if s29 then s2627 else s2668+  s2670 :: SWord8 = if s170 then s2643 else s2669+  s2671 :: SWord8 = if s29 then s2648 else s2670+  s2672 :: SWord8 = if s170 then s2666 else s2671+  s2673 :: SWord8 = s2656 + s2672+  s2674 :: SBool = s2673 < s2672+  s2675 :: SBool = s2673 < s2656+  s2676 :: SBool = s2674 | s2675+  s2677 :: SWord8 = s2673 >>> 1+  s2678 :: SWord8 = s24 | s2677+  s2679 :: SWord8 = s26 & s2677+  s2680 :: SWord8 = if s2676 then s2678 else s2679+  s2681 :: SWord8 = if s2652 then s2660 else s2680+  s2682 :: SWord8 = s2635 + s2670+  s2683 :: SWord8 = s18 & s2682+  s2684 :: SBool = s17 /= s2683+  s2685 :: SWord8 = if s2684 then s2646 else s2647+  s2686 :: SWord8 = if s22 then s2685 else s2643+  s2687 :: SWord8 = s18 & s2686+  s2688 :: SBool = s17 /= s2687+  s2689 :: SBool = s_2 == s2688+  s2690 :: SBool = s2682 < s2670+  s2691 :: SBool = s2682 < s2635+  s2692 :: SBool = s2690 | s2691+  s2693 :: SWord8 = s2682 >>> 1+  s2694 :: SWord8 = s24 | s2693+  s2695 :: SWord8 = s26 & s2693+  s2696 :: SWord8 = if s2692 then s2694 else s2695+  s2697 :: SWord8 = s2696 >>> 1+  s2698 :: SWord8 = s24 | s2697+  s2699 :: SWord8 = s26 & s2697+  s2700 :: SWord8 = if s2688 then s2698 else s2699+  s2701 :: SWord8 = s2686 >>> 1+  s2702 :: SWord8 = s24 | s2701+  s2703 :: SWord8 = s26 & s2701+  s2704 :: SWord8 = if s2662 then s2702 else s2703+  s2705 :: SWord8 = if s29 then s2685 else s2670+  s2706 :: SWord8 = if s170 then s2704 else s2705+  s2707 :: SWord8 = s2696 + s2706+  s2708 :: SBool = s2707 < s2706+  s2709 :: SBool = s2707 < s2696+  s2710 :: SBool = s2708 | s2709+  s2711 :: SWord8 = s2707 >>> 1+  s2712 :: SWord8 = s24 | s2711+  s2713 :: SWord8 = s26 & s2711+  s2714 :: SWord8 = if s2710 then s2712 else s2713+  s2715 :: SWord8 = if s2689 then s2700 else s2714+  s2716 :: SWord8 = if s2631 then s2681 else s2715+  s2717 :: SWord8 = s2616 + s2668+  s2718 :: SWord8 = s18 & s2717+  s2719 :: SBool = s17 /= s2718+  s2720 :: SWord8 = if s2719 then s2625 else s2626+  s2721 :: SWord8 = if s22 then s2720 else s2622+  s2722 :: SWord8 = s18 & s2721+  s2723 :: SBool = s17 /= s2722+  s2724 :: SBool = s_2 == s2723+  s2725 :: SBool = s2717 < s2668+  s2726 :: SBool = s2717 < s2616+  s2727 :: SBool = s2725 | s2726+  s2728 :: SWord8 = s2717 >>> 1+  s2729 :: SWord8 = s24 | s2728+  s2730 :: SWord8 = s26 & s2728+  s2731 :: SWord8 = if s2727 then s2729 else s2730+  s2732 :: SWord8 = s18 & s2731+  s2733 :: SBool = s17 /= s2732+  s2734 :: SWord8 = s2721 >>> 1+  s2735 :: SWord8 = s24 | s2734+  s2736 :: SWord8 = s26 & s2734+  s2737 :: SWord8 = if s2639 then s2735 else s2736+  s2738 :: SWord8 = if s22 then s2737 else s2720+  s2739 :: SWord8 = s2738 >>> 1+  s2740 :: SWord8 = s24 | s2739+  s2741 :: SWord8 = s26 & s2739+  s2742 :: SWord8 = if s2733 then s2740 else s2741+  s2743 :: SWord8 = if s22 then s2742 else s2737+  s2744 :: SWord8 = s18 & s2743+  s2745 :: SBool = s17 /= s2744+  s2746 :: SBool = s_2 == s2745+  s2747 :: SWord8 = s2731 >>> 1+  s2748 :: SWord8 = s24 | s2747+  s2749 :: SWord8 = s26 & s2747+  s2750 :: SWord8 = if s2723 then s2748 else s2749+  s2751 :: SWord8 = s2750 >>> 1+  s2752 :: SWord8 = s24 | s2751+  s2753 :: SWord8 = s26 & s2751+  s2754 :: SWord8 = if s2745 then s2752 else s2753+  s2755 :: SWord8 = s18 & s2738+  s2756 :: SBool = s17 /= s2755+  s2757 :: SWord8 = s2743 >>> 1+  s2758 :: SWord8 = s24 | s2757+  s2759 :: SWord8 = s26 & s2757+  s2760 :: SWord8 = if s2756 then s2758 else s2759+  s2761 :: SWord8 = if s29 then s2720 else s2668+  s2762 :: SWord8 = if s170 then s2737 else s2761+  s2763 :: SWord8 = if s29 then s2742 else s2762+  s2764 :: SWord8 = if s170 then s2760 else s2763+  s2765 :: SWord8 = s2750 + s2764+  s2766 :: SBool = s2765 < s2764+  s2767 :: SBool = s2765 < s2750+  s2768 :: SBool = s2766 | s2767+  s2769 :: SWord8 = s2765 >>> 1+  s2770 :: SWord8 = s24 | s2769+  s2771 :: SWord8 = s26 & s2769+  s2772 :: SWord8 = if s2768 then s2770 else s2771+  s2773 :: SWord8 = if s2746 then s2754 else s2772+  s2774 :: SWord8 = s2731 + s2762+  s2775 :: SWord8 = s18 & s2774+  s2776 :: SBool = s17 /= s2775+  s2777 :: SWord8 = if s2776 then s2740 else s2741+  s2778 :: SWord8 = if s22 then s2777 else s2737+  s2779 :: SWord8 = s18 & s2778+  s2780 :: SBool = s17 /= s2779+  s2781 :: SBool = s_2 == s2780+  s2782 :: SBool = s2774 < s2762+  s2783 :: SBool = s2774 < s2731+  s2784 :: SBool = s2782 | s2783+  s2785 :: SWord8 = s2774 >>> 1+  s2786 :: SWord8 = s24 | s2785+  s2787 :: SWord8 = s26 & s2785+  s2788 :: SWord8 = if s2784 then s2786 else s2787+  s2789 :: SWord8 = s2788 >>> 1+  s2790 :: SWord8 = s24 | s2789+  s2791 :: SWord8 = s26 & s2789+  s2792 :: SWord8 = if s2780 then s2790 else s2791+  s2793 :: SWord8 = s2778 >>> 1+  s2794 :: SWord8 = s24 | s2793+  s2795 :: SWord8 = s26 & s2793+  s2796 :: SWord8 = if s2756 then s2794 else s2795+  s2797 :: SWord8 = if s29 then s2777 else s2762+  s2798 :: SWord8 = if s170 then s2796 else s2797+  s2799 :: SWord8 = s2788 + s2798+  s2800 :: SBool = s2799 < s2798+  s2801 :: SBool = s2799 < s2788+  s2802 :: SBool = s2800 | s2801+  s2803 :: SWord8 = s2799 >>> 1+  s2804 :: SWord8 = s24 | s2803+  s2805 :: SWord8 = s26 & s2803+  s2806 :: SWord8 = if s2802 then s2804 else s2805+  s2807 :: SWord8 = if s2781 then s2792 else s2806+  s2808 :: SWord8 = if s2724 then s2773 else s2807+  s2809 :: SWord8 = if s2609 then s2716 else s2808+  s2810 :: SWord8 = if s2378 then s2601 else s2809+  s2811 :: SWord8 = if s1914 then s2370 else s2810+  s2812 :: SWord8 = s1899 + s2014+  s2813 :: SWord8 = s18 & s2812+  s2814 :: SBool = s17 /= s2813+  s2815 :: SWord8 = if s2814 then s1908 else s1909+  s2816 :: SWord8 = if s22 then s2815 else s1905+  s2817 :: SWord8 = s18 & s2816+  s2818 :: SBool = s17 /= s2817+  s2819 :: SBool = s_2 == s2818+  s2820 :: SBool = s2812 < s2014+  s2821 :: SBool = s2812 < s1899+  s2822 :: SBool = s2820 | s2821+  s2823 :: SWord8 = s2812 >>> 1+  s2824 :: SWord8 = s24 | s2823+  s2825 :: SWord8 = s26 & s2823+  s2826 :: SWord8 = if s2822 then s2824 else s2825+  s2827 :: SWord8 = s18 & s2826+  s2828 :: SBool = s17 /= s2827+  s2829 :: SWord8 = s2816 >>> 1+  s2830 :: SWord8 = s24 | s2829+  s2831 :: SWord8 = s26 & s2829+  s2832 :: SWord8 = if s1922 then s2830 else s2831+  s2833 :: SWord8 = if s22 then s2832 else s2815+  s2834 :: SWord8 = s2833 >>> 1+  s2835 :: SWord8 = s24 | s2834+  s2836 :: SWord8 = s26 & s2834+  s2837 :: SWord8 = if s2828 then s2835 else s2836+  s2838 :: SWord8 = if s22 then s2837 else s2832+  s2839 :: SWord8 = s18 & s2838+  s2840 :: SBool = s17 /= s2839+  s2841 :: SBool = s_2 == s2840+  s2842 :: SWord8 = s2826 >>> 1+  s2843 :: SWord8 = s24 | s2842+  s2844 :: SWord8 = s26 & s2842+  s2845 :: SWord8 = if s2818 then s2843 else s2844+  s2846 :: SWord8 = s18 & s2845+  s2847 :: SBool = s17 /= s2846+  s2848 :: SWord8 = s18 & s2833+  s2849 :: SBool = s17 /= s2848+  s2850 :: SWord8 = s2838 >>> 1+  s2851 :: SWord8 = s24 | s2850+  s2852 :: SWord8 = s26 & s2850+  s2853 :: SWord8 = if s2849 then s2851 else s2852+  s2854 :: SWord8 = if s22 then s2853 else s2837+  s2855 :: SWord8 = s2854 >>> 1+  s2856 :: SWord8 = s24 | s2855+  s2857 :: SWord8 = s26 & s2855+  s2858 :: SWord8 = if s2847 then s2856 else s2857+  s2859 :: SWord8 = if s22 then s2858 else s2853+  s2860 :: SWord8 = s18 & s2859+  s2861 :: SBool = s17 /= s2860+  s2862 :: SBool = s_2 == s2861+  s2863 :: SWord8 = s2845 >>> 1+  s2864 :: SWord8 = s24 | s2863+  s2865 :: SWord8 = s26 & s2863+  s2866 :: SWord8 = if s2840 then s2864 else s2865+  s2867 :: SWord8 = s18 & s2866+  s2868 :: SBool = s17 /= s2867+  s2869 :: SWord8 = s18 & s2854+  s2870 :: SBool = s17 /= s2869+  s2871 :: SWord8 = s2859 >>> 1+  s2872 :: SWord8 = s24 | s2871+  s2873 :: SWord8 = s26 & s2871+  s2874 :: SWord8 = if s2870 then s2872 else s2873+  s2875 :: SWord8 = if s22 then s2874 else s2858+  s2876 :: SWord8 = s2875 >>> 1+  s2877 :: SWord8 = s24 | s2876+  s2878 :: SWord8 = s26 & s2876+  s2879 :: SWord8 = if s2868 then s2877 else s2878+  s2880 :: SWord8 = if s22 then s2879 else s2874+  s2881 :: SWord8 = s18 & s2880+  s2882 :: SBool = s17 /= s2881+  s2883 :: SBool = s_2 == s2882+  s2884 :: SWord8 = s2866 >>> 1+  s2885 :: SWord8 = s24 | s2884+  s2886 :: SWord8 = s26 & s2884+  s2887 :: SWord8 = if s2861 then s2885 else s2886+  s2888 :: SWord8 = s18 & s2887+  s2889 :: SBool = s17 /= s2888+  s2890 :: SWord8 = s18 & s2875+  s2891 :: SBool = s17 /= s2890+  s2892 :: SWord8 = s2880 >>> 1+  s2893 :: SWord8 = s24 | s2892+  s2894 :: SWord8 = s26 & s2892+  s2895 :: SWord8 = if s2891 then s2893 else s2894+  s2896 :: SWord8 = if s22 then s2895 else s2879+  s2897 :: SWord8 = s2896 >>> 1+  s2898 :: SWord8 = s24 | s2897+  s2899 :: SWord8 = s26 & s2897+  s2900 :: SWord8 = if s2889 then s2898 else s2899+  s2901 :: SWord8 = if s22 then s2900 else s2895+  s2902 :: SWord8 = s18 & s2901+  s2903 :: SBool = s17 /= s2902+  s2904 :: SBool = s_2 == s2903+  s2905 :: SWord8 = s2887 >>> 1+  s2906 :: SWord8 = s24 | s2905+  s2907 :: SWord8 = s26 & s2905+  s2908 :: SWord8 = if s2882 then s2906 else s2907+  s2909 :: SWord8 = s2908 >>> 1+  s2910 :: SWord8 = s24 | s2909+  s2911 :: SWord8 = s26 & s2909+  s2912 :: SWord8 = if s2903 then s2910 else s2911+  s2913 :: SWord8 = s18 & s2896+  s2914 :: SBool = s17 /= s2913+  s2915 :: SWord8 = s2901 >>> 1+  s2916 :: SWord8 = s24 | s2915+  s2917 :: SWord8 = s26 & s2915+  s2918 :: SWord8 = if s2914 then s2916 else s2917+  s2919 :: SWord8 = if s29 then s2815 else s2014+  s2920 :: SWord8 = if s170 then s2832 else s2919+  s2921 :: SWord8 = if s29 then s2837 else s2920+  s2922 :: SWord8 = if s170 then s2853 else s2921+  s2923 :: SWord8 = if s29 then s2858 else s2922+  s2924 :: SWord8 = if s170 then s2874 else s2923+  s2925 :: SWord8 = if s29 then s2879 else s2924+  s2926 :: SWord8 = if s170 then s2895 else s2925+  s2927 :: SWord8 = if s29 then s2900 else s2926+  s2928 :: SWord8 = if s170 then s2918 else s2927+  s2929 :: SWord8 = s2908 + s2928+  s2930 :: SBool = s2929 < s2928+  s2931 :: SBool = s2929 < s2908+  s2932 :: SBool = s2930 | s2931+  s2933 :: SWord8 = s2929 >>> 1+  s2934 :: SWord8 = s24 | s2933+  s2935 :: SWord8 = s26 & s2933+  s2936 :: SWord8 = if s2932 then s2934 else s2935+  s2937 :: SWord8 = if s2904 then s2912 else s2936+  s2938 :: SWord8 = s2887 + s2926+  s2939 :: SWord8 = s18 & s2938+  s2940 :: SBool = s17 /= s2939+  s2941 :: SWord8 = if s2940 then s2898 else s2899+  s2942 :: SWord8 = if s22 then s2941 else s2895+  s2943 :: SWord8 = s18 & s2942+  s2944 :: SBool = s17 /= s2943+  s2945 :: SBool = s_2 == s2944+  s2946 :: SBool = s2938 < s2926+  s2947 :: SBool = s2938 < s2887+  s2948 :: SBool = s2946 | s2947+  s2949 :: SWord8 = s2938 >>> 1+  s2950 :: SWord8 = s24 | s2949+  s2951 :: SWord8 = s26 & s2949+  s2952 :: SWord8 = if s2948 then s2950 else s2951+  s2953 :: SWord8 = s2952 >>> 1+  s2954 :: SWord8 = s24 | s2953+  s2955 :: SWord8 = s26 & s2953+  s2956 :: SWord8 = if s2944 then s2954 else s2955+  s2957 :: SWord8 = s2942 >>> 1+  s2958 :: SWord8 = s24 | s2957+  s2959 :: SWord8 = s26 & s2957+  s2960 :: SWord8 = if s2914 then s2958 else s2959+  s2961 :: SWord8 = if s29 then s2941 else s2926+  s2962 :: SWord8 = if s170 then s2960 else s2961+  s2963 :: SWord8 = s2952 + s2962+  s2964 :: SBool = s2963 < s2962+  s2965 :: SBool = s2963 < s2952+  s2966 :: SBool = s2964 | s2965+  s2967 :: SWord8 = s2963 >>> 1+  s2968 :: SWord8 = s24 | s2967+  s2969 :: SWord8 = s26 & s2967+  s2970 :: SWord8 = if s2966 then s2968 else s2969+  s2971 :: SWord8 = if s2945 then s2956 else s2970+  s2972 :: SWord8 = if s2883 then s2937 else s2971+  s2973 :: SWord8 = s2866 + s2924+  s2974 :: SWord8 = s18 & s2973+  s2975 :: SBool = s17 /= s2974+  s2976 :: SWord8 = if s2975 then s2877 else s2878+  s2977 :: SWord8 = if s22 then s2976 else s2874+  s2978 :: SWord8 = s18 & s2977+  s2979 :: SBool = s17 /= s2978+  s2980 :: SBool = s_2 == s2979+  s2981 :: SBool = s2973 < s2924+  s2982 :: SBool = s2973 < s2866+  s2983 :: SBool = s2981 | s2982+  s2984 :: SWord8 = s2973 >>> 1+  s2985 :: SWord8 = s24 | s2984+  s2986 :: SWord8 = s26 & s2984+  s2987 :: SWord8 = if s2983 then s2985 else s2986+  s2988 :: SWord8 = s18 & s2987+  s2989 :: SBool = s17 /= s2988+  s2990 :: SWord8 = s2977 >>> 1+  s2991 :: SWord8 = s24 | s2990+  s2992 :: SWord8 = s26 & s2990+  s2993 :: SWord8 = if s2891 then s2991 else s2992+  s2994 :: SWord8 = if s22 then s2993 else s2976+  s2995 :: SWord8 = s2994 >>> 1+  s2996 :: SWord8 = s24 | s2995+  s2997 :: SWord8 = s26 & s2995+  s2998 :: SWord8 = if s2989 then s2996 else s2997+  s2999 :: SWord8 = if s22 then s2998 else s2993+  s3000 :: SWord8 = s18 & s2999+  s3001 :: SBool = s17 /= s3000+  s3002 :: SBool = s_2 == s3001+  s3003 :: SWord8 = s2987 >>> 1+  s3004 :: SWord8 = s24 | s3003+  s3005 :: SWord8 = s26 & s3003+  s3006 :: SWord8 = if s2979 then s3004 else s3005+  s3007 :: SWord8 = s3006 >>> 1+  s3008 :: SWord8 = s24 | s3007+  s3009 :: SWord8 = s26 & s3007+  s3010 :: SWord8 = if s3001 then s3008 else s3009+  s3011 :: SWord8 = s18 & s2994+  s3012 :: SBool = s17 /= s3011+  s3013 :: SWord8 = s2999 >>> 1+  s3014 :: SWord8 = s24 | s3013+  s3015 :: SWord8 = s26 & s3013+  s3016 :: SWord8 = if s3012 then s3014 else s3015+  s3017 :: SWord8 = if s29 then s2976 else s2924+  s3018 :: SWord8 = if s170 then s2993 else s3017+  s3019 :: SWord8 = if s29 then s2998 else s3018+  s3020 :: SWord8 = if s170 then s3016 else s3019+  s3021 :: SWord8 = s3006 + s3020+  s3022 :: SBool = s3021 < s3020+  s3023 :: SBool = s3021 < s3006+  s3024 :: SBool = s3022 | s3023+  s3025 :: SWord8 = s3021 >>> 1+  s3026 :: SWord8 = s24 | s3025+  s3027 :: SWord8 = s26 & s3025+  s3028 :: SWord8 = if s3024 then s3026 else s3027+  s3029 :: SWord8 = if s3002 then s3010 else s3028+  s3030 :: SWord8 = s2987 + s3018+  s3031 :: SWord8 = s18 & s3030+  s3032 :: SBool = s17 /= s3031+  s3033 :: SWord8 = if s3032 then s2996 else s2997+  s3034 :: SWord8 = if s22 then s3033 else s2993+  s3035 :: SWord8 = s18 & s3034+  s3036 :: SBool = s17 /= s3035+  s3037 :: SBool = s_2 == s3036+  s3038 :: SBool = s3030 < s3018+  s3039 :: SBool = s3030 < s2987+  s3040 :: SBool = s3038 | s3039+  s3041 :: SWord8 = s3030 >>> 1+  s3042 :: SWord8 = s24 | s3041+  s3043 :: SWord8 = s26 & s3041+  s3044 :: SWord8 = if s3040 then s3042 else s3043+  s3045 :: SWord8 = s3044 >>> 1+  s3046 :: SWord8 = s24 | s3045+  s3047 :: SWord8 = s26 & s3045+  s3048 :: SWord8 = if s3036 then s3046 else s3047+  s3049 :: SWord8 = s3034 >>> 1+  s3050 :: SWord8 = s24 | s3049+  s3051 :: SWord8 = s26 & s3049+  s3052 :: SWord8 = if s3012 then s3050 else s3051+  s3053 :: SWord8 = if s29 then s3033 else s3018+  s3054 :: SWord8 = if s170 then s3052 else s3053+  s3055 :: SWord8 = s3044 + s3054+  s3056 :: SBool = s3055 < s3054+  s3057 :: SBool = s3055 < s3044+  s3058 :: SBool = s3056 | s3057+  s3059 :: SWord8 = s3055 >>> 1+  s3060 :: SWord8 = s24 | s3059+  s3061 :: SWord8 = s26 & s3059+  s3062 :: SWord8 = if s3058 then s3060 else s3061+  s3063 :: SWord8 = if s3037 then s3048 else s3062+  s3064 :: SWord8 = if s2980 then s3029 else s3063+  s3065 :: SWord8 = if s2862 then s2972 else s3064+  s3066 :: SWord8 = s2845 + s2922+  s3067 :: SWord8 = s18 & s3066+  s3068 :: SBool = s17 /= s3067+  s3069 :: SWord8 = if s3068 then s2856 else s2857+  s3070 :: SWord8 = if s22 then s3069 else s2853+  s3071 :: SWord8 = s18 & s3070+  s3072 :: SBool = s17 /= s3071+  s3073 :: SBool = s_2 == s3072+  s3074 :: SBool = s3066 < s2922+  s3075 :: SBool = s3066 < s2845+  s3076 :: SBool = s3074 | s3075+  s3077 :: SWord8 = s3066 >>> 1+  s3078 :: SWord8 = s24 | s3077+  s3079 :: SWord8 = s26 & s3077+  s3080 :: SWord8 = if s3076 then s3078 else s3079+  s3081 :: SWord8 = s18 & s3080+  s3082 :: SBool = s17 /= s3081+  s3083 :: SWord8 = s3070 >>> 1+  s3084 :: SWord8 = s24 | s3083+  s3085 :: SWord8 = s26 & s3083+  s3086 :: SWord8 = if s2870 then s3084 else s3085+  s3087 :: SWord8 = if s22 then s3086 else s3069+  s3088 :: SWord8 = s3087 >>> 1+  s3089 :: SWord8 = s24 | s3088+  s3090 :: SWord8 = s26 & s3088+  s3091 :: SWord8 = if s3082 then s3089 else s3090+  s3092 :: SWord8 = if s22 then s3091 else s3086+  s3093 :: SWord8 = s18 & s3092+  s3094 :: SBool = s17 /= s3093+  s3095 :: SBool = s_2 == s3094+  s3096 :: SWord8 = s3080 >>> 1+  s3097 :: SWord8 = s24 | s3096+  s3098 :: SWord8 = s26 & s3096+  s3099 :: SWord8 = if s3072 then s3097 else s3098+  s3100 :: SWord8 = s18 & s3099+  s3101 :: SBool = s17 /= s3100+  s3102 :: SWord8 = s18 & s3087+  s3103 :: SBool = s17 /= s3102+  s3104 :: SWord8 = s3092 >>> 1+  s3105 :: SWord8 = s24 | s3104+  s3106 :: SWord8 = s26 & s3104+  s3107 :: SWord8 = if s3103 then s3105 else s3106+  s3108 :: SWord8 = if s22 then s3107 else s3091+  s3109 :: SWord8 = s3108 >>> 1+  s3110 :: SWord8 = s24 | s3109+  s3111 :: SWord8 = s26 & s3109+  s3112 :: SWord8 = if s3101 then s3110 else s3111+  s3113 :: SWord8 = if s22 then s3112 else s3107+  s3114 :: SWord8 = s18 & s3113+  s3115 :: SBool = s17 /= s3114+  s3116 :: SBool = s_2 == s3115+  s3117 :: SWord8 = s3099 >>> 1+  s3118 :: SWord8 = s24 | s3117+  s3119 :: SWord8 = s26 & s3117+  s3120 :: SWord8 = if s3094 then s3118 else s3119+  s3121 :: SWord8 = s3120 >>> 1+  s3122 :: SWord8 = s24 | s3121+  s3123 :: SWord8 = s26 & s3121+  s3124 :: SWord8 = if s3115 then s3122 else s3123+  s3125 :: SWord8 = s18 & s3108+  s3126 :: SBool = s17 /= s3125+  s3127 :: SWord8 = s3113 >>> 1+  s3128 :: SWord8 = s24 | s3127+  s3129 :: SWord8 = s26 & s3127+  s3130 :: SWord8 = if s3126 then s3128 else s3129+  s3131 :: SWord8 = if s29 then s3069 else s2922+  s3132 :: SWord8 = if s170 then s3086 else s3131+  s3133 :: SWord8 = if s29 then s3091 else s3132+  s3134 :: SWord8 = if s170 then s3107 else s3133+  s3135 :: SWord8 = if s29 then s3112 else s3134+  s3136 :: SWord8 = if s170 then s3130 else s3135+  s3137 :: SWord8 = s3120 + s3136+  s3138 :: SBool = s3137 < s3136+  s3139 :: SBool = s3137 < s3120+  s3140 :: SBool = s3138 | s3139+  s3141 :: SWord8 = s3137 >>> 1+  s3142 :: SWord8 = s24 | s3141+  s3143 :: SWord8 = s26 & s3141+  s3144 :: SWord8 = if s3140 then s3142 else s3143+  s3145 :: SWord8 = if s3116 then s3124 else s3144+  s3146 :: SWord8 = s3099 + s3134+  s3147 :: SWord8 = s18 & s3146+  s3148 :: SBool = s17 /= s3147+  s3149 :: SWord8 = if s3148 then s3110 else s3111+  s3150 :: SWord8 = if s22 then s3149 else s3107+  s3151 :: SWord8 = s18 & s3150+  s3152 :: SBool = s17 /= s3151+  s3153 :: SBool = s_2 == s3152+  s3154 :: SBool = s3146 < s3134+  s3155 :: SBool = s3146 < s3099+  s3156 :: SBool = s3154 | s3155+  s3157 :: SWord8 = s3146 >>> 1+  s3158 :: SWord8 = s24 | s3157+  s3159 :: SWord8 = s26 & s3157+  s3160 :: SWord8 = if s3156 then s3158 else s3159+  s3161 :: SWord8 = s3160 >>> 1+  s3162 :: SWord8 = s24 | s3161+  s3163 :: SWord8 = s26 & s3161+  s3164 :: SWord8 = if s3152 then s3162 else s3163+  s3165 :: SWord8 = s3150 >>> 1+  s3166 :: SWord8 = s24 | s3165+  s3167 :: SWord8 = s26 & s3165+  s3168 :: SWord8 = if s3126 then s3166 else s3167+  s3169 :: SWord8 = if s29 then s3149 else s3134+  s3170 :: SWord8 = if s170 then s3168 else s3169+  s3171 :: SWord8 = s3160 + s3170+  s3172 :: SBool = s3171 < s3170+  s3173 :: SBool = s3171 < s3160+  s3174 :: SBool = s3172 | s3173+  s3175 :: SWord8 = s3171 >>> 1+  s3176 :: SWord8 = s24 | s3175+  s3177 :: SWord8 = s26 & s3175+  s3178 :: SWord8 = if s3174 then s3176 else s3177+  s3179 :: SWord8 = if s3153 then s3164 else s3178+  s3180 :: SWord8 = if s3095 then s3145 else s3179+  s3181 :: SWord8 = s3080 + s3132+  s3182 :: SWord8 = s18 & s3181+  s3183 :: SBool = s17 /= s3182+  s3184 :: SWord8 = if s3183 then s3089 else s3090+  s3185 :: SWord8 = if s22 then s3184 else s3086+  s3186 :: SWord8 = s18 & s3185+  s3187 :: SBool = s17 /= s3186+  s3188 :: SBool = s_2 == s3187+  s3189 :: SBool = s3181 < s3132+  s3190 :: SBool = s3181 < s3080+  s3191 :: SBool = s3189 | s3190+  s3192 :: SWord8 = s3181 >>> 1+  s3193 :: SWord8 = s24 | s3192+  s3194 :: SWord8 = s26 & s3192+  s3195 :: SWord8 = if s3191 then s3193 else s3194+  s3196 :: SWord8 = s18 & s3195+  s3197 :: SBool = s17 /= s3196+  s3198 :: SWord8 = s3185 >>> 1+  s3199 :: SWord8 = s24 | s3198+  s3200 :: SWord8 = s26 & s3198+  s3201 :: SWord8 = if s3103 then s3199 else s3200+  s3202 :: SWord8 = if s22 then s3201 else s3184+  s3203 :: SWord8 = s3202 >>> 1+  s3204 :: SWord8 = s24 | s3203+  s3205 :: SWord8 = s26 & s3203+  s3206 :: SWord8 = if s3197 then s3204 else s3205+  s3207 :: SWord8 = if s22 then s3206 else s3201+  s3208 :: SWord8 = s18 & s3207+  s3209 :: SBool = s17 /= s3208+  s3210 :: SBool = s_2 == s3209+  s3211 :: SWord8 = s3195 >>> 1+  s3212 :: SWord8 = s24 | s3211+  s3213 :: SWord8 = s26 & s3211+  s3214 :: SWord8 = if s3187 then s3212 else s3213+  s3215 :: SWord8 = s3214 >>> 1+  s3216 :: SWord8 = s24 | s3215+  s3217 :: SWord8 = s26 & s3215+  s3218 :: SWord8 = if s3209 then s3216 else s3217+  s3219 :: SWord8 = s18 & s3202+  s3220 :: SBool = s17 /= s3219+  s3221 :: SWord8 = s3207 >>> 1+  s3222 :: SWord8 = s24 | s3221+  s3223 :: SWord8 = s26 & s3221+  s3224 :: SWord8 = if s3220 then s3222 else s3223+  s3225 :: SWord8 = if s29 then s3184 else s3132+  s3226 :: SWord8 = if s170 then s3201 else s3225+  s3227 :: SWord8 = if s29 then s3206 else s3226+  s3228 :: SWord8 = if s170 then s3224 else s3227+  s3229 :: SWord8 = s3214 + s3228+  s3230 :: SBool = s3229 < s3228+  s3231 :: SBool = s3229 < s3214+  s3232 :: SBool = s3230 | s3231+  s3233 :: SWord8 = s3229 >>> 1+  s3234 :: SWord8 = s24 | s3233+  s3235 :: SWord8 = s26 & s3233+  s3236 :: SWord8 = if s3232 then s3234 else s3235+  s3237 :: SWord8 = if s3210 then s3218 else s3236+  s3238 :: SWord8 = s3195 + s3226+  s3239 :: SWord8 = s18 & s3238+  s3240 :: SBool = s17 /= s3239+  s3241 :: SWord8 = if s3240 then s3204 else s3205+  s3242 :: SWord8 = if s22 then s3241 else s3201+  s3243 :: SWord8 = s18 & s3242+  s3244 :: SBool = s17 /= s3243+  s3245 :: SBool = s_2 == s3244+  s3246 :: SBool = s3238 < s3226+  s3247 :: SBool = s3238 < s3195+  s3248 :: SBool = s3246 | s3247+  s3249 :: SWord8 = s3238 >>> 1+  s3250 :: SWord8 = s24 | s3249+  s3251 :: SWord8 = s26 & s3249+  s3252 :: SWord8 = if s3248 then s3250 else s3251+  s3253 :: SWord8 = s3252 >>> 1+  s3254 :: SWord8 = s24 | s3253+  s3255 :: SWord8 = s26 & s3253+  s3256 :: SWord8 = if s3244 then s3254 else s3255+  s3257 :: SWord8 = s3242 >>> 1+  s3258 :: SWord8 = s24 | s3257+  s3259 :: SWord8 = s26 & s3257+  s3260 :: SWord8 = if s3220 then s3258 else s3259+  s3261 :: SWord8 = if s29 then s3241 else s3226+  s3262 :: SWord8 = if s170 then s3260 else s3261+  s3263 :: SWord8 = s3252 + s3262+  s3264 :: SBool = s3263 < s3262+  s3265 :: SBool = s3263 < s3252+  s3266 :: SBool = s3264 | s3265+  s3267 :: SWord8 = s3263 >>> 1+  s3268 :: SWord8 = s24 | s3267+  s3269 :: SWord8 = s26 & s3267+  s3270 :: SWord8 = if s3266 then s3268 else s3269+  s3271 :: SWord8 = if s3245 then s3256 else s3270+  s3272 :: SWord8 = if s3188 then s3237 else s3271+  s3273 :: SWord8 = if s3073 then s3180 else s3272+  s3274 :: SWord8 = if s2841 then s3065 else s3273+  s3275 :: SWord8 = s2826 + s2920+  s3276 :: SWord8 = s18 & s3275+  s3277 :: SBool = s17 /= s3276+  s3278 :: SWord8 = if s3277 then s2835 else s2836+  s3279 :: SWord8 = if s22 then s3278 else s2832+  s3280 :: SWord8 = s18 & s3279+  s3281 :: SBool = s17 /= s3280+  s3282 :: SBool = s_2 == s3281+  s3283 :: SBool = s3275 < s2920+  s3284 :: SBool = s3275 < s2826+  s3285 :: SBool = s3283 | s3284+  s3286 :: SWord8 = s3275 >>> 1+  s3287 :: SWord8 = s24 | s3286+  s3288 :: SWord8 = s26 & s3286+  s3289 :: SWord8 = if s3285 then s3287 else s3288+  s3290 :: SWord8 = s18 & s3289+  s3291 :: SBool = s17 /= s3290+  s3292 :: SWord8 = s3279 >>> 1+  s3293 :: SWord8 = s24 | s3292+  s3294 :: SWord8 = s26 & s3292+  s3295 :: SWord8 = if s2849 then s3293 else s3294+  s3296 :: SWord8 = if s22 then s3295 else s3278+  s3297 :: SWord8 = s3296 >>> 1+  s3298 :: SWord8 = s24 | s3297+  s3299 :: SWord8 = s26 & s3297+  s3300 :: SWord8 = if s3291 then s3298 else s3299+  s3301 :: SWord8 = if s22 then s3300 else s3295+  s3302 :: SWord8 = s18 & s3301+  s3303 :: SBool = s17 /= s3302+  s3304 :: SBool = s_2 == s3303+  s3305 :: SWord8 = s3289 >>> 1+  s3306 :: SWord8 = s24 | s3305+  s3307 :: SWord8 = s26 & s3305+  s3308 :: SWord8 = if s3281 then s3306 else s3307+  s3309 :: SWord8 = s18 & s3308+  s3310 :: SBool = s17 /= s3309+  s3311 :: SWord8 = s18 & s3296+  s3312 :: SBool = s17 /= s3311+  s3313 :: SWord8 = s3301 >>> 1+  s3314 :: SWord8 = s24 | s3313+  s3315 :: SWord8 = s26 & s3313+  s3316 :: SWord8 = if s3312 then s3314 else s3315+  s3317 :: SWord8 = if s22 then s3316 else s3300+  s3318 :: SWord8 = s3317 >>> 1+  s3319 :: SWord8 = s24 | s3318+  s3320 :: SWord8 = s26 & s3318+  s3321 :: SWord8 = if s3310 then s3319 else s3320+  s3322 :: SWord8 = if s22 then s3321 else s3316+  s3323 :: SWord8 = s18 & s3322+  s3324 :: SBool = s17 /= s3323+  s3325 :: SBool = s_2 == s3324+  s3326 :: SWord8 = s3308 >>> 1+  s3327 :: SWord8 = s24 | s3326+  s3328 :: SWord8 = s26 & s3326+  s3329 :: SWord8 = if s3303 then s3327 else s3328+  s3330 :: SWord8 = s18 & s3329+  s3331 :: SBool = s17 /= s3330+  s3332 :: SWord8 = s18 & s3317+  s3333 :: SBool = s17 /= s3332+  s3334 :: SWord8 = s3322 >>> 1+  s3335 :: SWord8 = s24 | s3334+  s3336 :: SWord8 = s26 & s3334+  s3337 :: SWord8 = if s3333 then s3335 else s3336+  s3338 :: SWord8 = if s22 then s3337 else s3321+  s3339 :: SWord8 = s3338 >>> 1+  s3340 :: SWord8 = s24 | s3339+  s3341 :: SWord8 = s26 & s3339+  s3342 :: SWord8 = if s3331 then s3340 else s3341+  s3343 :: SWord8 = if s22 then s3342 else s3337+  s3344 :: SWord8 = s18 & s3343+  s3345 :: SBool = s17 /= s3344+  s3346 :: SBool = s_2 == s3345+  s3347 :: SWord8 = s3329 >>> 1+  s3348 :: SWord8 = s24 | s3347+  s3349 :: SWord8 = s26 & s3347+  s3350 :: SWord8 = if s3324 then s3348 else s3349+  s3351 :: SWord8 = s3350 >>> 1+  s3352 :: SWord8 = s24 | s3351+  s3353 :: SWord8 = s26 & s3351+  s3354 :: SWord8 = if s3345 then s3352 else s3353+  s3355 :: SWord8 = s18 & s3338+  s3356 :: SBool = s17 /= s3355+  s3357 :: SWord8 = s3343 >>> 1+  s3358 :: SWord8 = s24 | s3357+  s3359 :: SWord8 = s26 & s3357+  s3360 :: SWord8 = if s3356 then s3358 else s3359+  s3361 :: SWord8 = if s29 then s3278 else s2920+  s3362 :: SWord8 = if s170 then s3295 else s3361+  s3363 :: SWord8 = if s29 then s3300 else s3362+  s3364 :: SWord8 = if s170 then s3316 else s3363+  s3365 :: SWord8 = if s29 then s3321 else s3364+  s3366 :: SWord8 = if s170 then s3337 else s3365+  s3367 :: SWord8 = if s29 then s3342 else s3366+  s3368 :: SWord8 = if s170 then s3360 else s3367+  s3369 :: SWord8 = s3350 + s3368+  s3370 :: SBool = s3369 < s3368+  s3371 :: SBool = s3369 < s3350+  s3372 :: SBool = s3370 | s3371+  s3373 :: SWord8 = s3369 >>> 1+  s3374 :: SWord8 = s24 | s3373+  s3375 :: SWord8 = s26 & s3373+  s3376 :: SWord8 = if s3372 then s3374 else s3375+  s3377 :: SWord8 = if s3346 then s3354 else s3376+  s3378 :: SWord8 = s3329 + s3366+  s3379 :: SWord8 = s18 & s3378+  s3380 :: SBool = s17 /= s3379+  s3381 :: SWord8 = if s3380 then s3340 else s3341+  s3382 :: SWord8 = if s22 then s3381 else s3337+  s3383 :: SWord8 = s18 & s3382+  s3384 :: SBool = s17 /= s3383+  s3385 :: SBool = s_2 == s3384+  s3386 :: SBool = s3378 < s3366+  s3387 :: SBool = s3378 < s3329+  s3388 :: SBool = s3386 | s3387+  s3389 :: SWord8 = s3378 >>> 1+  s3390 :: SWord8 = s24 | s3389+  s3391 :: SWord8 = s26 & s3389+  s3392 :: SWord8 = if s3388 then s3390 else s3391+  s3393 :: SWord8 = s3392 >>> 1+  s3394 :: SWord8 = s24 | s3393+  s3395 :: SWord8 = s26 & s3393+  s3396 :: SWord8 = if s3384 then s3394 else s3395+  s3397 :: SWord8 = s3382 >>> 1+  s3398 :: SWord8 = s24 | s3397+  s3399 :: SWord8 = s26 & s3397+  s3400 :: SWord8 = if s3356 then s3398 else s3399+  s3401 :: SWord8 = if s29 then s3381 else s3366+  s3402 :: SWord8 = if s170 then s3400 else s3401+  s3403 :: SWord8 = s3392 + s3402+  s3404 :: SBool = s3403 < s3402+  s3405 :: SBool = s3403 < s3392+  s3406 :: SBool = s3404 | s3405+  s3407 :: SWord8 = s3403 >>> 1+  s3408 :: SWord8 = s24 | s3407+  s3409 :: SWord8 = s26 & s3407+  s3410 :: SWord8 = if s3406 then s3408 else s3409+  s3411 :: SWord8 = if s3385 then s3396 else s3410+  s3412 :: SWord8 = if s3325 then s3377 else s3411+  s3413 :: SWord8 = s3308 + s3364+  s3414 :: SWord8 = s18 & s3413+  s3415 :: SBool = s17 /= s3414+  s3416 :: SWord8 = if s3415 then s3319 else s3320+  s3417 :: SWord8 = if s22 then s3416 else s3316+  s3418 :: SWord8 = s18 & s3417+  s3419 :: SBool = s17 /= s3418+  s3420 :: SBool = s_2 == s3419+  s3421 :: SBool = s3413 < s3364+  s3422 :: SBool = s3413 < s3308+  s3423 :: SBool = s3421 | s3422+  s3424 :: SWord8 = s3413 >>> 1+  s3425 :: SWord8 = s24 | s3424+  s3426 :: SWord8 = s26 & s3424+  s3427 :: SWord8 = if s3423 then s3425 else s3426+  s3428 :: SWord8 = s18 & s3427+  s3429 :: SBool = s17 /= s3428+  s3430 :: SWord8 = s3417 >>> 1+  s3431 :: SWord8 = s24 | s3430+  s3432 :: SWord8 = s26 & s3430+  s3433 :: SWord8 = if s3333 then s3431 else s3432+  s3434 :: SWord8 = if s22 then s3433 else s3416+  s3435 :: SWord8 = s3434 >>> 1+  s3436 :: SWord8 = s24 | s3435+  s3437 :: SWord8 = s26 & s3435+  s3438 :: SWord8 = if s3429 then s3436 else s3437+  s3439 :: SWord8 = if s22 then s3438 else s3433+  s3440 :: SWord8 = s18 & s3439+  s3441 :: SBool = s17 /= s3440+  s3442 :: SBool = s_2 == s3441+  s3443 :: SWord8 = s3427 >>> 1+  s3444 :: SWord8 = s24 | s3443+  s3445 :: SWord8 = s26 & s3443+  s3446 :: SWord8 = if s3419 then s3444 else s3445+  s3447 :: SWord8 = s3446 >>> 1+  s3448 :: SWord8 = s24 | s3447+  s3449 :: SWord8 = s26 & s3447+  s3450 :: SWord8 = if s3441 then s3448 else s3449+  s3451 :: SWord8 = s18 & s3434+  s3452 :: SBool = s17 /= s3451+  s3453 :: SWord8 = s3439 >>> 1+  s3454 :: SWord8 = s24 | s3453+  s3455 :: SWord8 = s26 & s3453+  s3456 :: SWord8 = if s3452 then s3454 else s3455+  s3457 :: SWord8 = if s29 then s3416 else s3364+  s3458 :: SWord8 = if s170 then s3433 else s3457+  s3459 :: SWord8 = if s29 then s3438 else s3458+  s3460 :: SWord8 = if s170 then s3456 else s3459+  s3461 :: SWord8 = s3446 + s3460+  s3462 :: SBool = s3461 < s3460+  s3463 :: SBool = s3461 < s3446+  s3464 :: SBool = s3462 | s3463+  s3465 :: SWord8 = s3461 >>> 1+  s3466 :: SWord8 = s24 | s3465+  s3467 :: SWord8 = s26 & s3465+  s3468 :: SWord8 = if s3464 then s3466 else s3467+  s3469 :: SWord8 = if s3442 then s3450 else s3468+  s3470 :: SWord8 = s3427 + s3458+  s3471 :: SWord8 = s18 & s3470+  s3472 :: SBool = s17 /= s3471+  s3473 :: SWord8 = if s3472 then s3436 else s3437+  s3474 :: SWord8 = if s22 then s3473 else s3433+  s3475 :: SWord8 = s18 & s3474+  s3476 :: SBool = s17 /= s3475+  s3477 :: SBool = s_2 == s3476+  s3478 :: SBool = s3470 < s3458+  s3479 :: SBool = s3470 < s3427+  s3480 :: SBool = s3478 | s3479+  s3481 :: SWord8 = s3470 >>> 1+  s3482 :: SWord8 = s24 | s3481+  s3483 :: SWord8 = s26 & s3481+  s3484 :: SWord8 = if s3480 then s3482 else s3483+  s3485 :: SWord8 = s3484 >>> 1+  s3486 :: SWord8 = s24 | s3485+  s3487 :: SWord8 = s26 & s3485+  s3488 :: SWord8 = if s3476 then s3486 else s3487+  s3489 :: SWord8 = s3474 >>> 1+  s3490 :: SWord8 = s24 | s3489+  s3491 :: SWord8 = s26 & s3489+  s3492 :: SWord8 = if s3452 then s3490 else s3491+  s3493 :: SWord8 = if s29 then s3473 else s3458+  s3494 :: SWord8 = if s170 then s3492 else s3493+  s3495 :: SWord8 = s3484 + s3494+  s3496 :: SBool = s3495 < s3494+  s3497 :: SBool = s3495 < s3484+  s3498 :: SBool = s3496 | s3497+  s3499 :: SWord8 = s3495 >>> 1+  s3500 :: SWord8 = s24 | s3499+  s3501 :: SWord8 = s26 & s3499+  s3502 :: SWord8 = if s3498 then s3500 else s3501+  s3503 :: SWord8 = if s3477 then s3488 else s3502+  s3504 :: SWord8 = if s3420 then s3469 else s3503+  s3505 :: SWord8 = if s3304 then s3412 else s3504+  s3506 :: SWord8 = s3289 + s3362+  s3507 :: SWord8 = s18 & s3506+  s3508 :: SBool = s17 /= s3507+  s3509 :: SWord8 = if s3508 then s3298 else s3299+  s3510 :: SWord8 = if s22 then s3509 else s3295+  s3511 :: SWord8 = s18 & s3510+  s3512 :: SBool = s17 /= s3511+  s3513 :: SBool = s_2 == s3512+  s3514 :: SBool = s3506 < s3362+  s3515 :: SBool = s3506 < s3289+  s3516 :: SBool = s3514 | s3515+  s3517 :: SWord8 = s3506 >>> 1+  s3518 :: SWord8 = s24 | s3517+  s3519 :: SWord8 = s26 & s3517+  s3520 :: SWord8 = if s3516 then s3518 else s3519+  s3521 :: SWord8 = s18 & s3520+  s3522 :: SBool = s17 /= s3521+  s3523 :: SWord8 = s3510 >>> 1+  s3524 :: SWord8 = s24 | s3523+  s3525 :: SWord8 = s26 & s3523+  s3526 :: SWord8 = if s3312 then s3524 else s3525+  s3527 :: SWord8 = if s22 then s3526 else s3509+  s3528 :: SWord8 = s3527 >>> 1+  s3529 :: SWord8 = s24 | s3528+  s3530 :: SWord8 = s26 & s3528+  s3531 :: SWord8 = if s3522 then s3529 else s3530+  s3532 :: SWord8 = if s22 then s3531 else s3526+  s3533 :: SWord8 = s18 & s3532+  s3534 :: SBool = s17 /= s3533+  s3535 :: SBool = s_2 == s3534+  s3536 :: SWord8 = s3520 >>> 1+  s3537 :: SWord8 = s24 | s3536+  s3538 :: SWord8 = s26 & s3536+  s3539 :: SWord8 = if s3512 then s3537 else s3538+  s3540 :: SWord8 = s18 & s3539+  s3541 :: SBool = s17 /= s3540+  s3542 :: SWord8 = s18 & s3527+  s3543 :: SBool = s17 /= s3542+  s3544 :: SWord8 = s3532 >>> 1+  s3545 :: SWord8 = s24 | s3544+  s3546 :: SWord8 = s26 & s3544+  s3547 :: SWord8 = if s3543 then s3545 else s3546+  s3548 :: SWord8 = if s22 then s3547 else s3531+  s3549 :: SWord8 = s3548 >>> 1+  s3550 :: SWord8 = s24 | s3549+  s3551 :: SWord8 = s26 & s3549+  s3552 :: SWord8 = if s3541 then s3550 else s3551+  s3553 :: SWord8 = if s22 then s3552 else s3547+  s3554 :: SWord8 = s18 & s3553+  s3555 :: SBool = s17 /= s3554+  s3556 :: SBool = s_2 == s3555+  s3557 :: SWord8 = s3539 >>> 1+  s3558 :: SWord8 = s24 | s3557+  s3559 :: SWord8 = s26 & s3557+  s3560 :: SWord8 = if s3534 then s3558 else s3559+  s3561 :: SWord8 = s3560 >>> 1+  s3562 :: SWord8 = s24 | s3561+  s3563 :: SWord8 = s26 & s3561+  s3564 :: SWord8 = if s3555 then s3562 else s3563+  s3565 :: SWord8 = s18 & s3548+  s3566 :: SBool = s17 /= s3565+  s3567 :: SWord8 = s3553 >>> 1+  s3568 :: SWord8 = s24 | s3567+  s3569 :: SWord8 = s26 & s3567+  s3570 :: SWord8 = if s3566 then s3568 else s3569+  s3571 :: SWord8 = if s29 then s3509 else s3362+  s3572 :: SWord8 = if s170 then s3526 else s3571+  s3573 :: SWord8 = if s29 then s3531 else s3572+  s3574 :: SWord8 = if s170 then s3547 else s3573+  s3575 :: SWord8 = if s29 then s3552 else s3574+  s3576 :: SWord8 = if s170 then s3570 else s3575+  s3577 :: SWord8 = s3560 + s3576+  s3578 :: SBool = s3577 < s3576+  s3579 :: SBool = s3577 < s3560+  s3580 :: SBool = s3578 | s3579+  s3581 :: SWord8 = s3577 >>> 1+  s3582 :: SWord8 = s24 | s3581+  s3583 :: SWord8 = s26 & s3581+  s3584 :: SWord8 = if s3580 then s3582 else s3583+  s3585 :: SWord8 = if s3556 then s3564 else s3584+  s3586 :: SWord8 = s3539 + s3574+  s3587 :: SWord8 = s18 & s3586+  s3588 :: SBool = s17 /= s3587+  s3589 :: SWord8 = if s3588 then s3550 else s3551+  s3590 :: SWord8 = if s22 then s3589 else s3547+  s3591 :: SWord8 = s18 & s3590+  s3592 :: SBool = s17 /= s3591+  s3593 :: SBool = s_2 == s3592+  s3594 :: SBool = s3586 < s3574+  s3595 :: SBool = s3586 < s3539+  s3596 :: SBool = s3594 | s3595+  s3597 :: SWord8 = s3586 >>> 1+  s3598 :: SWord8 = s24 | s3597+  s3599 :: SWord8 = s26 & s3597+  s3600 :: SWord8 = if s3596 then s3598 else s3599+  s3601 :: SWord8 = s3600 >>> 1+  s3602 :: SWord8 = s24 | s3601+  s3603 :: SWord8 = s26 & s3601+  s3604 :: SWord8 = if s3592 then s3602 else s3603+  s3605 :: SWord8 = s3590 >>> 1+  s3606 :: SWord8 = s24 | s3605+  s3607 :: SWord8 = s26 & s3605+  s3608 :: SWord8 = if s3566 then s3606 else s3607+  s3609 :: SWord8 = if s29 then s3589 else s3574+  s3610 :: SWord8 = if s170 then s3608 else s3609+  s3611 :: SWord8 = s3600 + s3610+  s3612 :: SBool = s3611 < s3610+  s3613 :: SBool = s3611 < s3600+  s3614 :: SBool = s3612 | s3613+  s3615 :: SWord8 = s3611 >>> 1+  s3616 :: SWord8 = s24 | s3615+  s3617 :: SWord8 = s26 & s3615+  s3618 :: SWord8 = if s3614 then s3616 else s3617+  s3619 :: SWord8 = if s3593 then s3604 else s3618+  s3620 :: SWord8 = if s3535 then s3585 else s3619+  s3621 :: SWord8 = s3520 + s3572+  s3622 :: SWord8 = s18 & s3621+  s3623 :: SBool = s17 /= s3622+  s3624 :: SWord8 = if s3623 then s3529 else s3530+  s3625 :: SWord8 = if s22 then s3624 else s3526+  s3626 :: SWord8 = s18 & s3625+  s3627 :: SBool = s17 /= s3626+  s3628 :: SBool = s_2 == s3627+  s3629 :: SBool = s3621 < s3572+  s3630 :: SBool = s3621 < s3520+  s3631 :: SBool = s3629 | s3630+  s3632 :: SWord8 = s3621 >>> 1+  s3633 :: SWord8 = s24 | s3632+  s3634 :: SWord8 = s26 & s3632+  s3635 :: SWord8 = if s3631 then s3633 else s3634+  s3636 :: SWord8 = s18 & s3635+  s3637 :: SBool = s17 /= s3636+  s3638 :: SWord8 = s3625 >>> 1+  s3639 :: SWord8 = s24 | s3638+  s3640 :: SWord8 = s26 & s3638+  s3641 :: SWord8 = if s3543 then s3639 else s3640+  s3642 :: SWord8 = if s22 then s3641 else s3624+  s3643 :: SWord8 = s3642 >>> 1+  s3644 :: SWord8 = s24 | s3643+  s3645 :: SWord8 = s26 & s3643+  s3646 :: SWord8 = if s3637 then s3644 else s3645+  s3647 :: SWord8 = if s22 then s3646 else s3641+  s3648 :: SWord8 = s18 & s3647+  s3649 :: SBool = s17 /= s3648+  s3650 :: SBool = s_2 == s3649+  s3651 :: SWord8 = s3635 >>> 1+  s3652 :: SWord8 = s24 | s3651+  s3653 :: SWord8 = s26 & s3651+  s3654 :: SWord8 = if s3627 then s3652 else s3653+  s3655 :: SWord8 = s3654 >>> 1+  s3656 :: SWord8 = s24 | s3655+  s3657 :: SWord8 = s26 & s3655+  s3658 :: SWord8 = if s3649 then s3656 else s3657+  s3659 :: SWord8 = s18 & s3642+  s3660 :: SBool = s17 /= s3659+  s3661 :: SWord8 = s3647 >>> 1+  s3662 :: SWord8 = s24 | s3661+  s3663 :: SWord8 = s26 & s3661+  s3664 :: SWord8 = if s3660 then s3662 else s3663+  s3665 :: SWord8 = if s29 then s3624 else s3572+  s3666 :: SWord8 = if s170 then s3641 else s3665+  s3667 :: SWord8 = if s29 then s3646 else s3666+  s3668 :: SWord8 = if s170 then s3664 else s3667+  s3669 :: SWord8 = s3654 + s3668+  s3670 :: SBool = s3669 < s3668+  s3671 :: SBool = s3669 < s3654+  s3672 :: SBool = s3670 | s3671+  s3673 :: SWord8 = s3669 >>> 1+  s3674 :: SWord8 = s24 | s3673+  s3675 :: SWord8 = s26 & s3673+  s3676 :: SWord8 = if s3672 then s3674 else s3675+  s3677 :: SWord8 = if s3650 then s3658 else s3676+  s3678 :: SWord8 = s3635 + s3666+  s3679 :: SWord8 = s18 & s3678+  s3680 :: SBool = s17 /= s3679+  s3681 :: SWord8 = if s3680 then s3644 else s3645+  s3682 :: SWord8 = if s22 then s3681 else s3641+  s3683 :: SWord8 = s18 & s3682+  s3684 :: SBool = s17 /= s3683+  s3685 :: SBool = s_2 == s3684+  s3686 :: SBool = s3678 < s3666+  s3687 :: SBool = s3678 < s3635+  s3688 :: SBool = s3686 | s3687+  s3689 :: SWord8 = s3678 >>> 1+  s3690 :: SWord8 = s24 | s3689+  s3691 :: SWord8 = s26 & s3689+  s3692 :: SWord8 = if s3688 then s3690 else s3691+  s3693 :: SWord8 = s3692 >>> 1+  s3694 :: SWord8 = s24 | s3693+  s3695 :: SWord8 = s26 & s3693+  s3696 :: SWord8 = if s3684 then s3694 else s3695+  s3697 :: SWord8 = s3682 >>> 1+  s3698 :: SWord8 = s24 | s3697+  s3699 :: SWord8 = s26 & s3697+  s3700 :: SWord8 = if s3660 then s3698 else s3699+  s3701 :: SWord8 = if s29 then s3681 else s3666+  s3702 :: SWord8 = if s170 then s3700 else s3701+  s3703 :: SWord8 = s3692 + s3702+  s3704 :: SBool = s3703 < s3702+  s3705 :: SBool = s3703 < s3692+  s3706 :: SBool = s3704 | s3705+  s3707 :: SWord8 = s3703 >>> 1+  s3708 :: SWord8 = s24 | s3707+  s3709 :: SWord8 = s26 & s3707+  s3710 :: SWord8 = if s3706 then s3708 else s3709+  s3711 :: SWord8 = if s3685 then s3696 else s3710+  s3712 :: SWord8 = if s3628 then s3677 else s3711+  s3713 :: SWord8 = if s3513 then s3620 else s3712+  s3714 :: SWord8 = if s3282 then s3505 else s3713+  s3715 :: SWord8 = if s2819 then s3274 else s3714+  s3716 :: SWord8 = if s1892 then s2811 else s3715+  s3717 :: SWord8 = if s38 then s1884 else s3716+  s3718 :: SWord8 = s18 & s178+  s3719 :: SBool = s17 /= s3718+  s3720 :: SWord8 = s24 | s33+  s3721 :: SWord8 = if s3719 then s3720 else s34+  s3722 :: SWord8 = if s22 then s3721 else s28+  s3723 :: SWord8 = s18 & s3722+  s3724 :: SBool = s17 /= s3723+  s3725 :: SBool = s_2 == s3724+  s3726 :: SWord8 = s178 >>> 1+  s3727 :: SWord8 = s26 & s3726+  s3728 :: SWord8 = s18 & s3727+  s3729 :: SBool = s17 /= s3728+  s3730 :: SWord8 = s3722 >>> 1+  s3731 :: SWord8 = s24 | s3730+  s3732 :: SWord8 = s26 & s3730+  s3733 :: SWord8 = if s43 then s3731 else s3732+  s3734 :: SWord8 = if s22 then s3733 else s3721+  s3735 :: SWord8 = s3734 >>> 1+  s3736 :: SWord8 = s24 | s3735+  s3737 :: SWord8 = s26 & s3735+  s3738 :: SWord8 = if s3729 then s3736 else s3737+  s3739 :: SWord8 = if s22 then s3738 else s3733+  s3740 :: SWord8 = s18 & s3739+  s3741 :: SBool = s17 /= s3740+  s3742 :: SBool = s_2 == s3741+  s3743 :: SWord8 = s3727 >>> 1+  s3744 :: SWord8 = s24 | s3743+  s3745 :: SWord8 = s26 & s3743+  s3746 :: SWord8 = if s3724 then s3744 else s3745+  s3747 :: SWord8 = s18 & s3746+  s3748 :: SBool = s17 /= s3747+  s3749 :: SWord8 = s18 & s3734+  s3750 :: SBool = s17 /= s3749+  s3751 :: SWord8 = s3739 >>> 1+  s3752 :: SWord8 = s24 | s3751+  s3753 :: SWord8 = s26 & s3751+  s3754 :: SWord8 = if s3750 then s3752 else s3753+  s3755 :: SWord8 = if s22 then s3754 else s3738+  s3756 :: SWord8 = s3755 >>> 1+  s3757 :: SWord8 = s24 | s3756+  s3758 :: SWord8 = s26 & s3756+  s3759 :: SWord8 = if s3748 then s3757 else s3758+  s3760 :: SWord8 = if s22 then s3759 else s3754+  s3761 :: SWord8 = s18 & s3760+  s3762 :: SBool = s17 /= s3761+  s3763 :: SBool = s_2 == s3762+  s3764 :: SWord8 = s3746 >>> 1+  s3765 :: SWord8 = s24 | s3764+  s3766 :: SWord8 = s26 & s3764+  s3767 :: SWord8 = if s3741 then s3765 else s3766+  s3768 :: SWord8 = s18 & s3767+  s3769 :: SBool = s17 /= s3768+  s3770 :: SWord8 = s18 & s3755+  s3771 :: SBool = s17 /= s3770+  s3772 :: SWord8 = s3760 >>> 1+  s3773 :: SWord8 = s24 | s3772+  s3774 :: SWord8 = s26 & s3772+  s3775 :: SWord8 = if s3771 then s3773 else s3774+  s3776 :: SWord8 = if s22 then s3775 else s3759+  s3777 :: SWord8 = s3776 >>> 1+  s3778 :: SWord8 = s24 | s3777+  s3779 :: SWord8 = s26 & s3777+  s3780 :: SWord8 = if s3769 then s3778 else s3779+  s3781 :: SWord8 = if s22 then s3780 else s3775+  s3782 :: SWord8 = s18 & s3781+  s3783 :: SBool = s17 /= s3782+  s3784 :: SBool = s_2 == s3783+  s3785 :: SWord8 = s3767 >>> 1+  s3786 :: SWord8 = s24 | s3785+  s3787 :: SWord8 = s26 & s3785+  s3788 :: SWord8 = if s3762 then s3786 else s3787+  s3789 :: SWord8 = s18 & s3788+  s3790 :: SBool = s17 /= s3789+  s3791 :: SWord8 = s18 & s3776+  s3792 :: SBool = s17 /= s3791+  s3793 :: SWord8 = s3781 >>> 1+  s3794 :: SWord8 = s24 | s3793+  s3795 :: SWord8 = s26 & s3793+  s3796 :: SWord8 = if s3792 then s3794 else s3795+  s3797 :: SWord8 = if s22 then s3796 else s3780+  s3798 :: SWord8 = s3797 >>> 1+  s3799 :: SWord8 = s24 | s3798+  s3800 :: SWord8 = s26 & s3798+  s3801 :: SWord8 = if s3790 then s3799 else s3800+  s3802 :: SWord8 = if s22 then s3801 else s3796+  s3803 :: SWord8 = s18 & s3802+  s3804 :: SBool = s17 /= s3803+  s3805 :: SBool = s_2 == s3804+  s3806 :: SWord8 = s3788 >>> 1+  s3807 :: SWord8 = s24 | s3806+  s3808 :: SWord8 = s26 & s3806+  s3809 :: SWord8 = if s3783 then s3807 else s3808+  s3810 :: SWord8 = s18 & s3809+  s3811 :: SBool = s17 /= s3810+  s3812 :: SWord8 = s18 & s3797+  s3813 :: SBool = s17 /= s3812+  s3814 :: SWord8 = s3802 >>> 1+  s3815 :: SWord8 = s24 | s3814+  s3816 :: SWord8 = s26 & s3814+  s3817 :: SWord8 = if s3813 then s3815 else s3816+  s3818 :: SWord8 = if s22 then s3817 else s3801+  s3819 :: SWord8 = s3818 >>> 1+  s3820 :: SWord8 = s24 | s3819+  s3821 :: SWord8 = s26 & s3819+  s3822 :: SWord8 = if s3811 then s3820 else s3821+  s3823 :: SWord8 = if s22 then s3822 else s3817+  s3824 :: SWord8 = s18 & s3823+  s3825 :: SBool = s17 /= s3824+  s3826 :: SBool = s_2 == s3825+  s3827 :: SWord8 = s3809 >>> 1+  s3828 :: SWord8 = s24 | s3827+  s3829 :: SWord8 = s26 & s3827+  s3830 :: SWord8 = if s3804 then s3828 else s3829+  s3831 :: SWord8 = s18 & s3830+  s3832 :: SBool = s17 /= s3831+  s3833 :: SWord8 = s18 & s3818+  s3834 :: SBool = s17 /= s3833+  s3835 :: SWord8 = s3823 >>> 1+  s3836 :: SWord8 = s24 | s3835+  s3837 :: SWord8 = s26 & s3835+  s3838 :: SWord8 = if s3834 then s3836 else s3837+  s3839 :: SWord8 = if s22 then s3838 else s3822+  s3840 :: SWord8 = s3839 >>> 1+  s3841 :: SWord8 = s24 | s3840+  s3842 :: SWord8 = s26 & s3840+  s3843 :: SWord8 = if s3832 then s3841 else s3842+  s3844 :: SWord8 = if s22 then s3843 else s3838+  s3845 :: SWord8 = s18 & s3844+  s3846 :: SBool = s17 /= s3845+  s3847 :: SBool = s_2 == s3846+  s3848 :: SWord8 = s3830 >>> 1+  s3849 :: SWord8 = s24 | s3848+  s3850 :: SWord8 = s26 & s3848+  s3851 :: SWord8 = if s3825 then s3849 else s3850+  s3852 :: SWord8 = s3851 >>> 1+  s3853 :: SWord8 = s24 | s3852+  s3854 :: SWord8 = s26 & s3852+  s3855 :: SWord8 = if s3846 then s3853 else s3854+  s3856 :: SWord8 = s18 & s3839+  s3857 :: SBool = s17 /= s3856+  s3858 :: SWord8 = s3844 >>> 1+  s3859 :: SWord8 = s24 | s3858+  s3860 :: SWord8 = s26 & s3858+  s3861 :: SWord8 = if s3857 then s3859 else s3860+  s3862 :: SWord8 = if s29 then s3721 else s178+  s3863 :: SWord8 = if s170 then s3733 else s3862+  s3864 :: SWord8 = if s29 then s3738 else s3863+  s3865 :: SWord8 = if s170 then s3754 else s3864+  s3866 :: SWord8 = if s29 then s3759 else s3865+  s3867 :: SWord8 = if s170 then s3775 else s3866+  s3868 :: SWord8 = if s29 then s3780 else s3867+  s3869 :: SWord8 = if s170 then s3796 else s3868+  s3870 :: SWord8 = if s29 then s3801 else s3869+  s3871 :: SWord8 = if s170 then s3817 else s3870+  s3872 :: SWord8 = if s29 then s3822 else s3871+  s3873 :: SWord8 = if s170 then s3838 else s3872+  s3874 :: SWord8 = if s29 then s3843 else s3873+  s3875 :: SWord8 = if s170 then s3861 else s3874+  s3876 :: SWord8 = s3851 + s3875+  s3877 :: SBool = s3876 < s3875+  s3878 :: SBool = s3876 < s3851+  s3879 :: SBool = s3877 | s3878+  s3880 :: SWord8 = s3876 >>> 1+  s3881 :: SWord8 = s24 | s3880+  s3882 :: SWord8 = s26 & s3880+  s3883 :: SWord8 = if s3879 then s3881 else s3882+  s3884 :: SWord8 = if s3847 then s3855 else s3883+  s3885 :: SWord8 = s3830 + s3873+  s3886 :: SWord8 = s18 & s3885+  s3887 :: SBool = s17 /= s3886+  s3888 :: SWord8 = if s3887 then s3841 else s3842+  s3889 :: SWord8 = if s22 then s3888 else s3838+  s3890 :: SWord8 = s18 & s3889+  s3891 :: SBool = s17 /= s3890+  s3892 :: SBool = s_2 == s3891+  s3893 :: SBool = s3885 < s3873+  s3894 :: SBool = s3885 < s3830+  s3895 :: SBool = s3893 | s3894+  s3896 :: SWord8 = s3885 >>> 1+  s3897 :: SWord8 = s24 | s3896+  s3898 :: SWord8 = s26 & s3896+  s3899 :: SWord8 = if s3895 then s3897 else s3898+  s3900 :: SWord8 = s3899 >>> 1+  s3901 :: SWord8 = s24 | s3900+  s3902 :: SWord8 = s26 & s3900+  s3903 :: SWord8 = if s3891 then s3901 else s3902+  s3904 :: SWord8 = s3889 >>> 1+  s3905 :: SWord8 = s24 | s3904+  s3906 :: SWord8 = s26 & s3904+  s3907 :: SWord8 = if s3857 then s3905 else s3906+  s3908 :: SWord8 = if s29 then s3888 else s3873+  s3909 :: SWord8 = if s170 then s3907 else s3908+  s3910 :: SWord8 = s3899 + s3909+  s3911 :: SBool = s3910 < s3909+  s3912 :: SBool = s3910 < s3899+  s3913 :: SBool = s3911 | s3912+  s3914 :: SWord8 = s3910 >>> 1+  s3915 :: SWord8 = s24 | s3914+  s3916 :: SWord8 = s26 & s3914+  s3917 :: SWord8 = if s3913 then s3915 else s3916+  s3918 :: SWord8 = if s3892 then s3903 else s3917+  s3919 :: SWord8 = if s3826 then s3884 else s3918+  s3920 :: SWord8 = s3809 + s3871+  s3921 :: SWord8 = s18 & s3920+  s3922 :: SBool = s17 /= s3921+  s3923 :: SWord8 = if s3922 then s3820 else s3821+  s3924 :: SWord8 = if s22 then s3923 else s3817+  s3925 :: SWord8 = s18 & s3924+  s3926 :: SBool = s17 /= s3925+  s3927 :: SBool = s_2 == s3926+  s3928 :: SBool = s3920 < s3871+  s3929 :: SBool = s3920 < s3809+  s3930 :: SBool = s3928 | s3929+  s3931 :: SWord8 = s3920 >>> 1+  s3932 :: SWord8 = s24 | s3931+  s3933 :: SWord8 = s26 & s3931+  s3934 :: SWord8 = if s3930 then s3932 else s3933+  s3935 :: SWord8 = s18 & s3934+  s3936 :: SBool = s17 /= s3935+  s3937 :: SWord8 = s3924 >>> 1+  s3938 :: SWord8 = s24 | s3937+  s3939 :: SWord8 = s26 & s3937+  s3940 :: SWord8 = if s3834 then s3938 else s3939+  s3941 :: SWord8 = if s22 then s3940 else s3923+  s3942 :: SWord8 = s3941 >>> 1+  s3943 :: SWord8 = s24 | s3942+  s3944 :: SWord8 = s26 & s3942+  s3945 :: SWord8 = if s3936 then s3943 else s3944+  s3946 :: SWord8 = if s22 then s3945 else s3940+  s3947 :: SWord8 = s18 & s3946+  s3948 :: SBool = s17 /= s3947+  s3949 :: SBool = s_2 == s3948+  s3950 :: SWord8 = s3934 >>> 1+  s3951 :: SWord8 = s24 | s3950+  s3952 :: SWord8 = s26 & s3950+  s3953 :: SWord8 = if s3926 then s3951 else s3952+  s3954 :: SWord8 = s3953 >>> 1+  s3955 :: SWord8 = s24 | s3954+  s3956 :: SWord8 = s26 & s3954+  s3957 :: SWord8 = if s3948 then s3955 else s3956+  s3958 :: SWord8 = s18 & s3941+  s3959 :: SBool = s17 /= s3958+  s3960 :: SWord8 = s3946 >>> 1+  s3961 :: SWord8 = s24 | s3960+  s3962 :: SWord8 = s26 & s3960+  s3963 :: SWord8 = if s3959 then s3961 else s3962+  s3964 :: SWord8 = if s29 then s3923 else s3871+  s3965 :: SWord8 = if s170 then s3940 else s3964+  s3966 :: SWord8 = if s29 then s3945 else s3965+  s3967 :: SWord8 = if s170 then s3963 else s3966+  s3968 :: SWord8 = s3953 + s3967+  s3969 :: SBool = s3968 < s3967+  s3970 :: SBool = s3968 < s3953+  s3971 :: SBool = s3969 | s3970+  s3972 :: SWord8 = s3968 >>> 1+  s3973 :: SWord8 = s24 | s3972+  s3974 :: SWord8 = s26 & s3972+  s3975 :: SWord8 = if s3971 then s3973 else s3974+  s3976 :: SWord8 = if s3949 then s3957 else s3975+  s3977 :: SWord8 = s3934 + s3965+  s3978 :: SWord8 = s18 & s3977+  s3979 :: SBool = s17 /= s3978+  s3980 :: SWord8 = if s3979 then s3943 else s3944+  s3981 :: SWord8 = if s22 then s3980 else s3940+  s3982 :: SWord8 = s18 & s3981+  s3983 :: SBool = s17 /= s3982+  s3984 :: SBool = s_2 == s3983+  s3985 :: SBool = s3977 < s3965+  s3986 :: SBool = s3977 < s3934+  s3987 :: SBool = s3985 | s3986+  s3988 :: SWord8 = s3977 >>> 1+  s3989 :: SWord8 = s24 | s3988+  s3990 :: SWord8 = s26 & s3988+  s3991 :: SWord8 = if s3987 then s3989 else s3990+  s3992 :: SWord8 = s3991 >>> 1+  s3993 :: SWord8 = s24 | s3992+  s3994 :: SWord8 = s26 & s3992+  s3995 :: SWord8 = if s3983 then s3993 else s3994+  s3996 :: SWord8 = s3981 >>> 1+  s3997 :: SWord8 = s24 | s3996+  s3998 :: SWord8 = s26 & s3996+  s3999 :: SWord8 = if s3959 then s3997 else s3998+  s4000 :: SWord8 = if s29 then s3980 else s3965+  s4001 :: SWord8 = if s170 then s3999 else s4000+  s4002 :: SWord8 = s3991 + s4001+  s4003 :: SBool = s4002 < s4001+  s4004 :: SBool = s4002 < s3991+  s4005 :: SBool = s4003 | s4004+  s4006 :: SWord8 = s4002 >>> 1+  s4007 :: SWord8 = s24 | s4006+  s4008 :: SWord8 = s26 & s4006+  s4009 :: SWord8 = if s4005 then s4007 else s4008+  s4010 :: SWord8 = if s3984 then s3995 else s4009+  s4011 :: SWord8 = if s3927 then s3976 else s4010+  s4012 :: SWord8 = if s3805 then s3919 else s4011+  s4013 :: SWord8 = s3788 + s3869+  s4014 :: SWord8 = s18 & s4013+  s4015 :: SBool = s17 /= s4014+  s4016 :: SWord8 = if s4015 then s3799 else s3800+  s4017 :: SWord8 = if s22 then s4016 else s3796+  s4018 :: SWord8 = s18 & s4017+  s4019 :: SBool = s17 /= s4018+  s4020 :: SBool = s_2 == s4019+  s4021 :: SBool = s4013 < s3869+  s4022 :: SBool = s4013 < s3788+  s4023 :: SBool = s4021 | s4022+  s4024 :: SWord8 = s4013 >>> 1+  s4025 :: SWord8 = s24 | s4024+  s4026 :: SWord8 = s26 & s4024+  s4027 :: SWord8 = if s4023 then s4025 else s4026+  s4028 :: SWord8 = s18 & s4027+  s4029 :: SBool = s17 /= s4028+  s4030 :: SWord8 = s4017 >>> 1+  s4031 :: SWord8 = s24 | s4030+  s4032 :: SWord8 = s26 & s4030+  s4033 :: SWord8 = if s3813 then s4031 else s4032+  s4034 :: SWord8 = if s22 then s4033 else s4016+  s4035 :: SWord8 = s4034 >>> 1+  s4036 :: SWord8 = s24 | s4035+  s4037 :: SWord8 = s26 & s4035+  s4038 :: SWord8 = if s4029 then s4036 else s4037+  s4039 :: SWord8 = if s22 then s4038 else s4033+  s4040 :: SWord8 = s18 & s4039+  s4041 :: SBool = s17 /= s4040+  s4042 :: SBool = s_2 == s4041+  s4043 :: SWord8 = s4027 >>> 1+  s4044 :: SWord8 = s24 | s4043+  s4045 :: SWord8 = s26 & s4043+  s4046 :: SWord8 = if s4019 then s4044 else s4045+  s4047 :: SWord8 = s18 & s4046+  s4048 :: SBool = s17 /= s4047+  s4049 :: SWord8 = s18 & s4034+  s4050 :: SBool = s17 /= s4049+  s4051 :: SWord8 = s4039 >>> 1+  s4052 :: SWord8 = s24 | s4051+  s4053 :: SWord8 = s26 & s4051+  s4054 :: SWord8 = if s4050 then s4052 else s4053+  s4055 :: SWord8 = if s22 then s4054 else s4038+  s4056 :: SWord8 = s4055 >>> 1+  s4057 :: SWord8 = s24 | s4056+  s4058 :: SWord8 = s26 & s4056+  s4059 :: SWord8 = if s4048 then s4057 else s4058+  s4060 :: SWord8 = if s22 then s4059 else s4054+  s4061 :: SWord8 = s18 & s4060+  s4062 :: SBool = s17 /= s4061+  s4063 :: SBool = s_2 == s4062+  s4064 :: SWord8 = s4046 >>> 1+  s4065 :: SWord8 = s24 | s4064+  s4066 :: SWord8 = s26 & s4064+  s4067 :: SWord8 = if s4041 then s4065 else s4066+  s4068 :: SWord8 = s4067 >>> 1+  s4069 :: SWord8 = s24 | s4068+  s4070 :: SWord8 = s26 & s4068+  s4071 :: SWord8 = if s4062 then s4069 else s4070+  s4072 :: SWord8 = s18 & s4055+  s4073 :: SBool = s17 /= s4072+  s4074 :: SWord8 = s4060 >>> 1+  s4075 :: SWord8 = s24 | s4074+  s4076 :: SWord8 = s26 & s4074+  s4077 :: SWord8 = if s4073 then s4075 else s4076+  s4078 :: SWord8 = if s29 then s4016 else s3869+  s4079 :: SWord8 = if s170 then s4033 else s4078+  s4080 :: SWord8 = if s29 then s4038 else s4079+  s4081 :: SWord8 = if s170 then s4054 else s4080+  s4082 :: SWord8 = if s29 then s4059 else s4081+  s4083 :: SWord8 = if s170 then s4077 else s4082+  s4084 :: SWord8 = s4067 + s4083+  s4085 :: SBool = s4084 < s4083+  s4086 :: SBool = s4084 < s4067+  s4087 :: SBool = s4085 | s4086+  s4088 :: SWord8 = s4084 >>> 1+  s4089 :: SWord8 = s24 | s4088+  s4090 :: SWord8 = s26 & s4088+  s4091 :: SWord8 = if s4087 then s4089 else s4090+  s4092 :: SWord8 = if s4063 then s4071 else s4091+  s4093 :: SWord8 = s4046 + s4081+  s4094 :: SWord8 = s18 & s4093+  s4095 :: SBool = s17 /= s4094+  s4096 :: SWord8 = if s4095 then s4057 else s4058+  s4097 :: SWord8 = if s22 then s4096 else s4054+  s4098 :: SWord8 = s18 & s4097+  s4099 :: SBool = s17 /= s4098+  s4100 :: SBool = s_2 == s4099+  s4101 :: SBool = s4093 < s4081+  s4102 :: SBool = s4093 < s4046+  s4103 :: SBool = s4101 | s4102+  s4104 :: SWord8 = s4093 >>> 1+  s4105 :: SWord8 = s24 | s4104+  s4106 :: SWord8 = s26 & s4104+  s4107 :: SWord8 = if s4103 then s4105 else s4106+  s4108 :: SWord8 = s4107 >>> 1+  s4109 :: SWord8 = s24 | s4108+  s4110 :: SWord8 = s26 & s4108+  s4111 :: SWord8 = if s4099 then s4109 else s4110+  s4112 :: SWord8 = s4097 >>> 1+  s4113 :: SWord8 = s24 | s4112+  s4114 :: SWord8 = s26 & s4112+  s4115 :: SWord8 = if s4073 then s4113 else s4114+  s4116 :: SWord8 = if s29 then s4096 else s4081+  s4117 :: SWord8 = if s170 then s4115 else s4116+  s4118 :: SWord8 = s4107 + s4117+  s4119 :: SBool = s4118 < s4117+  s4120 :: SBool = s4118 < s4107+  s4121 :: SBool = s4119 | s4120+  s4122 :: SWord8 = s4118 >>> 1+  s4123 :: SWord8 = s24 | s4122+  s4124 :: SWord8 = s26 & s4122+  s4125 :: SWord8 = if s4121 then s4123 else s4124+  s4126 :: SWord8 = if s4100 then s4111 else s4125+  s4127 :: SWord8 = if s4042 then s4092 else s4126+  s4128 :: SWord8 = s4027 + s4079+  s4129 :: SWord8 = s18 & s4128+  s4130 :: SBool = s17 /= s4129+  s4131 :: SWord8 = if s4130 then s4036 else s4037+  s4132 :: SWord8 = if s22 then s4131 else s4033+  s4133 :: SWord8 = s18 & s4132+  s4134 :: SBool = s17 /= s4133+  s4135 :: SBool = s_2 == s4134+  s4136 :: SBool = s4128 < s4079+  s4137 :: SBool = s4128 < s4027+  s4138 :: SBool = s4136 | s4137+  s4139 :: SWord8 = s4128 >>> 1+  s4140 :: SWord8 = s24 | s4139+  s4141 :: SWord8 = s26 & s4139+  s4142 :: SWord8 = if s4138 then s4140 else s4141+  s4143 :: SWord8 = s18 & s4142+  s4144 :: SBool = s17 /= s4143+  s4145 :: SWord8 = s4132 >>> 1+  s4146 :: SWord8 = s24 | s4145+  s4147 :: SWord8 = s26 & s4145+  s4148 :: SWord8 = if s4050 then s4146 else s4147+  s4149 :: SWord8 = if s22 then s4148 else s4131+  s4150 :: SWord8 = s4149 >>> 1+  s4151 :: SWord8 = s24 | s4150+  s4152 :: SWord8 = s26 & s4150+  s4153 :: SWord8 = if s4144 then s4151 else s4152+  s4154 :: SWord8 = if s22 then s4153 else s4148+  s4155 :: SWord8 = s18 & s4154+  s4156 :: SBool = s17 /= s4155+  s4157 :: SBool = s_2 == s4156+  s4158 :: SWord8 = s4142 >>> 1+  s4159 :: SWord8 = s24 | s4158+  s4160 :: SWord8 = s26 & s4158+  s4161 :: SWord8 = if s4134 then s4159 else s4160+  s4162 :: SWord8 = s4161 >>> 1+  s4163 :: SWord8 = s24 | s4162+  s4164 :: SWord8 = s26 & s4162+  s4165 :: SWord8 = if s4156 then s4163 else s4164+  s4166 :: SWord8 = s18 & s4149+  s4167 :: SBool = s17 /= s4166+  s4168 :: SWord8 = s4154 >>> 1+  s4169 :: SWord8 = s24 | s4168+  s4170 :: SWord8 = s26 & s4168+  s4171 :: SWord8 = if s4167 then s4169 else s4170+  s4172 :: SWord8 = if s29 then s4131 else s4079+  s4173 :: SWord8 = if s170 then s4148 else s4172+  s4174 :: SWord8 = if s29 then s4153 else s4173+  s4175 :: SWord8 = if s170 then s4171 else s4174+  s4176 :: SWord8 = s4161 + s4175+  s4177 :: SBool = s4176 < s4175+  s4178 :: SBool = s4176 < s4161+  s4179 :: SBool = s4177 | s4178+  s4180 :: SWord8 = s4176 >>> 1+  s4181 :: SWord8 = s24 | s4180+  s4182 :: SWord8 = s26 & s4180+  s4183 :: SWord8 = if s4179 then s4181 else s4182+  s4184 :: SWord8 = if s4157 then s4165 else s4183+  s4185 :: SWord8 = s4142 + s4173+  s4186 :: SWord8 = s18 & s4185+  s4187 :: SBool = s17 /= s4186+  s4188 :: SWord8 = if s4187 then s4151 else s4152+  s4189 :: SWord8 = if s22 then s4188 else s4148+  s4190 :: SWord8 = s18 & s4189+  s4191 :: SBool = s17 /= s4190+  s4192 :: SBool = s_2 == s4191+  s4193 :: SBool = s4185 < s4173+  s4194 :: SBool = s4185 < s4142+  s4195 :: SBool = s4193 | s4194+  s4196 :: SWord8 = s4185 >>> 1+  s4197 :: SWord8 = s24 | s4196+  s4198 :: SWord8 = s26 & s4196+  s4199 :: SWord8 = if s4195 then s4197 else s4198+  s4200 :: SWord8 = s4199 >>> 1+  s4201 :: SWord8 = s24 | s4200+  s4202 :: SWord8 = s26 & s4200+  s4203 :: SWord8 = if s4191 then s4201 else s4202+  s4204 :: SWord8 = s4189 >>> 1+  s4205 :: SWord8 = s24 | s4204+  s4206 :: SWord8 = s26 & s4204+  s4207 :: SWord8 = if s4167 then s4205 else s4206+  s4208 :: SWord8 = if s29 then s4188 else s4173+  s4209 :: SWord8 = if s170 then s4207 else s4208+  s4210 :: SWord8 = s4199 + s4209+  s4211 :: SBool = s4210 < s4209+  s4212 :: SBool = s4210 < s4199+  s4213 :: SBool = s4211 | s4212+  s4214 :: SWord8 = s4210 >>> 1+  s4215 :: SWord8 = s24 | s4214+  s4216 :: SWord8 = s26 & s4214+  s4217 :: SWord8 = if s4213 then s4215 else s4216+  s4218 :: SWord8 = if s4192 then s4203 else s4217+  s4219 :: SWord8 = if s4135 then s4184 else s4218+  s4220 :: SWord8 = if s4020 then s4127 else s4219+  s4221 :: SWord8 = if s3784 then s4012 else s4220+  s4222 :: SWord8 = s3767 + s3867+  s4223 :: SWord8 = s18 & s4222+  s4224 :: SBool = s17 /= s4223+  s4225 :: SWord8 = if s4224 then s3778 else s3779+  s4226 :: SWord8 = if s22 then s4225 else s3775+  s4227 :: SWord8 = s18 & s4226+  s4228 :: SBool = s17 /= s4227+  s4229 :: SBool = s_2 == s4228+  s4230 :: SBool = s4222 < s3867+  s4231 :: SBool = s4222 < s3767+  s4232 :: SBool = s4230 | s4231+  s4233 :: SWord8 = s4222 >>> 1+  s4234 :: SWord8 = s24 | s4233+  s4235 :: SWord8 = s26 & s4233+  s4236 :: SWord8 = if s4232 then s4234 else s4235+  s4237 :: SWord8 = s18 & s4236+  s4238 :: SBool = s17 /= s4237+  s4239 :: SWord8 = s4226 >>> 1+  s4240 :: SWord8 = s24 | s4239+  s4241 :: SWord8 = s26 & s4239+  s4242 :: SWord8 = if s3792 then s4240 else s4241+  s4243 :: SWord8 = if s22 then s4242 else s4225+  s4244 :: SWord8 = s4243 >>> 1+  s4245 :: SWord8 = s24 | s4244+  s4246 :: SWord8 = s26 & s4244+  s4247 :: SWord8 = if s4238 then s4245 else s4246+  s4248 :: SWord8 = if s22 then s4247 else s4242+  s4249 :: SWord8 = s18 & s4248+  s4250 :: SBool = s17 /= s4249+  s4251 :: SBool = s_2 == s4250+  s4252 :: SWord8 = s4236 >>> 1+  s4253 :: SWord8 = s24 | s4252+  s4254 :: SWord8 = s26 & s4252+  s4255 :: SWord8 = if s4228 then s4253 else s4254+  s4256 :: SWord8 = s18 & s4255+  s4257 :: SBool = s17 /= s4256+  s4258 :: SWord8 = s18 & s4243+  s4259 :: SBool = s17 /= s4258+  s4260 :: SWord8 = s4248 >>> 1+  s4261 :: SWord8 = s24 | s4260+  s4262 :: SWord8 = s26 & s4260+  s4263 :: SWord8 = if s4259 then s4261 else s4262+  s4264 :: SWord8 = if s22 then s4263 else s4247+  s4265 :: SWord8 = s4264 >>> 1+  s4266 :: SWord8 = s24 | s4265+  s4267 :: SWord8 = s26 & s4265+  s4268 :: SWord8 = if s4257 then s4266 else s4267+  s4269 :: SWord8 = if s22 then s4268 else s4263+  s4270 :: SWord8 = s18 & s4269+  s4271 :: SBool = s17 /= s4270+  s4272 :: SBool = s_2 == s4271+  s4273 :: SWord8 = s4255 >>> 1+  s4274 :: SWord8 = s24 | s4273+  s4275 :: SWord8 = s26 & s4273+  s4276 :: SWord8 = if s4250 then s4274 else s4275+  s4277 :: SWord8 = s18 & s4276+  s4278 :: SBool = s17 /= s4277+  s4279 :: SWord8 = s18 & s4264+  s4280 :: SBool = s17 /= s4279+  s4281 :: SWord8 = s4269 >>> 1+  s4282 :: SWord8 = s24 | s4281+  s4283 :: SWord8 = s26 & s4281+  s4284 :: SWord8 = if s4280 then s4282 else s4283+  s4285 :: SWord8 = if s22 then s4284 else s4268+  s4286 :: SWord8 = s4285 >>> 1+  s4287 :: SWord8 = s24 | s4286+  s4288 :: SWord8 = s26 & s4286+  s4289 :: SWord8 = if s4278 then s4287 else s4288+  s4290 :: SWord8 = if s22 then s4289 else s4284+  s4291 :: SWord8 = s18 & s4290+  s4292 :: SBool = s17 /= s4291+  s4293 :: SBool = s_2 == s4292+  s4294 :: SWord8 = s4276 >>> 1+  s4295 :: SWord8 = s24 | s4294+  s4296 :: SWord8 = s26 & s4294+  s4297 :: SWord8 = if s4271 then s4295 else s4296+  s4298 :: SWord8 = s4297 >>> 1+  s4299 :: SWord8 = s24 | s4298+  s4300 :: SWord8 = s26 & s4298+  s4301 :: SWord8 = if s4292 then s4299 else s4300+  s4302 :: SWord8 = s18 & s4285+  s4303 :: SBool = s17 /= s4302+  s4304 :: SWord8 = s4290 >>> 1+  s4305 :: SWord8 = s24 | s4304+  s4306 :: SWord8 = s26 & s4304+  s4307 :: SWord8 = if s4303 then s4305 else s4306+  s4308 :: SWord8 = if s29 then s4225 else s3867+  s4309 :: SWord8 = if s170 then s4242 else s4308+  s4310 :: SWord8 = if s29 then s4247 else s4309+  s4311 :: SWord8 = if s170 then s4263 else s4310+  s4312 :: SWord8 = if s29 then s4268 else s4311+  s4313 :: SWord8 = if s170 then s4284 else s4312+  s4314 :: SWord8 = if s29 then s4289 else s4313+  s4315 :: SWord8 = if s170 then s4307 else s4314+  s4316 :: SWord8 = s4297 + s4315+  s4317 :: SBool = s4316 < s4315+  s4318 :: SBool = s4316 < s4297+  s4319 :: SBool = s4317 | s4318+  s4320 :: SWord8 = s4316 >>> 1+  s4321 :: SWord8 = s24 | s4320+  s4322 :: SWord8 = s26 & s4320+  s4323 :: SWord8 = if s4319 then s4321 else s4322+  s4324 :: SWord8 = if s4293 then s4301 else s4323+  s4325 :: SWord8 = s4276 + s4313+  s4326 :: SWord8 = s18 & s4325+  s4327 :: SBool = s17 /= s4326+  s4328 :: SWord8 = if s4327 then s4287 else s4288+  s4329 :: SWord8 = if s22 then s4328 else s4284+  s4330 :: SWord8 = s18 & s4329+  s4331 :: SBool = s17 /= s4330+  s4332 :: SBool = s_2 == s4331+  s4333 :: SBool = s4325 < s4313+  s4334 :: SBool = s4325 < s4276+  s4335 :: SBool = s4333 | s4334+  s4336 :: SWord8 = s4325 >>> 1+  s4337 :: SWord8 = s24 | s4336+  s4338 :: SWord8 = s26 & s4336+  s4339 :: SWord8 = if s4335 then s4337 else s4338+  s4340 :: SWord8 = s4339 >>> 1+  s4341 :: SWord8 = s24 | s4340+  s4342 :: SWord8 = s26 & s4340+  s4343 :: SWord8 = if s4331 then s4341 else s4342+  s4344 :: SWord8 = s4329 >>> 1+  s4345 :: SWord8 = s24 | s4344+  s4346 :: SWord8 = s26 & s4344+  s4347 :: SWord8 = if s4303 then s4345 else s4346+  s4348 :: SWord8 = if s29 then s4328 else s4313+  s4349 :: SWord8 = if s170 then s4347 else s4348+  s4350 :: SWord8 = s4339 + s4349+  s4351 :: SBool = s4350 < s4349+  s4352 :: SBool = s4350 < s4339+  s4353 :: SBool = s4351 | s4352+  s4354 :: SWord8 = s4350 >>> 1+  s4355 :: SWord8 = s24 | s4354+  s4356 :: SWord8 = s26 & s4354+  s4357 :: SWord8 = if s4353 then s4355 else s4356+  s4358 :: SWord8 = if s4332 then s4343 else s4357+  s4359 :: SWord8 = if s4272 then s4324 else s4358+  s4360 :: SWord8 = s4255 + s4311+  s4361 :: SWord8 = s18 & s4360+  s4362 :: SBool = s17 /= s4361+  s4363 :: SWord8 = if s4362 then s4266 else s4267+  s4364 :: SWord8 = if s22 then s4363 else s4263+  s4365 :: SWord8 = s18 & s4364+  s4366 :: SBool = s17 /= s4365+  s4367 :: SBool = s_2 == s4366+  s4368 :: SBool = s4360 < s4311+  s4369 :: SBool = s4360 < s4255+  s4370 :: SBool = s4368 | s4369+  s4371 :: SWord8 = s4360 >>> 1+  s4372 :: SWord8 = s24 | s4371+  s4373 :: SWord8 = s26 & s4371+  s4374 :: SWord8 = if s4370 then s4372 else s4373+  s4375 :: SWord8 = s18 & s4374+  s4376 :: SBool = s17 /= s4375+  s4377 :: SWord8 = s4364 >>> 1+  s4378 :: SWord8 = s24 | s4377+  s4379 :: SWord8 = s26 & s4377+  s4380 :: SWord8 = if s4280 then s4378 else s4379+  s4381 :: SWord8 = if s22 then s4380 else s4363+  s4382 :: SWord8 = s4381 >>> 1+  s4383 :: SWord8 = s24 | s4382+  s4384 :: SWord8 = s26 & s4382+  s4385 :: SWord8 = if s4376 then s4383 else s4384+  s4386 :: SWord8 = if s22 then s4385 else s4380+  s4387 :: SWord8 = s18 & s4386+  s4388 :: SBool = s17 /= s4387+  s4389 :: SBool = s_2 == s4388+  s4390 :: SWord8 = s4374 >>> 1+  s4391 :: SWord8 = s24 | s4390+  s4392 :: SWord8 = s26 & s4390+  s4393 :: SWord8 = if s4366 then s4391 else s4392+  s4394 :: SWord8 = s4393 >>> 1+  s4395 :: SWord8 = s24 | s4394+  s4396 :: SWord8 = s26 & s4394+  s4397 :: SWord8 = if s4388 then s4395 else s4396+  s4398 :: SWord8 = s18 & s4381+  s4399 :: SBool = s17 /= s4398+  s4400 :: SWord8 = s4386 >>> 1+  s4401 :: SWord8 = s24 | s4400+  s4402 :: SWord8 = s26 & s4400+  s4403 :: SWord8 = if s4399 then s4401 else s4402+  s4404 :: SWord8 = if s29 then s4363 else s4311+  s4405 :: SWord8 = if s170 then s4380 else s4404+  s4406 :: SWord8 = if s29 then s4385 else s4405+  s4407 :: SWord8 = if s170 then s4403 else s4406+  s4408 :: SWord8 = s4393 + s4407+  s4409 :: SBool = s4408 < s4407+  s4410 :: SBool = s4408 < s4393+  s4411 :: SBool = s4409 | s4410+  s4412 :: SWord8 = s4408 >>> 1+  s4413 :: SWord8 = s24 | s4412+  s4414 :: SWord8 = s26 & s4412+  s4415 :: SWord8 = if s4411 then s4413 else s4414+  s4416 :: SWord8 = if s4389 then s4397 else s4415+  s4417 :: SWord8 = s4374 + s4405+  s4418 :: SWord8 = s18 & s4417+  s4419 :: SBool = s17 /= s4418+  s4420 :: SWord8 = if s4419 then s4383 else s4384+  s4421 :: SWord8 = if s22 then s4420 else s4380+  s4422 :: SWord8 = s18 & s4421+  s4423 :: SBool = s17 /= s4422+  s4424 :: SBool = s_2 == s4423+  s4425 :: SBool = s4417 < s4405+  s4426 :: SBool = s4417 < s4374+  s4427 :: SBool = s4425 | s4426+  s4428 :: SWord8 = s4417 >>> 1+  s4429 :: SWord8 = s24 | s4428+  s4430 :: SWord8 = s26 & s4428+  s4431 :: SWord8 = if s4427 then s4429 else s4430+  s4432 :: SWord8 = s4431 >>> 1+  s4433 :: SWord8 = s24 | s4432+  s4434 :: SWord8 = s26 & s4432+  s4435 :: SWord8 = if s4423 then s4433 else s4434+  s4436 :: SWord8 = s4421 >>> 1+  s4437 :: SWord8 = s24 | s4436+  s4438 :: SWord8 = s26 & s4436+  s4439 :: SWord8 = if s4399 then s4437 else s4438+  s4440 :: SWord8 = if s29 then s4420 else s4405+  s4441 :: SWord8 = if s170 then s4439 else s4440+  s4442 :: SWord8 = s4431 + s4441+  s4443 :: SBool = s4442 < s4441+  s4444 :: SBool = s4442 < s4431+  s4445 :: SBool = s4443 | s4444+  s4446 :: SWord8 = s4442 >>> 1+  s4447 :: SWord8 = s24 | s4446+  s4448 :: SWord8 = s26 & s4446+  s4449 :: SWord8 = if s4445 then s4447 else s4448+  s4450 :: SWord8 = if s4424 then s4435 else s4449+  s4451 :: SWord8 = if s4367 then s4416 else s4450+  s4452 :: SWord8 = if s4251 then s4359 else s4451+  s4453 :: SWord8 = s4236 + s4309+  s4454 :: SWord8 = s18 & s4453+  s4455 :: SBool = s17 /= s4454+  s4456 :: SWord8 = if s4455 then s4245 else s4246+  s4457 :: SWord8 = if s22 then s4456 else s4242+  s4458 :: SWord8 = s18 & s4457+  s4459 :: SBool = s17 /= s4458+  s4460 :: SBool = s_2 == s4459+  s4461 :: SBool = s4453 < s4309+  s4462 :: SBool = s4453 < s4236+  s4463 :: SBool = s4461 | s4462+  s4464 :: SWord8 = s4453 >>> 1+  s4465 :: SWord8 = s24 | s4464+  s4466 :: SWord8 = s26 & s4464+  s4467 :: SWord8 = if s4463 then s4465 else s4466+  s4468 :: SWord8 = s18 & s4467+  s4469 :: SBool = s17 /= s4468+  s4470 :: SWord8 = s4457 >>> 1+  s4471 :: SWord8 = s24 | s4470+  s4472 :: SWord8 = s26 & s4470+  s4473 :: SWord8 = if s4259 then s4471 else s4472+  s4474 :: SWord8 = if s22 then s4473 else s4456+  s4475 :: SWord8 = s4474 >>> 1+  s4476 :: SWord8 = s24 | s4475+  s4477 :: SWord8 = s26 & s4475+  s4478 :: SWord8 = if s4469 then s4476 else s4477+  s4479 :: SWord8 = if s22 then s4478 else s4473+  s4480 :: SWord8 = s18 & s4479+  s4481 :: SBool = s17 /= s4480+  s4482 :: SBool = s_2 == s4481+  s4483 :: SWord8 = s4467 >>> 1+  s4484 :: SWord8 = s24 | s4483+  s4485 :: SWord8 = s26 & s4483+  s4486 :: SWord8 = if s4459 then s4484 else s4485+  s4487 :: SWord8 = s18 & s4486+  s4488 :: SBool = s17 /= s4487+  s4489 :: SWord8 = s18 & s4474+  s4490 :: SBool = s17 /= s4489+  s4491 :: SWord8 = s4479 >>> 1+  s4492 :: SWord8 = s24 | s4491+  s4493 :: SWord8 = s26 & s4491+  s4494 :: SWord8 = if s4490 then s4492 else s4493+  s4495 :: SWord8 = if s22 then s4494 else s4478+  s4496 :: SWord8 = s4495 >>> 1+  s4497 :: SWord8 = s24 | s4496+  s4498 :: SWord8 = s26 & s4496+  s4499 :: SWord8 = if s4488 then s4497 else s4498+  s4500 :: SWord8 = if s22 then s4499 else s4494+  s4501 :: SWord8 = s18 & s4500+  s4502 :: SBool = s17 /= s4501+  s4503 :: SBool = s_2 == s4502+  s4504 :: SWord8 = s4486 >>> 1+  s4505 :: SWord8 = s24 | s4504+  s4506 :: SWord8 = s26 & s4504+  s4507 :: SWord8 = if s4481 then s4505 else s4506+  s4508 :: SWord8 = s4507 >>> 1+  s4509 :: SWord8 = s24 | s4508+  s4510 :: SWord8 = s26 & s4508+  s4511 :: SWord8 = if s4502 then s4509 else s4510+  s4512 :: SWord8 = s18 & s4495+  s4513 :: SBool = s17 /= s4512+  s4514 :: SWord8 = s4500 >>> 1+  s4515 :: SWord8 = s24 | s4514+  s4516 :: SWord8 = s26 & s4514+  s4517 :: SWord8 = if s4513 then s4515 else s4516+  s4518 :: SWord8 = if s29 then s4456 else s4309+  s4519 :: SWord8 = if s170 then s4473 else s4518+  s4520 :: SWord8 = if s29 then s4478 else s4519+  s4521 :: SWord8 = if s170 then s4494 else s4520+  s4522 :: SWord8 = if s29 then s4499 else s4521+  s4523 :: SWord8 = if s170 then s4517 else s4522+  s4524 :: SWord8 = s4507 + s4523+  s4525 :: SBool = s4524 < s4523+  s4526 :: SBool = s4524 < s4507+  s4527 :: SBool = s4525 | s4526+  s4528 :: SWord8 = s4524 >>> 1+  s4529 :: SWord8 = s24 | s4528+  s4530 :: SWord8 = s26 & s4528+  s4531 :: SWord8 = if s4527 then s4529 else s4530+  s4532 :: SWord8 = if s4503 then s4511 else s4531+  s4533 :: SWord8 = s4486 + s4521+  s4534 :: SWord8 = s18 & s4533+  s4535 :: SBool = s17 /= s4534+  s4536 :: SWord8 = if s4535 then s4497 else s4498+  s4537 :: SWord8 = if s22 then s4536 else s4494+  s4538 :: SWord8 = s18 & s4537+  s4539 :: SBool = s17 /= s4538+  s4540 :: SBool = s_2 == s4539+  s4541 :: SBool = s4533 < s4521+  s4542 :: SBool = s4533 < s4486+  s4543 :: SBool = s4541 | s4542+  s4544 :: SWord8 = s4533 >>> 1+  s4545 :: SWord8 = s24 | s4544+  s4546 :: SWord8 = s26 & s4544+  s4547 :: SWord8 = if s4543 then s4545 else s4546+  s4548 :: SWord8 = s4547 >>> 1+  s4549 :: SWord8 = s24 | s4548+  s4550 :: SWord8 = s26 & s4548+  s4551 :: SWord8 = if s4539 then s4549 else s4550+  s4552 :: SWord8 = s4537 >>> 1+  s4553 :: SWord8 = s24 | s4552+  s4554 :: SWord8 = s26 & s4552+  s4555 :: SWord8 = if s4513 then s4553 else s4554+  s4556 :: SWord8 = if s29 then s4536 else s4521+  s4557 :: SWord8 = if s170 then s4555 else s4556+  s4558 :: SWord8 = s4547 + s4557+  s4559 :: SBool = s4558 < s4557+  s4560 :: SBool = s4558 < s4547+  s4561 :: SBool = s4559 | s4560+  s4562 :: SWord8 = s4558 >>> 1+  s4563 :: SWord8 = s24 | s4562+  s4564 :: SWord8 = s26 & s4562+  s4565 :: SWord8 = if s4561 then s4563 else s4564+  s4566 :: SWord8 = if s4540 then s4551 else s4565+  s4567 :: SWord8 = if s4482 then s4532 else s4566+  s4568 :: SWord8 = s4467 + s4519+  s4569 :: SWord8 = s18 & s4568+  s4570 :: SBool = s17 /= s4569+  s4571 :: SWord8 = if s4570 then s4476 else s4477+  s4572 :: SWord8 = if s22 then s4571 else s4473+  s4573 :: SWord8 = s18 & s4572+  s4574 :: SBool = s17 /= s4573+  s4575 :: SBool = s_2 == s4574+  s4576 :: SBool = s4568 < s4519+  s4577 :: SBool = s4568 < s4467+  s4578 :: SBool = s4576 | s4577+  s4579 :: SWord8 = s4568 >>> 1+  s4580 :: SWord8 = s24 | s4579+  s4581 :: SWord8 = s26 & s4579+  s4582 :: SWord8 = if s4578 then s4580 else s4581+  s4583 :: SWord8 = s18 & s4582+  s4584 :: SBool = s17 /= s4583+  s4585 :: SWord8 = s4572 >>> 1+  s4586 :: SWord8 = s24 | s4585+  s4587 :: SWord8 = s26 & s4585+  s4588 :: SWord8 = if s4490 then s4586 else s4587+  s4589 :: SWord8 = if s22 then s4588 else s4571+  s4590 :: SWord8 = s4589 >>> 1+  s4591 :: SWord8 = s24 | s4590+  s4592 :: SWord8 = s26 & s4590+  s4593 :: SWord8 = if s4584 then s4591 else s4592+  s4594 :: SWord8 = if s22 then s4593 else s4588+  s4595 :: SWord8 = s18 & s4594+  s4596 :: SBool = s17 /= s4595+  s4597 :: SBool = s_2 == s4596+  s4598 :: SWord8 = s4582 >>> 1+  s4599 :: SWord8 = s24 | s4598+  s4600 :: SWord8 = s26 & s4598+  s4601 :: SWord8 = if s4574 then s4599 else s4600+  s4602 :: SWord8 = s4601 >>> 1+  s4603 :: SWord8 = s24 | s4602+  s4604 :: SWord8 = s26 & s4602+  s4605 :: SWord8 = if s4596 then s4603 else s4604+  s4606 :: SWord8 = s18 & s4589+  s4607 :: SBool = s17 /= s4606+  s4608 :: SWord8 = s4594 >>> 1+  s4609 :: SWord8 = s24 | s4608+  s4610 :: SWord8 = s26 & s4608+  s4611 :: SWord8 = if s4607 then s4609 else s4610+  s4612 :: SWord8 = if s29 then s4571 else s4519+  s4613 :: SWord8 = if s170 then s4588 else s4612+  s4614 :: SWord8 = if s29 then s4593 else s4613+  s4615 :: SWord8 = if s170 then s4611 else s4614+  s4616 :: SWord8 = s4601 + s4615+  s4617 :: SBool = s4616 < s4615+  s4618 :: SBool = s4616 < s4601+  s4619 :: SBool = s4617 | s4618+  s4620 :: SWord8 = s4616 >>> 1+  s4621 :: SWord8 = s24 | s4620+  s4622 :: SWord8 = s26 & s4620+  s4623 :: SWord8 = if s4619 then s4621 else s4622+  s4624 :: SWord8 = if s4597 then s4605 else s4623+  s4625 :: SWord8 = s4582 + s4613+  s4626 :: SWord8 = s18 & s4625+  s4627 :: SBool = s17 /= s4626+  s4628 :: SWord8 = if s4627 then s4591 else s4592+  s4629 :: SWord8 = if s22 then s4628 else s4588+  s4630 :: SWord8 = s18 & s4629+  s4631 :: SBool = s17 /= s4630+  s4632 :: SBool = s_2 == s4631+  s4633 :: SBool = s4625 < s4613+  s4634 :: SBool = s4625 < s4582+  s4635 :: SBool = s4633 | s4634+  s4636 :: SWord8 = s4625 >>> 1+  s4637 :: SWord8 = s24 | s4636+  s4638 :: SWord8 = s26 & s4636+  s4639 :: SWord8 = if s4635 then s4637 else s4638+  s4640 :: SWord8 = s4639 >>> 1+  s4641 :: SWord8 = s24 | s4640+  s4642 :: SWord8 = s26 & s4640+  s4643 :: SWord8 = if s4631 then s4641 else s4642+  s4644 :: SWord8 = s4629 >>> 1+  s4645 :: SWord8 = s24 | s4644+  s4646 :: SWord8 = s26 & s4644+  s4647 :: SWord8 = if s4607 then s4645 else s4646+  s4648 :: SWord8 = if s29 then s4628 else s4613+  s4649 :: SWord8 = if s170 then s4647 else s4648+  s4650 :: SWord8 = s4639 + s4649+  s4651 :: SBool = s4650 < s4649+  s4652 :: SBool = s4650 < s4639+  s4653 :: SBool = s4651 | s4652+  s4654 :: SWord8 = s4650 >>> 1+  s4655 :: SWord8 = s24 | s4654+  s4656 :: SWord8 = s26 & s4654+  s4657 :: SWord8 = if s4653 then s4655 else s4656+  s4658 :: SWord8 = if s4632 then s4643 else s4657+  s4659 :: SWord8 = if s4575 then s4624 else s4658+  s4660 :: SWord8 = if s4460 then s4567 else s4659+  s4661 :: SWord8 = if s4229 then s4452 else s4660+  s4662 :: SWord8 = if s3763 then s4221 else s4661+  s4663 :: SWord8 = s3746 + s3865+  s4664 :: SWord8 = s18 & s4663+  s4665 :: SBool = s17 /= s4664+  s4666 :: SWord8 = if s4665 then s3757 else s3758+  s4667 :: SWord8 = if s22 then s4666 else s3754+  s4668 :: SWord8 = s18 & s4667+  s4669 :: SBool = s17 /= s4668+  s4670 :: SBool = s_2 == s4669+  s4671 :: SBool = s4663 < s3865+  s4672 :: SBool = s4663 < s3746+  s4673 :: SBool = s4671 | s4672+  s4674 :: SWord8 = s4663 >>> 1+  s4675 :: SWord8 = s24 | s4674+  s4676 :: SWord8 = s26 & s4674+  s4677 :: SWord8 = if s4673 then s4675 else s4676+  s4678 :: SWord8 = s18 & s4677+  s4679 :: SBool = s17 /= s4678+  s4680 :: SWord8 = s4667 >>> 1+  s4681 :: SWord8 = s24 | s4680+  s4682 :: SWord8 = s26 & s4680+  s4683 :: SWord8 = if s3771 then s4681 else s4682+  s4684 :: SWord8 = if s22 then s4683 else s4666+  s4685 :: SWord8 = s4684 >>> 1+  s4686 :: SWord8 = s24 | s4685+  s4687 :: SWord8 = s26 & s4685+  s4688 :: SWord8 = if s4679 then s4686 else s4687+  s4689 :: SWord8 = if s22 then s4688 else s4683+  s4690 :: SWord8 = s18 & s4689+  s4691 :: SBool = s17 /= s4690+  s4692 :: SBool = s_2 == s4691+  s4693 :: SWord8 = s4677 >>> 1+  s4694 :: SWord8 = s24 | s4693+  s4695 :: SWord8 = s26 & s4693+  s4696 :: SWord8 = if s4669 then s4694 else s4695+  s4697 :: SWord8 = s18 & s4696+  s4698 :: SBool = s17 /= s4697+  s4699 :: SWord8 = s18 & s4684+  s4700 :: SBool = s17 /= s4699+  s4701 :: SWord8 = s4689 >>> 1+  s4702 :: SWord8 = s24 | s4701+  s4703 :: SWord8 = s26 & s4701+  s4704 :: SWord8 = if s4700 then s4702 else s4703+  s4705 :: SWord8 = if s22 then s4704 else s4688+  s4706 :: SWord8 = s4705 >>> 1+  s4707 :: SWord8 = s24 | s4706+  s4708 :: SWord8 = s26 & s4706+  s4709 :: SWord8 = if s4698 then s4707 else s4708+  s4710 :: SWord8 = if s22 then s4709 else s4704+  s4711 :: SWord8 = s18 & s4710+  s4712 :: SBool = s17 /= s4711+  s4713 :: SBool = s_2 == s4712+  s4714 :: SWord8 = s4696 >>> 1+  s4715 :: SWord8 = s24 | s4714+  s4716 :: SWord8 = s26 & s4714+  s4717 :: SWord8 = if s4691 then s4715 else s4716+  s4718 :: SWord8 = s18 & s4717+  s4719 :: SBool = s17 /= s4718+  s4720 :: SWord8 = s18 & s4705+  s4721 :: SBool = s17 /= s4720+  s4722 :: SWord8 = s4710 >>> 1+  s4723 :: SWord8 = s24 | s4722+  s4724 :: SWord8 = s26 & s4722+  s4725 :: SWord8 = if s4721 then s4723 else s4724+  s4726 :: SWord8 = if s22 then s4725 else s4709+  s4727 :: SWord8 = s4726 >>> 1+  s4728 :: SWord8 = s24 | s4727+  s4729 :: SWord8 = s26 & s4727+  s4730 :: SWord8 = if s4719 then s4728 else s4729+  s4731 :: SWord8 = if s22 then s4730 else s4725+  s4732 :: SWord8 = s18 & s4731+  s4733 :: SBool = s17 /= s4732+  s4734 :: SBool = s_2 == s4733+  s4735 :: SWord8 = s4717 >>> 1+  s4736 :: SWord8 = s24 | s4735+  s4737 :: SWord8 = s26 & s4735+  s4738 :: SWord8 = if s4712 then s4736 else s4737+  s4739 :: SWord8 = s18 & s4738+  s4740 :: SBool = s17 /= s4739+  s4741 :: SWord8 = s18 & s4726+  s4742 :: SBool = s17 /= s4741+  s4743 :: SWord8 = s4731 >>> 1+  s4744 :: SWord8 = s24 | s4743+  s4745 :: SWord8 = s26 & s4743+  s4746 :: SWord8 = if s4742 then s4744 else s4745+  s4747 :: SWord8 = if s22 then s4746 else s4730+  s4748 :: SWord8 = s4747 >>> 1+  s4749 :: SWord8 = s24 | s4748+  s4750 :: SWord8 = s26 & s4748+  s4751 :: SWord8 = if s4740 then s4749 else s4750+  s4752 :: SWord8 = if s22 then s4751 else s4746+  s4753 :: SWord8 = s18 & s4752+  s4754 :: SBool = s17 /= s4753+  s4755 :: SBool = s_2 == s4754+  s4756 :: SWord8 = s4738 >>> 1+  s4757 :: SWord8 = s24 | s4756+  s4758 :: SWord8 = s26 & s4756+  s4759 :: SWord8 = if s4733 then s4757 else s4758+  s4760 :: SWord8 = s4759 >>> 1+  s4761 :: SWord8 = s24 | s4760+  s4762 :: SWord8 = s26 & s4760+  s4763 :: SWord8 = if s4754 then s4761 else s4762+  s4764 :: SWord8 = s18 & s4747+  s4765 :: SBool = s17 /= s4764+  s4766 :: SWord8 = s4752 >>> 1+  s4767 :: SWord8 = s24 | s4766+  s4768 :: SWord8 = s26 & s4766+  s4769 :: SWord8 = if s4765 then s4767 else s4768+  s4770 :: SWord8 = if s29 then s4666 else s3865+  s4771 :: SWord8 = if s170 then s4683 else s4770+  s4772 :: SWord8 = if s29 then s4688 else s4771+  s4773 :: SWord8 = if s170 then s4704 else s4772+  s4774 :: SWord8 = if s29 then s4709 else s4773+  s4775 :: SWord8 = if s170 then s4725 else s4774+  s4776 :: SWord8 = if s29 then s4730 else s4775+  s4777 :: SWord8 = if s170 then s4746 else s4776+  s4778 :: SWord8 = if s29 then s4751 else s4777+  s4779 :: SWord8 = if s170 then s4769 else s4778+  s4780 :: SWord8 = s4759 + s4779+  s4781 :: SBool = s4780 < s4779+  s4782 :: SBool = s4780 < s4759+  s4783 :: SBool = s4781 | s4782+  s4784 :: SWord8 = s4780 >>> 1+  s4785 :: SWord8 = s24 | s4784+  s4786 :: SWord8 = s26 & s4784+  s4787 :: SWord8 = if s4783 then s4785 else s4786+  s4788 :: SWord8 = if s4755 then s4763 else s4787+  s4789 :: SWord8 = s4738 + s4777+  s4790 :: SWord8 = s18 & s4789+  s4791 :: SBool = s17 /= s4790+  s4792 :: SWord8 = if s4791 then s4749 else s4750+  s4793 :: SWord8 = if s22 then s4792 else s4746+  s4794 :: SWord8 = s18 & s4793+  s4795 :: SBool = s17 /= s4794+  s4796 :: SBool = s_2 == s4795+  s4797 :: SBool = s4789 < s4777+  s4798 :: SBool = s4789 < s4738+  s4799 :: SBool = s4797 | s4798+  s4800 :: SWord8 = s4789 >>> 1+  s4801 :: SWord8 = s24 | s4800+  s4802 :: SWord8 = s26 & s4800+  s4803 :: SWord8 = if s4799 then s4801 else s4802+  s4804 :: SWord8 = s4803 >>> 1+  s4805 :: SWord8 = s24 | s4804+  s4806 :: SWord8 = s26 & s4804+  s4807 :: SWord8 = if s4795 then s4805 else s4806+  s4808 :: SWord8 = s4793 >>> 1+  s4809 :: SWord8 = s24 | s4808+  s4810 :: SWord8 = s26 & s4808+  s4811 :: SWord8 = if s4765 then s4809 else s4810+  s4812 :: SWord8 = if s29 then s4792 else s4777+  s4813 :: SWord8 = if s170 then s4811 else s4812+  s4814 :: SWord8 = s4803 + s4813+  s4815 :: SBool = s4814 < s4813+  s4816 :: SBool = s4814 < s4803+  s4817 :: SBool = s4815 | s4816+  s4818 :: SWord8 = s4814 >>> 1+  s4819 :: SWord8 = s24 | s4818+  s4820 :: SWord8 = s26 & s4818+  s4821 :: SWord8 = if s4817 then s4819 else s4820+  s4822 :: SWord8 = if s4796 then s4807 else s4821+  s4823 :: SWord8 = if s4734 then s4788 else s4822+  s4824 :: SWord8 = s4717 + s4775+  s4825 :: SWord8 = s18 & s4824+  s4826 :: SBool = s17 /= s4825+  s4827 :: SWord8 = if s4826 then s4728 else s4729+  s4828 :: SWord8 = if s22 then s4827 else s4725+  s4829 :: SWord8 = s18 & s4828+  s4830 :: SBool = s17 /= s4829+  s4831 :: SBool = s_2 == s4830+  s4832 :: SBool = s4824 < s4775+  s4833 :: SBool = s4824 < s4717+  s4834 :: SBool = s4832 | s4833+  s4835 :: SWord8 = s4824 >>> 1+  s4836 :: SWord8 = s24 | s4835+  s4837 :: SWord8 = s26 & s4835+  s4838 :: SWord8 = if s4834 then s4836 else s4837+  s4839 :: SWord8 = s18 & s4838+  s4840 :: SBool = s17 /= s4839+  s4841 :: SWord8 = s4828 >>> 1+  s4842 :: SWord8 = s24 | s4841+  s4843 :: SWord8 = s26 & s4841+  s4844 :: SWord8 = if s4742 then s4842 else s4843+  s4845 :: SWord8 = if s22 then s4844 else s4827+  s4846 :: SWord8 = s4845 >>> 1+  s4847 :: SWord8 = s24 | s4846+  s4848 :: SWord8 = s26 & s4846+  s4849 :: SWord8 = if s4840 then s4847 else s4848+  s4850 :: SWord8 = if s22 then s4849 else s4844+  s4851 :: SWord8 = s18 & s4850+  s4852 :: SBool = s17 /= s4851+  s4853 :: SBool = s_2 == s4852+  s4854 :: SWord8 = s4838 >>> 1+  s4855 :: SWord8 = s24 | s4854+  s4856 :: SWord8 = s26 & s4854+  s4857 :: SWord8 = if s4830 then s4855 else s4856+  s4858 :: SWord8 = s4857 >>> 1+  s4859 :: SWord8 = s24 | s4858+  s4860 :: SWord8 = s26 & s4858+  s4861 :: SWord8 = if s4852 then s4859 else s4860+  s4862 :: SWord8 = s18 & s4845+  s4863 :: SBool = s17 /= s4862+  s4864 :: SWord8 = s4850 >>> 1+  s4865 :: SWord8 = s24 | s4864+  s4866 :: SWord8 = s26 & s4864+  s4867 :: SWord8 = if s4863 then s4865 else s4866+  s4868 :: SWord8 = if s29 then s4827 else s4775+  s4869 :: SWord8 = if s170 then s4844 else s4868+  s4870 :: SWord8 = if s29 then s4849 else s4869+  s4871 :: SWord8 = if s170 then s4867 else s4870+  s4872 :: SWord8 = s4857 + s4871+  s4873 :: SBool = s4872 < s4871+  s4874 :: SBool = s4872 < s4857+  s4875 :: SBool = s4873 | s4874+  s4876 :: SWord8 = s4872 >>> 1+  s4877 :: SWord8 = s24 | s4876+  s4878 :: SWord8 = s26 & s4876+  s4879 :: SWord8 = if s4875 then s4877 else s4878+  s4880 :: SWord8 = if s4853 then s4861 else s4879+  s4881 :: SWord8 = s4838 + s4869+  s4882 :: SWord8 = s18 & s4881+  s4883 :: SBool = s17 /= s4882+  s4884 :: SWord8 = if s4883 then s4847 else s4848+  s4885 :: SWord8 = if s22 then s4884 else s4844+  s4886 :: SWord8 = s18 & s4885+  s4887 :: SBool = s17 /= s4886+  s4888 :: SBool = s_2 == s4887+  s4889 :: SBool = s4881 < s4869+  s4890 :: SBool = s4881 < s4838+  s4891 :: SBool = s4889 | s4890+  s4892 :: SWord8 = s4881 >>> 1+  s4893 :: SWord8 = s24 | s4892+  s4894 :: SWord8 = s26 & s4892+  s4895 :: SWord8 = if s4891 then s4893 else s4894+  s4896 :: SWord8 = s4895 >>> 1+  s4897 :: SWord8 = s24 | s4896+  s4898 :: SWord8 = s26 & s4896+  s4899 :: SWord8 = if s4887 then s4897 else s4898+  s4900 :: SWord8 = s4885 >>> 1+  s4901 :: SWord8 = s24 | s4900+  s4902 :: SWord8 = s26 & s4900+  s4903 :: SWord8 = if s4863 then s4901 else s4902+  s4904 :: SWord8 = if s29 then s4884 else s4869+  s4905 :: SWord8 = if s170 then s4903 else s4904+  s4906 :: SWord8 = s4895 + s4905+  s4907 :: SBool = s4906 < s4905+  s4908 :: SBool = s4906 < s4895+  s4909 :: SBool = s4907 | s4908+  s4910 :: SWord8 = s4906 >>> 1+  s4911 :: SWord8 = s24 | s4910+  s4912 :: SWord8 = s26 & s4910+  s4913 :: SWord8 = if s4909 then s4911 else s4912+  s4914 :: SWord8 = if s4888 then s4899 else s4913+  s4915 :: SWord8 = if s4831 then s4880 else s4914+  s4916 :: SWord8 = if s4713 then s4823 else s4915+  s4917 :: SWord8 = s4696 + s4773+  s4918 :: SWord8 = s18 & s4917+  s4919 :: SBool = s17 /= s4918+  s4920 :: SWord8 = if s4919 then s4707 else s4708+  s4921 :: SWord8 = if s22 then s4920 else s4704+  s4922 :: SWord8 = s18 & s4921+  s4923 :: SBool = s17 /= s4922+  s4924 :: SBool = s_2 == s4923+  s4925 :: SBool = s4917 < s4773+  s4926 :: SBool = s4917 < s4696+  s4927 :: SBool = s4925 | s4926+  s4928 :: SWord8 = s4917 >>> 1+  s4929 :: SWord8 = s24 | s4928+  s4930 :: SWord8 = s26 & s4928+  s4931 :: SWord8 = if s4927 then s4929 else s4930+  s4932 :: SWord8 = s18 & s4931+  s4933 :: SBool = s17 /= s4932+  s4934 :: SWord8 = s4921 >>> 1+  s4935 :: SWord8 = s24 | s4934+  s4936 :: SWord8 = s26 & s4934+  s4937 :: SWord8 = if s4721 then s4935 else s4936+  s4938 :: SWord8 = if s22 then s4937 else s4920+  s4939 :: SWord8 = s4938 >>> 1+  s4940 :: SWord8 = s24 | s4939+  s4941 :: SWord8 = s26 & s4939+  s4942 :: SWord8 = if s4933 then s4940 else s4941+  s4943 :: SWord8 = if s22 then s4942 else s4937+  s4944 :: SWord8 = s18 & s4943+  s4945 :: SBool = s17 /= s4944+  s4946 :: SBool = s_2 == s4945+  s4947 :: SWord8 = s4931 >>> 1+  s4948 :: SWord8 = s24 | s4947+  s4949 :: SWord8 = s26 & s4947+  s4950 :: SWord8 = if s4923 then s4948 else s4949+  s4951 :: SWord8 = s18 & s4950+  s4952 :: SBool = s17 /= s4951+  s4953 :: SWord8 = s18 & s4938+  s4954 :: SBool = s17 /= s4953+  s4955 :: SWord8 = s4943 >>> 1+  s4956 :: SWord8 = s24 | s4955+  s4957 :: SWord8 = s26 & s4955+  s4958 :: SWord8 = if s4954 then s4956 else s4957+  s4959 :: SWord8 = if s22 then s4958 else s4942+  s4960 :: SWord8 = s4959 >>> 1+  s4961 :: SWord8 = s24 | s4960+  s4962 :: SWord8 = s26 & s4960+  s4963 :: SWord8 = if s4952 then s4961 else s4962+  s4964 :: SWord8 = if s22 then s4963 else s4958+  s4965 :: SWord8 = s18 & s4964+  s4966 :: SBool = s17 /= s4965+  s4967 :: SBool = s_2 == s4966+  s4968 :: SWord8 = s4950 >>> 1+  s4969 :: SWord8 = s24 | s4968+  s4970 :: SWord8 = s26 & s4968+  s4971 :: SWord8 = if s4945 then s4969 else s4970+  s4972 :: SWord8 = s4971 >>> 1+  s4973 :: SWord8 = s24 | s4972+  s4974 :: SWord8 = s26 & s4972+  s4975 :: SWord8 = if s4966 then s4973 else s4974+  s4976 :: SWord8 = s18 & s4959+  s4977 :: SBool = s17 /= s4976+  s4978 :: SWord8 = s4964 >>> 1+  s4979 :: SWord8 = s24 | s4978+  s4980 :: SWord8 = s26 & s4978+  s4981 :: SWord8 = if s4977 then s4979 else s4980+  s4982 :: SWord8 = if s29 then s4920 else s4773+  s4983 :: SWord8 = if s170 then s4937 else s4982+  s4984 :: SWord8 = if s29 then s4942 else s4983+  s4985 :: SWord8 = if s170 then s4958 else s4984+  s4986 :: SWord8 = if s29 then s4963 else s4985+  s4987 :: SWord8 = if s170 then s4981 else s4986+  s4988 :: SWord8 = s4971 + s4987+  s4989 :: SBool = s4988 < s4987+  s4990 :: SBool = s4988 < s4971+  s4991 :: SBool = s4989 | s4990+  s4992 :: SWord8 = s4988 >>> 1+  s4993 :: SWord8 = s24 | s4992+  s4994 :: SWord8 = s26 & s4992+  s4995 :: SWord8 = if s4991 then s4993 else s4994+  s4996 :: SWord8 = if s4967 then s4975 else s4995+  s4997 :: SWord8 = s4950 + s4985+  s4998 :: SWord8 = s18 & s4997+  s4999 :: SBool = s17 /= s4998+  s5000 :: SWord8 = if s4999 then s4961 else s4962+  s5001 :: SWord8 = if s22 then s5000 else s4958+  s5002 :: SWord8 = s18 & s5001+  s5003 :: SBool = s17 /= s5002+  s5004 :: SBool = s_2 == s5003+  s5005 :: SBool = s4997 < s4985+  s5006 :: SBool = s4997 < s4950+  s5007 :: SBool = s5005 | s5006+  s5008 :: SWord8 = s4997 >>> 1+  s5009 :: SWord8 = s24 | s5008+  s5010 :: SWord8 = s26 & s5008+  s5011 :: SWord8 = if s5007 then s5009 else s5010+  s5012 :: SWord8 = s5011 >>> 1+  s5013 :: SWord8 = s24 | s5012+  s5014 :: SWord8 = s26 & s5012+  s5015 :: SWord8 = if s5003 then s5013 else s5014+  s5016 :: SWord8 = s5001 >>> 1+  s5017 :: SWord8 = s24 | s5016+  s5018 :: SWord8 = s26 & s5016+  s5019 :: SWord8 = if s4977 then s5017 else s5018+  s5020 :: SWord8 = if s29 then s5000 else s4985+  s5021 :: SWord8 = if s170 then s5019 else s5020+  s5022 :: SWord8 = s5011 + s5021+  s5023 :: SBool = s5022 < s5021+  s5024 :: SBool = s5022 < s5011+  s5025 :: SBool = s5023 | s5024+  s5026 :: SWord8 = s5022 >>> 1+  s5027 :: SWord8 = s24 | s5026+  s5028 :: SWord8 = s26 & s5026+  s5029 :: SWord8 = if s5025 then s5027 else s5028+  s5030 :: SWord8 = if s5004 then s5015 else s5029+  s5031 :: SWord8 = if s4946 then s4996 else s5030+  s5032 :: SWord8 = s4931 + s4983+  s5033 :: SWord8 = s18 & s5032+  s5034 :: SBool = s17 /= s5033+  s5035 :: SWord8 = if s5034 then s4940 else s4941+  s5036 :: SWord8 = if s22 then s5035 else s4937+  s5037 :: SWord8 = s18 & s5036+  s5038 :: SBool = s17 /= s5037+  s5039 :: SBool = s_2 == s5038+  s5040 :: SBool = s5032 < s4983+  s5041 :: SBool = s5032 < s4931+  s5042 :: SBool = s5040 | s5041+  s5043 :: SWord8 = s5032 >>> 1+  s5044 :: SWord8 = s24 | s5043+  s5045 :: SWord8 = s26 & s5043+  s5046 :: SWord8 = if s5042 then s5044 else s5045+  s5047 :: SWord8 = s18 & s5046+  s5048 :: SBool = s17 /= s5047+  s5049 :: SWord8 = s5036 >>> 1+  s5050 :: SWord8 = s24 | s5049+  s5051 :: SWord8 = s26 & s5049+  s5052 :: SWord8 = if s4954 then s5050 else s5051+  s5053 :: SWord8 = if s22 then s5052 else s5035+  s5054 :: SWord8 = s5053 >>> 1+  s5055 :: SWord8 = s24 | s5054+  s5056 :: SWord8 = s26 & s5054+  s5057 :: SWord8 = if s5048 then s5055 else s5056+  s5058 :: SWord8 = if s22 then s5057 else s5052+  s5059 :: SWord8 = s18 & s5058+  s5060 :: SBool = s17 /= s5059+  s5061 :: SBool = s_2 == s5060+  s5062 :: SWord8 = s5046 >>> 1+  s5063 :: SWord8 = s24 | s5062+  s5064 :: SWord8 = s26 & s5062+  s5065 :: SWord8 = if s5038 then s5063 else s5064+  s5066 :: SWord8 = s5065 >>> 1+  s5067 :: SWord8 = s24 | s5066+  s5068 :: SWord8 = s26 & s5066+  s5069 :: SWord8 = if s5060 then s5067 else s5068+  s5070 :: SWord8 = s18 & s5053+  s5071 :: SBool = s17 /= s5070+  s5072 :: SWord8 = s5058 >>> 1+  s5073 :: SWord8 = s24 | s5072+  s5074 :: SWord8 = s26 & s5072+  s5075 :: SWord8 = if s5071 then s5073 else s5074+  s5076 :: SWord8 = if s29 then s5035 else s4983+  s5077 :: SWord8 = if s170 then s5052 else s5076+  s5078 :: SWord8 = if s29 then s5057 else s5077+  s5079 :: SWord8 = if s170 then s5075 else s5078+  s5080 :: SWord8 = s5065 + s5079+  s5081 :: SBool = s5080 < s5079+  s5082 :: SBool = s5080 < s5065+  s5083 :: SBool = s5081 | s5082+  s5084 :: SWord8 = s5080 >>> 1+  s5085 :: SWord8 = s24 | s5084+  s5086 :: SWord8 = s26 & s5084+  s5087 :: SWord8 = if s5083 then s5085 else s5086+  s5088 :: SWord8 = if s5061 then s5069 else s5087+  s5089 :: SWord8 = s5046 + s5077+  s5090 :: SWord8 = s18 & s5089+  s5091 :: SBool = s17 /= s5090+  s5092 :: SWord8 = if s5091 then s5055 else s5056+  s5093 :: SWord8 = if s22 then s5092 else s5052+  s5094 :: SWord8 = s18 & s5093+  s5095 :: SBool = s17 /= s5094+  s5096 :: SBool = s_2 == s5095+  s5097 :: SBool = s5089 < s5077+  s5098 :: SBool = s5089 < s5046+  s5099 :: SBool = s5097 | s5098+  s5100 :: SWord8 = s5089 >>> 1+  s5101 :: SWord8 = s24 | s5100+  s5102 :: SWord8 = s26 & s5100+  s5103 :: SWord8 = if s5099 then s5101 else s5102+  s5104 :: SWord8 = s5103 >>> 1+  s5105 :: SWord8 = s24 | s5104+  s5106 :: SWord8 = s26 & s5104+  s5107 :: SWord8 = if s5095 then s5105 else s5106+  s5108 :: SWord8 = s5093 >>> 1+  s5109 :: SWord8 = s24 | s5108+  s5110 :: SWord8 = s26 & s5108+  s5111 :: SWord8 = if s5071 then s5109 else s5110+  s5112 :: SWord8 = if s29 then s5092 else s5077+  s5113 :: SWord8 = if s170 then s5111 else s5112+  s5114 :: SWord8 = s5103 + s5113+  s5115 :: SBool = s5114 < s5113+  s5116 :: SBool = s5114 < s5103+  s5117 :: SBool = s5115 | s5116+  s5118 :: SWord8 = s5114 >>> 1+  s5119 :: SWord8 = s24 | s5118+  s5120 :: SWord8 = s26 & s5118+  s5121 :: SWord8 = if s5117 then s5119 else s5120+  s5122 :: SWord8 = if s5096 then s5107 else s5121+  s5123 :: SWord8 = if s5039 then s5088 else s5122+  s5124 :: SWord8 = if s4924 then s5031 else s5123+  s5125 :: SWord8 = if s4692 then s4916 else s5124+  s5126 :: SWord8 = s4677 + s4771+  s5127 :: SWord8 = s18 & s5126+  s5128 :: SBool = s17 /= s5127+  s5129 :: SWord8 = if s5128 then s4686 else s4687+  s5130 :: SWord8 = if s22 then s5129 else s4683+  s5131 :: SWord8 = s18 & s5130+  s5132 :: SBool = s17 /= s5131+  s5133 :: SBool = s_2 == s5132+  s5134 :: SBool = s5126 < s4771+  s5135 :: SBool = s5126 < s4677+  s5136 :: SBool = s5134 | s5135+  s5137 :: SWord8 = s5126 >>> 1+  s5138 :: SWord8 = s24 | s5137+  s5139 :: SWord8 = s26 & s5137+  s5140 :: SWord8 = if s5136 then s5138 else s5139+  s5141 :: SWord8 = s18 & s5140+  s5142 :: SBool = s17 /= s5141+  s5143 :: SWord8 = s5130 >>> 1+  s5144 :: SWord8 = s24 | s5143+  s5145 :: SWord8 = s26 & s5143+  s5146 :: SWord8 = if s4700 then s5144 else s5145+  s5147 :: SWord8 = if s22 then s5146 else s5129+  s5148 :: SWord8 = s5147 >>> 1+  s5149 :: SWord8 = s24 | s5148+  s5150 :: SWord8 = s26 & s5148+  s5151 :: SWord8 = if s5142 then s5149 else s5150+  s5152 :: SWord8 = if s22 then s5151 else s5146+  s5153 :: SWord8 = s18 & s5152+  s5154 :: SBool = s17 /= s5153+  s5155 :: SBool = s_2 == s5154+  s5156 :: SWord8 = s5140 >>> 1+  s5157 :: SWord8 = s24 | s5156+  s5158 :: SWord8 = s26 & s5156+  s5159 :: SWord8 = if s5132 then s5157 else s5158+  s5160 :: SWord8 = s18 & s5159+  s5161 :: SBool = s17 /= s5160+  s5162 :: SWord8 = s18 & s5147+  s5163 :: SBool = s17 /= s5162+  s5164 :: SWord8 = s5152 >>> 1+  s5165 :: SWord8 = s24 | s5164+  s5166 :: SWord8 = s26 & s5164+  s5167 :: SWord8 = if s5163 then s5165 else s5166+  s5168 :: SWord8 = if s22 then s5167 else s5151+  s5169 :: SWord8 = s5168 >>> 1+  s5170 :: SWord8 = s24 | s5169+  s5171 :: SWord8 = s26 & s5169+  s5172 :: SWord8 = if s5161 then s5170 else s5171+  s5173 :: SWord8 = if s22 then s5172 else s5167+  s5174 :: SWord8 = s18 & s5173+  s5175 :: SBool = s17 /= s5174+  s5176 :: SBool = s_2 == s5175+  s5177 :: SWord8 = s5159 >>> 1+  s5178 :: SWord8 = s24 | s5177+  s5179 :: SWord8 = s26 & s5177+  s5180 :: SWord8 = if s5154 then s5178 else s5179+  s5181 :: SWord8 = s18 & s5180+  s5182 :: SBool = s17 /= s5181+  s5183 :: SWord8 = s18 & s5168+  s5184 :: SBool = s17 /= s5183+  s5185 :: SWord8 = s5173 >>> 1+  s5186 :: SWord8 = s24 | s5185+  s5187 :: SWord8 = s26 & s5185+  s5188 :: SWord8 = if s5184 then s5186 else s5187+  s5189 :: SWord8 = if s22 then s5188 else s5172+  s5190 :: SWord8 = s5189 >>> 1+  s5191 :: SWord8 = s24 | s5190+  s5192 :: SWord8 = s26 & s5190+  s5193 :: SWord8 = if s5182 then s5191 else s5192+  s5194 :: SWord8 = if s22 then s5193 else s5188+  s5195 :: SWord8 = s18 & s5194+  s5196 :: SBool = s17 /= s5195+  s5197 :: SBool = s_2 == s5196+  s5198 :: SWord8 = s5180 >>> 1+  s5199 :: SWord8 = s24 | s5198+  s5200 :: SWord8 = s26 & s5198+  s5201 :: SWord8 = if s5175 then s5199 else s5200+  s5202 :: SWord8 = s5201 >>> 1+  s5203 :: SWord8 = s24 | s5202+  s5204 :: SWord8 = s26 & s5202+  s5205 :: SWord8 = if s5196 then s5203 else s5204+  s5206 :: SWord8 = s18 & s5189+  s5207 :: SBool = s17 /= s5206+  s5208 :: SWord8 = s5194 >>> 1+  s5209 :: SWord8 = s24 | s5208+  s5210 :: SWord8 = s26 & s5208+  s5211 :: SWord8 = if s5207 then s5209 else s5210+  s5212 :: SWord8 = if s29 then s5129 else s4771+  s5213 :: SWord8 = if s170 then s5146 else s5212+  s5214 :: SWord8 = if s29 then s5151 else s5213+  s5215 :: SWord8 = if s170 then s5167 else s5214+  s5216 :: SWord8 = if s29 then s5172 else s5215+  s5217 :: SWord8 = if s170 then s5188 else s5216+  s5218 :: SWord8 = if s29 then s5193 else s5217+  s5219 :: SWord8 = if s170 then s5211 else s5218+  s5220 :: SWord8 = s5201 + s5219+  s5221 :: SBool = s5220 < s5219+  s5222 :: SBool = s5220 < s5201+  s5223 :: SBool = s5221 | s5222+  s5224 :: SWord8 = s5220 >>> 1+  s5225 :: SWord8 = s24 | s5224+  s5226 :: SWord8 = s26 & s5224+  s5227 :: SWord8 = if s5223 then s5225 else s5226+  s5228 :: SWord8 = if s5197 then s5205 else s5227+  s5229 :: SWord8 = s5180 + s5217+  s5230 :: SWord8 = s18 & s5229+  s5231 :: SBool = s17 /= s5230+  s5232 :: SWord8 = if s5231 then s5191 else s5192+  s5233 :: SWord8 = if s22 then s5232 else s5188+  s5234 :: SWord8 = s18 & s5233+  s5235 :: SBool = s17 /= s5234+  s5236 :: SBool = s_2 == s5235+  s5237 :: SBool = s5229 < s5217+  s5238 :: SBool = s5229 < s5180+  s5239 :: SBool = s5237 | s5238+  s5240 :: SWord8 = s5229 >>> 1+  s5241 :: SWord8 = s24 | s5240+  s5242 :: SWord8 = s26 & s5240+  s5243 :: SWord8 = if s5239 then s5241 else s5242+  s5244 :: SWord8 = s5243 >>> 1+  s5245 :: SWord8 = s24 | s5244+  s5246 :: SWord8 = s26 & s5244+  s5247 :: SWord8 = if s5235 then s5245 else s5246+  s5248 :: SWord8 = s5233 >>> 1+  s5249 :: SWord8 = s24 | s5248+  s5250 :: SWord8 = s26 & s5248+  s5251 :: SWord8 = if s5207 then s5249 else s5250+  s5252 :: SWord8 = if s29 then s5232 else s5217+  s5253 :: SWord8 = if s170 then s5251 else s5252+  s5254 :: SWord8 = s5243 + s5253+  s5255 :: SBool = s5254 < s5253+  s5256 :: SBool = s5254 < s5243+  s5257 :: SBool = s5255 | s5256+  s5258 :: SWord8 = s5254 >>> 1+  s5259 :: SWord8 = s24 | s5258+  s5260 :: SWord8 = s26 & s5258+  s5261 :: SWord8 = if s5257 then s5259 else s5260+  s5262 :: SWord8 = if s5236 then s5247 else s5261+  s5263 :: SWord8 = if s5176 then s5228 else s5262+  s5264 :: SWord8 = s5159 + s5215+  s5265 :: SWord8 = s18 & s5264+  s5266 :: SBool = s17 /= s5265+  s5267 :: SWord8 = if s5266 then s5170 else s5171+  s5268 :: SWord8 = if s22 then s5267 else s5167+  s5269 :: SWord8 = s18 & s5268+  s5270 :: SBool = s17 /= s5269+  s5271 :: SBool = s_2 == s5270+  s5272 :: SBool = s5264 < s5215+  s5273 :: SBool = s5264 < s5159+  s5274 :: SBool = s5272 | s5273+  s5275 :: SWord8 = s5264 >>> 1+  s5276 :: SWord8 = s24 | s5275+  s5277 :: SWord8 = s26 & s5275+  s5278 :: SWord8 = if s5274 then s5276 else s5277+  s5279 :: SWord8 = s18 & s5278+  s5280 :: SBool = s17 /= s5279+  s5281 :: SWord8 = s5268 >>> 1+  s5282 :: SWord8 = s24 | s5281+  s5283 :: SWord8 = s26 & s5281+  s5284 :: SWord8 = if s5184 then s5282 else s5283+  s5285 :: SWord8 = if s22 then s5284 else s5267+  s5286 :: SWord8 = s5285 >>> 1+  s5287 :: SWord8 = s24 | s5286+  s5288 :: SWord8 = s26 & s5286+  s5289 :: SWord8 = if s5280 then s5287 else s5288+  s5290 :: SWord8 = if s22 then s5289 else s5284+  s5291 :: SWord8 = s18 & s5290+  s5292 :: SBool = s17 /= s5291+  s5293 :: SBool = s_2 == s5292+  s5294 :: SWord8 = s5278 >>> 1+  s5295 :: SWord8 = s24 | s5294+  s5296 :: SWord8 = s26 & s5294+  s5297 :: SWord8 = if s5270 then s5295 else s5296+  s5298 :: SWord8 = s5297 >>> 1+  s5299 :: SWord8 = s24 | s5298+  s5300 :: SWord8 = s26 & s5298+  s5301 :: SWord8 = if s5292 then s5299 else s5300+  s5302 :: SWord8 = s18 & s5285+  s5303 :: SBool = s17 /= s5302+  s5304 :: SWord8 = s5290 >>> 1+  s5305 :: SWord8 = s24 | s5304+  s5306 :: SWord8 = s26 & s5304+  s5307 :: SWord8 = if s5303 then s5305 else s5306+  s5308 :: SWord8 = if s29 then s5267 else s5215+  s5309 :: SWord8 = if s170 then s5284 else s5308+  s5310 :: SWord8 = if s29 then s5289 else s5309+  s5311 :: SWord8 = if s170 then s5307 else s5310+  s5312 :: SWord8 = s5297 + s5311+  s5313 :: SBool = s5312 < s5311+  s5314 :: SBool = s5312 < s5297+  s5315 :: SBool = s5313 | s5314+  s5316 :: SWord8 = s5312 >>> 1+  s5317 :: SWord8 = s24 | s5316+  s5318 :: SWord8 = s26 & s5316+  s5319 :: SWord8 = if s5315 then s5317 else s5318+  s5320 :: SWord8 = if s5293 then s5301 else s5319+  s5321 :: SWord8 = s5278 + s5309+  s5322 :: SWord8 = s18 & s5321+  s5323 :: SBool = s17 /= s5322+  s5324 :: SWord8 = if s5323 then s5287 else s5288+  s5325 :: SWord8 = if s22 then s5324 else s5284+  s5326 :: SWord8 = s18 & s5325+  s5327 :: SBool = s17 /= s5326+  s5328 :: SBool = s_2 == s5327+  s5329 :: SBool = s5321 < s5309+  s5330 :: SBool = s5321 < s5278+  s5331 :: SBool = s5329 | s5330+  s5332 :: SWord8 = s5321 >>> 1+  s5333 :: SWord8 = s24 | s5332+  s5334 :: SWord8 = s26 & s5332+  s5335 :: SWord8 = if s5331 then s5333 else s5334+  s5336 :: SWord8 = s5335 >>> 1+  s5337 :: SWord8 = s24 | s5336+  s5338 :: SWord8 = s26 & s5336+  s5339 :: SWord8 = if s5327 then s5337 else s5338+  s5340 :: SWord8 = s5325 >>> 1+  s5341 :: SWord8 = s24 | s5340+  s5342 :: SWord8 = s26 & s5340+  s5343 :: SWord8 = if s5303 then s5341 else s5342+  s5344 :: SWord8 = if s29 then s5324 else s5309+  s5345 :: SWord8 = if s170 then s5343 else s5344+  s5346 :: SWord8 = s5335 + s5345+  s5347 :: SBool = s5346 < s5345+  s5348 :: SBool = s5346 < s5335+  s5349 :: SBool = s5347 | s5348+  s5350 :: SWord8 = s5346 >>> 1+  s5351 :: SWord8 = s24 | s5350+  s5352 :: SWord8 = s26 & s5350+  s5353 :: SWord8 = if s5349 then s5351 else s5352+  s5354 :: SWord8 = if s5328 then s5339 else s5353+  s5355 :: SWord8 = if s5271 then s5320 else s5354+  s5356 :: SWord8 = if s5155 then s5263 else s5355+  s5357 :: SWord8 = s5140 + s5213+  s5358 :: SWord8 = s18 & s5357+  s5359 :: SBool = s17 /= s5358+  s5360 :: SWord8 = if s5359 then s5149 else s5150+  s5361 :: SWord8 = if s22 then s5360 else s5146+  s5362 :: SWord8 = s18 & s5361+  s5363 :: SBool = s17 /= s5362+  s5364 :: SBool = s_2 == s5363+  s5365 :: SBool = s5357 < s5213+  s5366 :: SBool = s5357 < s5140+  s5367 :: SBool = s5365 | s5366+  s5368 :: SWord8 = s5357 >>> 1+  s5369 :: SWord8 = s24 | s5368+  s5370 :: SWord8 = s26 & s5368+  s5371 :: SWord8 = if s5367 then s5369 else s5370+  s5372 :: SWord8 = s18 & s5371+  s5373 :: SBool = s17 /= s5372+  s5374 :: SWord8 = s5361 >>> 1+  s5375 :: SWord8 = s24 | s5374+  s5376 :: SWord8 = s26 & s5374+  s5377 :: SWord8 = if s5163 then s5375 else s5376+  s5378 :: SWord8 = if s22 then s5377 else s5360+  s5379 :: SWord8 = s5378 >>> 1+  s5380 :: SWord8 = s24 | s5379+  s5381 :: SWord8 = s26 & s5379+  s5382 :: SWord8 = if s5373 then s5380 else s5381+  s5383 :: SWord8 = if s22 then s5382 else s5377+  s5384 :: SWord8 = s18 & s5383+  s5385 :: SBool = s17 /= s5384+  s5386 :: SBool = s_2 == s5385+  s5387 :: SWord8 = s5371 >>> 1+  s5388 :: SWord8 = s24 | s5387+  s5389 :: SWord8 = s26 & s5387+  s5390 :: SWord8 = if s5363 then s5388 else s5389+  s5391 :: SWord8 = s18 & s5390+  s5392 :: SBool = s17 /= s5391+  s5393 :: SWord8 = s18 & s5378+  s5394 :: SBool = s17 /= s5393+  s5395 :: SWord8 = s5383 >>> 1+  s5396 :: SWord8 = s24 | s5395+  s5397 :: SWord8 = s26 & s5395+  s5398 :: SWord8 = if s5394 then s5396 else s5397+  s5399 :: SWord8 = if s22 then s5398 else s5382+  s5400 :: SWord8 = s5399 >>> 1+  s5401 :: SWord8 = s24 | s5400+  s5402 :: SWord8 = s26 & s5400+  s5403 :: SWord8 = if s5392 then s5401 else s5402+  s5404 :: SWord8 = if s22 then s5403 else s5398+  s5405 :: SWord8 = s18 & s5404+  s5406 :: SBool = s17 /= s5405+  s5407 :: SBool = s_2 == s5406+  s5408 :: SWord8 = s5390 >>> 1+  s5409 :: SWord8 = s24 | s5408+  s5410 :: SWord8 = s26 & s5408+  s5411 :: SWord8 = if s5385 then s5409 else s5410+  s5412 :: SWord8 = s5411 >>> 1+  s5413 :: SWord8 = s24 | s5412+  s5414 :: SWord8 = s26 & s5412+  s5415 :: SWord8 = if s5406 then s5413 else s5414+  s5416 :: SWord8 = s18 & s5399+  s5417 :: SBool = s17 /= s5416+  s5418 :: SWord8 = s5404 >>> 1+  s5419 :: SWord8 = s24 | s5418+  s5420 :: SWord8 = s26 & s5418+  s5421 :: SWord8 = if s5417 then s5419 else s5420+  s5422 :: SWord8 = if s29 then s5360 else s5213+  s5423 :: SWord8 = if s170 then s5377 else s5422+  s5424 :: SWord8 = if s29 then s5382 else s5423+  s5425 :: SWord8 = if s170 then s5398 else s5424+  s5426 :: SWord8 = if s29 then s5403 else s5425+  s5427 :: SWord8 = if s170 then s5421 else s5426+  s5428 :: SWord8 = s5411 + s5427+  s5429 :: SBool = s5428 < s5427+  s5430 :: SBool = s5428 < s5411+  s5431 :: SBool = s5429 | s5430+  s5432 :: SWord8 = s5428 >>> 1+  s5433 :: SWord8 = s24 | s5432+  s5434 :: SWord8 = s26 & s5432+  s5435 :: SWord8 = if s5431 then s5433 else s5434+  s5436 :: SWord8 = if s5407 then s5415 else s5435+  s5437 :: SWord8 = s5390 + s5425+  s5438 :: SWord8 = s18 & s5437+  s5439 :: SBool = s17 /= s5438+  s5440 :: SWord8 = if s5439 then s5401 else s5402+  s5441 :: SWord8 = if s22 then s5440 else s5398+  s5442 :: SWord8 = s18 & s5441+  s5443 :: SBool = s17 /= s5442+  s5444 :: SBool = s_2 == s5443+  s5445 :: SBool = s5437 < s5425+  s5446 :: SBool = s5437 < s5390+  s5447 :: SBool = s5445 | s5446+  s5448 :: SWord8 = s5437 >>> 1+  s5449 :: SWord8 = s24 | s5448+  s5450 :: SWord8 = s26 & s5448+  s5451 :: SWord8 = if s5447 then s5449 else s5450+  s5452 :: SWord8 = s5451 >>> 1+  s5453 :: SWord8 = s24 | s5452+  s5454 :: SWord8 = s26 & s5452+  s5455 :: SWord8 = if s5443 then s5453 else s5454+  s5456 :: SWord8 = s5441 >>> 1+  s5457 :: SWord8 = s24 | s5456+  s5458 :: SWord8 = s26 & s5456+  s5459 :: SWord8 = if s5417 then s5457 else s5458+  s5460 :: SWord8 = if s29 then s5440 else s5425+  s5461 :: SWord8 = if s170 then s5459 else s5460+  s5462 :: SWord8 = s5451 + s5461+  s5463 :: SBool = s5462 < s5461+  s5464 :: SBool = s5462 < s5451+  s5465 :: SBool = s5463 | s5464+  s5466 :: SWord8 = s5462 >>> 1+  s5467 :: SWord8 = s24 | s5466+  s5468 :: SWord8 = s26 & s5466+  s5469 :: SWord8 = if s5465 then s5467 else s5468+  s5470 :: SWord8 = if s5444 then s5455 else s5469+  s5471 :: SWord8 = if s5386 then s5436 else s5470+  s5472 :: SWord8 = s5371 + s5423+  s5473 :: SWord8 = s18 & s5472+  s5474 :: SBool = s17 /= s5473+  s5475 :: SWord8 = if s5474 then s5380 else s5381+  s5476 :: SWord8 = if s22 then s5475 else s5377+  s5477 :: SWord8 = s18 & s5476+  s5478 :: SBool = s17 /= s5477+  s5479 :: SBool = s_2 == s5478+  s5480 :: SBool = s5472 < s5423+  s5481 :: SBool = s5472 < s5371+  s5482 :: SBool = s5480 | s5481+  s5483 :: SWord8 = s5472 >>> 1+  s5484 :: SWord8 = s24 | s5483+  s5485 :: SWord8 = s26 & s5483+  s5486 :: SWord8 = if s5482 then s5484 else s5485+  s5487 :: SWord8 = s18 & s5486+  s5488 :: SBool = s17 /= s5487+  s5489 :: SWord8 = s5476 >>> 1+  s5490 :: SWord8 = s24 | s5489+  s5491 :: SWord8 = s26 & s5489+  s5492 :: SWord8 = if s5394 then s5490 else s5491+  s5493 :: SWord8 = if s22 then s5492 else s5475+  s5494 :: SWord8 = s5493 >>> 1+  s5495 :: SWord8 = s24 | s5494+  s5496 :: SWord8 = s26 & s5494+  s5497 :: SWord8 = if s5488 then s5495 else s5496+  s5498 :: SWord8 = if s22 then s5497 else s5492+  s5499 :: SWord8 = s18 & s5498+  s5500 :: SBool = s17 /= s5499+  s5501 :: SBool = s_2 == s5500+  s5502 :: SWord8 = s5486 >>> 1+  s5503 :: SWord8 = s24 | s5502+  s5504 :: SWord8 = s26 & s5502+  s5505 :: SWord8 = if s5478 then s5503 else s5504+  s5506 :: SWord8 = s5505 >>> 1+  s5507 :: SWord8 = s24 | s5506+  s5508 :: SWord8 = s26 & s5506+  s5509 :: SWord8 = if s5500 then s5507 else s5508+  s5510 :: SWord8 = s18 & s5493+  s5511 :: SBool = s17 /= s5510+  s5512 :: SWord8 = s5498 >>> 1+  s5513 :: SWord8 = s24 | s5512+  s5514 :: SWord8 = s26 & s5512+  s5515 :: SWord8 = if s5511 then s5513 else s5514+  s5516 :: SWord8 = if s29 then s5475 else s5423+  s5517 :: SWord8 = if s170 then s5492 else s5516+  s5518 :: SWord8 = if s29 then s5497 else s5517+  s5519 :: SWord8 = if s170 then s5515 else s5518+  s5520 :: SWord8 = s5505 + s5519+  s5521 :: SBool = s5520 < s5519+  s5522 :: SBool = s5520 < s5505+  s5523 :: SBool = s5521 | s5522+  s5524 :: SWord8 = s5520 >>> 1+  s5525 :: SWord8 = s24 | s5524+  s5526 :: SWord8 = s26 & s5524+  s5527 :: SWord8 = if s5523 then s5525 else s5526+  s5528 :: SWord8 = if s5501 then s5509 else s5527+  s5529 :: SWord8 = s5486 + s5517+  s5530 :: SWord8 = s18 & s5529+  s5531 :: SBool = s17 /= s5530+  s5532 :: SWord8 = if s5531 then s5495 else s5496+  s5533 :: SWord8 = if s22 then s5532 else s5492+  s5534 :: SWord8 = s18 & s5533+  s5535 :: SBool = s17 /= s5534+  s5536 :: SBool = s_2 == s5535+  s5537 :: SBool = s5529 < s5517+  s5538 :: SBool = s5529 < s5486+  s5539 :: SBool = s5537 | s5538+  s5540 :: SWord8 = s5529 >>> 1+  s5541 :: SWord8 = s24 | s5540+  s5542 :: SWord8 = s26 & s5540+  s5543 :: SWord8 = if s5539 then s5541 else s5542+  s5544 :: SWord8 = s5543 >>> 1+  s5545 :: SWord8 = s24 | s5544+  s5546 :: SWord8 = s26 & s5544+  s5547 :: SWord8 = if s5535 then s5545 else s5546+  s5548 :: SWord8 = s5533 >>> 1+  s5549 :: SWord8 = s24 | s5548+  s5550 :: SWord8 = s26 & s5548+  s5551 :: SWord8 = if s5511 then s5549 else s5550+  s5552 :: SWord8 = if s29 then s5532 else s5517+  s5553 :: SWord8 = if s170 then s5551 else s5552+  s5554 :: SWord8 = s5543 + s5553+  s5555 :: SBool = s5554 < s5553+  s5556 :: SBool = s5554 < s5543+  s5557 :: SBool = s5555 | s5556+  s5558 :: SWord8 = s5554 >>> 1+  s5559 :: SWord8 = s24 | s5558+  s5560 :: SWord8 = s26 & s5558+  s5561 :: SWord8 = if s5557 then s5559 else s5560+  s5562 :: SWord8 = if s5536 then s5547 else s5561+  s5563 :: SWord8 = if s5479 then s5528 else s5562+  s5564 :: SWord8 = if s5364 then s5471 else s5563+  s5565 :: SWord8 = if s5133 then s5356 else s5564+  s5566 :: SWord8 = if s4670 then s5125 else s5565+  s5567 :: SWord8 = if s3742 then s4662 else s5566+  s5568 :: SWord8 = s3727 + s3863+  s5569 :: SWord8 = s18 & s5568+  s5570 :: SBool = s17 /= s5569+  s5571 :: SWord8 = if s5570 then s3736 else s3737+  s5572 :: SWord8 = if s22 then s5571 else s3733+  s5573 :: SWord8 = s18 & s5572+  s5574 :: SBool = s17 /= s5573+  s5575 :: SBool = s_2 == s5574+  s5576 :: SBool = s5568 < s3863+  s5577 :: SBool = s5568 < s3727+  s5578 :: SBool = s5576 | s5577+  s5579 :: SWord8 = s5568 >>> 1+  s5580 :: SWord8 = s24 | s5579+  s5581 :: SWord8 = s26 & s5579+  s5582 :: SWord8 = if s5578 then s5580 else s5581+  s5583 :: SWord8 = s18 & s5582+  s5584 :: SBool = s17 /= s5583+  s5585 :: SWord8 = s5572 >>> 1+  s5586 :: SWord8 = s24 | s5585+  s5587 :: SWord8 = s26 & s5585+  s5588 :: SWord8 = if s3750 then s5586 else s5587+  s5589 :: SWord8 = if s22 then s5588 else s5571+  s5590 :: SWord8 = s5589 >>> 1+  s5591 :: SWord8 = s24 | s5590+  s5592 :: SWord8 = s26 & s5590+  s5593 :: SWord8 = if s5584 then s5591 else s5592+  s5594 :: SWord8 = if s22 then s5593 else s5588+  s5595 :: SWord8 = s18 & s5594+  s5596 :: SBool = s17 /= s5595+  s5597 :: SBool = s_2 == s5596+  s5598 :: SWord8 = s5582 >>> 1+  s5599 :: SWord8 = s24 | s5598+  s5600 :: SWord8 = s26 & s5598+  s5601 :: SWord8 = if s5574 then s5599 else s5600+  s5602 :: SWord8 = s18 & s5601+  s5603 :: SBool = s17 /= s5602+  s5604 :: SWord8 = s18 & s5589+  s5605 :: SBool = s17 /= s5604+  s5606 :: SWord8 = s5594 >>> 1+  s5607 :: SWord8 = s24 | s5606+  s5608 :: SWord8 = s26 & s5606+  s5609 :: SWord8 = if s5605 then s5607 else s5608+  s5610 :: SWord8 = if s22 then s5609 else s5593+  s5611 :: SWord8 = s5610 >>> 1+  s5612 :: SWord8 = s24 | s5611+  s5613 :: SWord8 = s26 & s5611+  s5614 :: SWord8 = if s5603 then s5612 else s5613+  s5615 :: SWord8 = if s22 then s5614 else s5609+  s5616 :: SWord8 = s18 & s5615+  s5617 :: SBool = s17 /= s5616+  s5618 :: SBool = s_2 == s5617+  s5619 :: SWord8 = s5601 >>> 1+  s5620 :: SWord8 = s24 | s5619+  s5621 :: SWord8 = s26 & s5619+  s5622 :: SWord8 = if s5596 then s5620 else s5621+  s5623 :: SWord8 = s18 & s5622+  s5624 :: SBool = s17 /= s5623+  s5625 :: SWord8 = s18 & s5610+  s5626 :: SBool = s17 /= s5625+  s5627 :: SWord8 = s5615 >>> 1+  s5628 :: SWord8 = s24 | s5627+  s5629 :: SWord8 = s26 & s5627+  s5630 :: SWord8 = if s5626 then s5628 else s5629+  s5631 :: SWord8 = if s22 then s5630 else s5614+  s5632 :: SWord8 = s5631 >>> 1+  s5633 :: SWord8 = s24 | s5632+  s5634 :: SWord8 = s26 & s5632+  s5635 :: SWord8 = if s5624 then s5633 else s5634+  s5636 :: SWord8 = if s22 then s5635 else s5630+  s5637 :: SWord8 = s18 & s5636+  s5638 :: SBool = s17 /= s5637+  s5639 :: SBool = s_2 == s5638+  s5640 :: SWord8 = s5622 >>> 1+  s5641 :: SWord8 = s24 | s5640+  s5642 :: SWord8 = s26 & s5640+  s5643 :: SWord8 = if s5617 then s5641 else s5642+  s5644 :: SWord8 = s18 & s5643+  s5645 :: SBool = s17 /= s5644+  s5646 :: SWord8 = s18 & s5631+  s5647 :: SBool = s17 /= s5646+  s5648 :: SWord8 = s5636 >>> 1+  s5649 :: SWord8 = s24 | s5648+  s5650 :: SWord8 = s26 & s5648+  s5651 :: SWord8 = if s5647 then s5649 else s5650+  s5652 :: SWord8 = if s22 then s5651 else s5635+  s5653 :: SWord8 = s5652 >>> 1+  s5654 :: SWord8 = s24 | s5653+  s5655 :: SWord8 = s26 & s5653+  s5656 :: SWord8 = if s5645 then s5654 else s5655+  s5657 :: SWord8 = if s22 then s5656 else s5651+  s5658 :: SWord8 = s18 & s5657+  s5659 :: SBool = s17 /= s5658+  s5660 :: SBool = s_2 == s5659+  s5661 :: SWord8 = s5643 >>> 1+  s5662 :: SWord8 = s24 | s5661+  s5663 :: SWord8 = s26 & s5661+  s5664 :: SWord8 = if s5638 then s5662 else s5663+  s5665 :: SWord8 = s18 & s5664+  s5666 :: SBool = s17 /= s5665+  s5667 :: SWord8 = s18 & s5652+  s5668 :: SBool = s17 /= s5667+  s5669 :: SWord8 = s5657 >>> 1+  s5670 :: SWord8 = s24 | s5669+  s5671 :: SWord8 = s26 & s5669+  s5672 :: SWord8 = if s5668 then s5670 else s5671+  s5673 :: SWord8 = if s22 then s5672 else s5656+  s5674 :: SWord8 = s5673 >>> 1+  s5675 :: SWord8 = s24 | s5674+  s5676 :: SWord8 = s26 & s5674+  s5677 :: SWord8 = if s5666 then s5675 else s5676+  s5678 :: SWord8 = if s22 then s5677 else s5672+  s5679 :: SWord8 = s18 & s5678+  s5680 :: SBool = s17 /= s5679+  s5681 :: SBool = s_2 == s5680+  s5682 :: SWord8 = s5664 >>> 1+  s5683 :: SWord8 = s24 | s5682+  s5684 :: SWord8 = s26 & s5682+  s5685 :: SWord8 = if s5659 then s5683 else s5684+  s5686 :: SWord8 = s5685 >>> 1+  s5687 :: SWord8 = s24 | s5686+  s5688 :: SWord8 = s26 & s5686+  s5689 :: SWord8 = if s5680 then s5687 else s5688+  s5690 :: SWord8 = s18 & s5673+  s5691 :: SBool = s17 /= s5690+  s5692 :: SWord8 = s5678 >>> 1+  s5693 :: SWord8 = s24 | s5692+  s5694 :: SWord8 = s26 & s5692+  s5695 :: SWord8 = if s5691 then s5693 else s5694+  s5696 :: SWord8 = if s29 then s5571 else s3863+  s5697 :: SWord8 = if s170 then s5588 else s5696+  s5698 :: SWord8 = if s29 then s5593 else s5697+  s5699 :: SWord8 = if s170 then s5609 else s5698+  s5700 :: SWord8 = if s29 then s5614 else s5699+  s5701 :: SWord8 = if s170 then s5630 else s5700+  s5702 :: SWord8 = if s29 then s5635 else s5701+  s5703 :: SWord8 = if s170 then s5651 else s5702+  s5704 :: SWord8 = if s29 then s5656 else s5703+  s5705 :: SWord8 = if s170 then s5672 else s5704+  s5706 :: SWord8 = if s29 then s5677 else s5705+  s5707 :: SWord8 = if s170 then s5695 else s5706+  s5708 :: SWord8 = s5685 + s5707+  s5709 :: SBool = s5708 < s5707+  s5710 :: SBool = s5708 < s5685+  s5711 :: SBool = s5709 | s5710+  s5712 :: SWord8 = s5708 >>> 1+  s5713 :: SWord8 = s24 | s5712+  s5714 :: SWord8 = s26 & s5712+  s5715 :: SWord8 = if s5711 then s5713 else s5714+  s5716 :: SWord8 = if s5681 then s5689 else s5715+  s5717 :: SWord8 = s5664 + s5705+  s5718 :: SWord8 = s18 & s5717+  s5719 :: SBool = s17 /= s5718+  s5720 :: SWord8 = if s5719 then s5675 else s5676+  s5721 :: SWord8 = if s22 then s5720 else s5672+  s5722 :: SWord8 = s18 & s5721+  s5723 :: SBool = s17 /= s5722+  s5724 :: SBool = s_2 == s5723+  s5725 :: SBool = s5717 < s5705+  s5726 :: SBool = s5717 < s5664+  s5727 :: SBool = s5725 | s5726+  s5728 :: SWord8 = s5717 >>> 1+  s5729 :: SWord8 = s24 | s5728+  s5730 :: SWord8 = s26 & s5728+  s5731 :: SWord8 = if s5727 then s5729 else s5730+  s5732 :: SWord8 = s5731 >>> 1+  s5733 :: SWord8 = s24 | s5732+  s5734 :: SWord8 = s26 & s5732+  s5735 :: SWord8 = if s5723 then s5733 else s5734+  s5736 :: SWord8 = s5721 >>> 1+  s5737 :: SWord8 = s24 | s5736+  s5738 :: SWord8 = s26 & s5736+  s5739 :: SWord8 = if s5691 then s5737 else s5738+  s5740 :: SWord8 = if s29 then s5720 else s5705+  s5741 :: SWord8 = if s170 then s5739 else s5740+  s5742 :: SWord8 = s5731 + s5741+  s5743 :: SBool = s5742 < s5741+  s5744 :: SBool = s5742 < s5731+  s5745 :: SBool = s5743 | s5744+  s5746 :: SWord8 = s5742 >>> 1+  s5747 :: SWord8 = s24 | s5746+  s5748 :: SWord8 = s26 & s5746+  s5749 :: SWord8 = if s5745 then s5747 else s5748+  s5750 :: SWord8 = if s5724 then s5735 else s5749+  s5751 :: SWord8 = if s5660 then s5716 else s5750+  s5752 :: SWord8 = s5643 + s5703+  s5753 :: SWord8 = s18 & s5752+  s5754 :: SBool = s17 /= s5753+  s5755 :: SWord8 = if s5754 then s5654 else s5655+  s5756 :: SWord8 = if s22 then s5755 else s5651+  s5757 :: SWord8 = s18 & s5756+  s5758 :: SBool = s17 /= s5757+  s5759 :: SBool = s_2 == s5758+  s5760 :: SBool = s5752 < s5703+  s5761 :: SBool = s5752 < s5643+  s5762 :: SBool = s5760 | s5761+  s5763 :: SWord8 = s5752 >>> 1+  s5764 :: SWord8 = s24 | s5763+  s5765 :: SWord8 = s26 & s5763+  s5766 :: SWord8 = if s5762 then s5764 else s5765+  s5767 :: SWord8 = s18 & s5766+  s5768 :: SBool = s17 /= s5767+  s5769 :: SWord8 = s5756 >>> 1+  s5770 :: SWord8 = s24 | s5769+  s5771 :: SWord8 = s26 & s5769+  s5772 :: SWord8 = if s5668 then s5770 else s5771+  s5773 :: SWord8 = if s22 then s5772 else s5755+  s5774 :: SWord8 = s5773 >>> 1+  s5775 :: SWord8 = s24 | s5774+  s5776 :: SWord8 = s26 & s5774+  s5777 :: SWord8 = if s5768 then s5775 else s5776+  s5778 :: SWord8 = if s22 then s5777 else s5772+  s5779 :: SWord8 = s18 & s5778+  s5780 :: SBool = s17 /= s5779+  s5781 :: SBool = s_2 == s5780+  s5782 :: SWord8 = s5766 >>> 1+  s5783 :: SWord8 = s24 | s5782+  s5784 :: SWord8 = s26 & s5782+  s5785 :: SWord8 = if s5758 then s5783 else s5784+  s5786 :: SWord8 = s5785 >>> 1+  s5787 :: SWord8 = s24 | s5786+  s5788 :: SWord8 = s26 & s5786+  s5789 :: SWord8 = if s5780 then s5787 else s5788+  s5790 :: SWord8 = s18 & s5773+  s5791 :: SBool = s17 /= s5790+  s5792 :: SWord8 = s5778 >>> 1+  s5793 :: SWord8 = s24 | s5792+  s5794 :: SWord8 = s26 & s5792+  s5795 :: SWord8 = if s5791 then s5793 else s5794+  s5796 :: SWord8 = if s29 then s5755 else s5703+  s5797 :: SWord8 = if s170 then s5772 else s5796+  s5798 :: SWord8 = if s29 then s5777 else s5797+  s5799 :: SWord8 = if s170 then s5795 else s5798+  s5800 :: SWord8 = s5785 + s5799+  s5801 :: SBool = s5800 < s5799+  s5802 :: SBool = s5800 < s5785+  s5803 :: SBool = s5801 | s5802+  s5804 :: SWord8 = s5800 >>> 1+  s5805 :: SWord8 = s24 | s5804+  s5806 :: SWord8 = s26 & s5804+  s5807 :: SWord8 = if s5803 then s5805 else s5806+  s5808 :: SWord8 = if s5781 then s5789 else s5807+  s5809 :: SWord8 = s5766 + s5797+  s5810 :: SWord8 = s18 & s5809+  s5811 :: SBool = s17 /= s5810+  s5812 :: SWord8 = if s5811 then s5775 else s5776+  s5813 :: SWord8 = if s22 then s5812 else s5772+  s5814 :: SWord8 = s18 & s5813+  s5815 :: SBool = s17 /= s5814+  s5816 :: SBool = s_2 == s5815+  s5817 :: SBool = s5809 < s5797+  s5818 :: SBool = s5809 < s5766+  s5819 :: SBool = s5817 | s5818+  s5820 :: SWord8 = s5809 >>> 1+  s5821 :: SWord8 = s24 | s5820+  s5822 :: SWord8 = s26 & s5820+  s5823 :: SWord8 = if s5819 then s5821 else s5822+  s5824 :: SWord8 = s5823 >>> 1+  s5825 :: SWord8 = s24 | s5824+  s5826 :: SWord8 = s26 & s5824+  s5827 :: SWord8 = if s5815 then s5825 else s5826+  s5828 :: SWord8 = s5813 >>> 1+  s5829 :: SWord8 = s24 | s5828+  s5830 :: SWord8 = s26 & s5828+  s5831 :: SWord8 = if s5791 then s5829 else s5830+  s5832 :: SWord8 = if s29 then s5812 else s5797+  s5833 :: SWord8 = if s170 then s5831 else s5832+  s5834 :: SWord8 = s5823 + s5833+  s5835 :: SBool = s5834 < s5833+  s5836 :: SBool = s5834 < s5823+  s5837 :: SBool = s5835 | s5836+  s5838 :: SWord8 = s5834 >>> 1+  s5839 :: SWord8 = s24 | s5838+  s5840 :: SWord8 = s26 & s5838+  s5841 :: SWord8 = if s5837 then s5839 else s5840+  s5842 :: SWord8 = if s5816 then s5827 else s5841+  s5843 :: SWord8 = if s5759 then s5808 else s5842+  s5844 :: SWord8 = if s5639 then s5751 else s5843+  s5845 :: SWord8 = s5622 + s5701+  s5846 :: SWord8 = s18 & s5845+  s5847 :: SBool = s17 /= s5846+  s5848 :: SWord8 = if s5847 then s5633 else s5634+  s5849 :: SWord8 = if s22 then s5848 else s5630+  s5850 :: SWord8 = s18 & s5849+  s5851 :: SBool = s17 /= s5850+  s5852 :: SBool = s_2 == s5851+  s5853 :: SBool = s5845 < s5701+  s5854 :: SBool = s5845 < s5622+  s5855 :: SBool = s5853 | s5854+  s5856 :: SWord8 = s5845 >>> 1+  s5857 :: SWord8 = s24 | s5856+  s5858 :: SWord8 = s26 & s5856+  s5859 :: SWord8 = if s5855 then s5857 else s5858+  s5860 :: SWord8 = s18 & s5859+  s5861 :: SBool = s17 /= s5860+  s5862 :: SWord8 = s5849 >>> 1+  s5863 :: SWord8 = s24 | s5862+  s5864 :: SWord8 = s26 & s5862+  s5865 :: SWord8 = if s5647 then s5863 else s5864+  s5866 :: SWord8 = if s22 then s5865 else s5848+  s5867 :: SWord8 = s5866 >>> 1+  s5868 :: SWord8 = s24 | s5867+  s5869 :: SWord8 = s26 & s5867+  s5870 :: SWord8 = if s5861 then s5868 else s5869+  s5871 :: SWord8 = if s22 then s5870 else s5865+  s5872 :: SWord8 = s18 & s5871+  s5873 :: SBool = s17 /= s5872+  s5874 :: SBool = s_2 == s5873+  s5875 :: SWord8 = s5859 >>> 1+  s5876 :: SWord8 = s24 | s5875+  s5877 :: SWord8 = s26 & s5875+  s5878 :: SWord8 = if s5851 then s5876 else s5877+  s5879 :: SWord8 = s18 & s5878+  s5880 :: SBool = s17 /= s5879+  s5881 :: SWord8 = s18 & s5866+  s5882 :: SBool = s17 /= s5881+  s5883 :: SWord8 = s5871 >>> 1+  s5884 :: SWord8 = s24 | s5883+  s5885 :: SWord8 = s26 & s5883+  s5886 :: SWord8 = if s5882 then s5884 else s5885+  s5887 :: SWord8 = if s22 then s5886 else s5870+  s5888 :: SWord8 = s5887 >>> 1+  s5889 :: SWord8 = s24 | s5888+  s5890 :: SWord8 = s26 & s5888+  s5891 :: SWord8 = if s5880 then s5889 else s5890+  s5892 :: SWord8 = if s22 then s5891 else s5886+  s5893 :: SWord8 = s18 & s5892+  s5894 :: SBool = s17 /= s5893+  s5895 :: SBool = s_2 == s5894+  s5896 :: SWord8 = s5878 >>> 1+  s5897 :: SWord8 = s24 | s5896+  s5898 :: SWord8 = s26 & s5896+  s5899 :: SWord8 = if s5873 then s5897 else s5898+  s5900 :: SWord8 = s5899 >>> 1+  s5901 :: SWord8 = s24 | s5900+  s5902 :: SWord8 = s26 & s5900+  s5903 :: SWord8 = if s5894 then s5901 else s5902+  s5904 :: SWord8 = s18 & s5887+  s5905 :: SBool = s17 /= s5904+  s5906 :: SWord8 = s5892 >>> 1+  s5907 :: SWord8 = s24 | s5906+  s5908 :: SWord8 = s26 & s5906+  s5909 :: SWord8 = if s5905 then s5907 else s5908+  s5910 :: SWord8 = if s29 then s5848 else s5701+  s5911 :: SWord8 = if s170 then s5865 else s5910+  s5912 :: SWord8 = if s29 then s5870 else s5911+  s5913 :: SWord8 = if s170 then s5886 else s5912+  s5914 :: SWord8 = if s29 then s5891 else s5913+  s5915 :: SWord8 = if s170 then s5909 else s5914+  s5916 :: SWord8 = s5899 + s5915+  s5917 :: SBool = s5916 < s5915+  s5918 :: SBool = s5916 < s5899+  s5919 :: SBool = s5917 | s5918+  s5920 :: SWord8 = s5916 >>> 1+  s5921 :: SWord8 = s24 | s5920+  s5922 :: SWord8 = s26 & s5920+  s5923 :: SWord8 = if s5919 then s5921 else s5922+  s5924 :: SWord8 = if s5895 then s5903 else s5923+  s5925 :: SWord8 = s5878 + s5913+  s5926 :: SWord8 = s18 & s5925+  s5927 :: SBool = s17 /= s5926+  s5928 :: SWord8 = if s5927 then s5889 else s5890+  s5929 :: SWord8 = if s22 then s5928 else s5886+  s5930 :: SWord8 = s18 & s5929+  s5931 :: SBool = s17 /= s5930+  s5932 :: SBool = s_2 == s5931+  s5933 :: SBool = s5925 < s5913+  s5934 :: SBool = s5925 < s5878+  s5935 :: SBool = s5933 | s5934+  s5936 :: SWord8 = s5925 >>> 1+  s5937 :: SWord8 = s24 | s5936+  s5938 :: SWord8 = s26 & s5936+  s5939 :: SWord8 = if s5935 then s5937 else s5938+  s5940 :: SWord8 = s5939 >>> 1+  s5941 :: SWord8 = s24 | s5940+  s5942 :: SWord8 = s26 & s5940+  s5943 :: SWord8 = if s5931 then s5941 else s5942+  s5944 :: SWord8 = s5929 >>> 1+  s5945 :: SWord8 = s24 | s5944+  s5946 :: SWord8 = s26 & s5944+  s5947 :: SWord8 = if s5905 then s5945 else s5946+  s5948 :: SWord8 = if s29 then s5928 else s5913+  s5949 :: SWord8 = if s170 then s5947 else s5948+  s5950 :: SWord8 = s5939 + s5949+  s5951 :: SBool = s5950 < s5949+  s5952 :: SBool = s5950 < s5939+  s5953 :: SBool = s5951 | s5952+  s5954 :: SWord8 = s5950 >>> 1+  s5955 :: SWord8 = s24 | s5954+  s5956 :: SWord8 = s26 & s5954+  s5957 :: SWord8 = if s5953 then s5955 else s5956+  s5958 :: SWord8 = if s5932 then s5943 else s5957+  s5959 :: SWord8 = if s5874 then s5924 else s5958+  s5960 :: SWord8 = s5859 + s5911+  s5961 :: SWord8 = s18 & s5960+  s5962 :: SBool = s17 /= s5961+  s5963 :: SWord8 = if s5962 then s5868 else s5869+  s5964 :: SWord8 = if s22 then s5963 else s5865+  s5965 :: SWord8 = s18 & s5964+  s5966 :: SBool = s17 /= s5965+  s5967 :: SBool = s_2 == s5966+  s5968 :: SBool = s5960 < s5911+  s5969 :: SBool = s5960 < s5859+  s5970 :: SBool = s5968 | s5969+  s5971 :: SWord8 = s5960 >>> 1+  s5972 :: SWord8 = s24 | s5971+  s5973 :: SWord8 = s26 & s5971+  s5974 :: SWord8 = if s5970 then s5972 else s5973+  s5975 :: SWord8 = s18 & s5974+  s5976 :: SBool = s17 /= s5975+  s5977 :: SWord8 = s5964 >>> 1+  s5978 :: SWord8 = s24 | s5977+  s5979 :: SWord8 = s26 & s5977+  s5980 :: SWord8 = if s5882 then s5978 else s5979+  s5981 :: SWord8 = if s22 then s5980 else s5963+  s5982 :: SWord8 = s5981 >>> 1+  s5983 :: SWord8 = s24 | s5982+  s5984 :: SWord8 = s26 & s5982+  s5985 :: SWord8 = if s5976 then s5983 else s5984+  s5986 :: SWord8 = if s22 then s5985 else s5980+  s5987 :: SWord8 = s18 & s5986+  s5988 :: SBool = s17 /= s5987+  s5989 :: SBool = s_2 == s5988+  s5990 :: SWord8 = s5974 >>> 1+  s5991 :: SWord8 = s24 | s5990+  s5992 :: SWord8 = s26 & s5990+  s5993 :: SWord8 = if s5966 then s5991 else s5992+  s5994 :: SWord8 = s5993 >>> 1+  s5995 :: SWord8 = s24 | s5994+  s5996 :: SWord8 = s26 & s5994+  s5997 :: SWord8 = if s5988 then s5995 else s5996+  s5998 :: SWord8 = s18 & s5981+  s5999 :: SBool = s17 /= s5998+  s6000 :: SWord8 = s5986 >>> 1+  s6001 :: SWord8 = s24 | s6000+  s6002 :: SWord8 = s26 & s6000+  s6003 :: SWord8 = if s5999 then s6001 else s6002+  s6004 :: SWord8 = if s29 then s5963 else s5911+  s6005 :: SWord8 = if s170 then s5980 else s6004+  s6006 :: SWord8 = if s29 then s5985 else s6005+  s6007 :: SWord8 = if s170 then s6003 else s6006+  s6008 :: SWord8 = s5993 + s6007+  s6009 :: SBool = s6008 < s6007+  s6010 :: SBool = s6008 < s5993+  s6011 :: SBool = s6009 | s6010+  s6012 :: SWord8 = s6008 >>> 1+  s6013 :: SWord8 = s24 | s6012+  s6014 :: SWord8 = s26 & s6012+  s6015 :: SWord8 = if s6011 then s6013 else s6014+  s6016 :: SWord8 = if s5989 then s5997 else s6015+  s6017 :: SWord8 = s5974 + s6005+  s6018 :: SWord8 = s18 & s6017+  s6019 :: SBool = s17 /= s6018+  s6020 :: SWord8 = if s6019 then s5983 else s5984+  s6021 :: SWord8 = if s22 then s6020 else s5980+  s6022 :: SWord8 = s18 & s6021+  s6023 :: SBool = s17 /= s6022+  s6024 :: SBool = s_2 == s6023+  s6025 :: SBool = s6017 < s6005+  s6026 :: SBool = s6017 < s5974+  s6027 :: SBool = s6025 | s6026+  s6028 :: SWord8 = s6017 >>> 1+  s6029 :: SWord8 = s24 | s6028+  s6030 :: SWord8 = s26 & s6028+  s6031 :: SWord8 = if s6027 then s6029 else s6030+  s6032 :: SWord8 = s6031 >>> 1+  s6033 :: SWord8 = s24 | s6032+  s6034 :: SWord8 = s26 & s6032+  s6035 :: SWord8 = if s6023 then s6033 else s6034+  s6036 :: SWord8 = s6021 >>> 1+  s6037 :: SWord8 = s24 | s6036+  s6038 :: SWord8 = s26 & s6036+  s6039 :: SWord8 = if s5999 then s6037 else s6038+  s6040 :: SWord8 = if s29 then s6020 else s6005+  s6041 :: SWord8 = if s170 then s6039 else s6040+  s6042 :: SWord8 = s6031 + s6041+  s6043 :: SBool = s6042 < s6041+  s6044 :: SBool = s6042 < s6031+  s6045 :: SBool = s6043 | s6044+  s6046 :: SWord8 = s6042 >>> 1+  s6047 :: SWord8 = s24 | s6046+  s6048 :: SWord8 = s26 & s6046+  s6049 :: SWord8 = if s6045 then s6047 else s6048+  s6050 :: SWord8 = if s6024 then s6035 else s6049+  s6051 :: SWord8 = if s5967 then s6016 else s6050+  s6052 :: SWord8 = if s5852 then s5959 else s6051+  s6053 :: SWord8 = if s5618 then s5844 else s6052+  s6054 :: SWord8 = s5601 + s5699+  s6055 :: SWord8 = s18 & s6054+  s6056 :: SBool = s17 /= s6055+  s6057 :: SWord8 = if s6056 then s5612 else s5613+  s6058 :: SWord8 = if s22 then s6057 else s5609+  s6059 :: SWord8 = s18 & s6058+  s6060 :: SBool = s17 /= s6059+  s6061 :: SBool = s_2 == s6060+  s6062 :: SBool = s6054 < s5699+  s6063 :: SBool = s6054 < s5601+  s6064 :: SBool = s6062 | s6063+  s6065 :: SWord8 = s6054 >>> 1+  s6066 :: SWord8 = s24 | s6065+  s6067 :: SWord8 = s26 & s6065+  s6068 :: SWord8 = if s6064 then s6066 else s6067+  s6069 :: SWord8 = s18 & s6068+  s6070 :: SBool = s17 /= s6069+  s6071 :: SWord8 = s6058 >>> 1+  s6072 :: SWord8 = s24 | s6071+  s6073 :: SWord8 = s26 & s6071+  s6074 :: SWord8 = if s5626 then s6072 else s6073+  s6075 :: SWord8 = if s22 then s6074 else s6057+  s6076 :: SWord8 = s6075 >>> 1+  s6077 :: SWord8 = s24 | s6076+  s6078 :: SWord8 = s26 & s6076+  s6079 :: SWord8 = if s6070 then s6077 else s6078+  s6080 :: SWord8 = if s22 then s6079 else s6074+  s6081 :: SWord8 = s18 & s6080+  s6082 :: SBool = s17 /= s6081+  s6083 :: SBool = s_2 == s6082+  s6084 :: SWord8 = s6068 >>> 1+  s6085 :: SWord8 = s24 | s6084+  s6086 :: SWord8 = s26 & s6084+  s6087 :: SWord8 = if s6060 then s6085 else s6086+  s6088 :: SWord8 = s18 & s6087+  s6089 :: SBool = s17 /= s6088+  s6090 :: SWord8 = s18 & s6075+  s6091 :: SBool = s17 /= s6090+  s6092 :: SWord8 = s6080 >>> 1+  s6093 :: SWord8 = s24 | s6092+  s6094 :: SWord8 = s26 & s6092+  s6095 :: SWord8 = if s6091 then s6093 else s6094+  s6096 :: SWord8 = if s22 then s6095 else s6079+  s6097 :: SWord8 = s6096 >>> 1+  s6098 :: SWord8 = s24 | s6097+  s6099 :: SWord8 = s26 & s6097+  s6100 :: SWord8 = if s6089 then s6098 else s6099+  s6101 :: SWord8 = if s22 then s6100 else s6095+  s6102 :: SWord8 = s18 & s6101+  s6103 :: SBool = s17 /= s6102+  s6104 :: SBool = s_2 == s6103+  s6105 :: SWord8 = s6087 >>> 1+  s6106 :: SWord8 = s24 | s6105+  s6107 :: SWord8 = s26 & s6105+  s6108 :: SWord8 = if s6082 then s6106 else s6107+  s6109 :: SWord8 = s18 & s6108+  s6110 :: SBool = s17 /= s6109+  s6111 :: SWord8 = s18 & s6096+  s6112 :: SBool = s17 /= s6111+  s6113 :: SWord8 = s6101 >>> 1+  s6114 :: SWord8 = s24 | s6113+  s6115 :: SWord8 = s26 & s6113+  s6116 :: SWord8 = if s6112 then s6114 else s6115+  s6117 :: SWord8 = if s22 then s6116 else s6100+  s6118 :: SWord8 = s6117 >>> 1+  s6119 :: SWord8 = s24 | s6118+  s6120 :: SWord8 = s26 & s6118+  s6121 :: SWord8 = if s6110 then s6119 else s6120+  s6122 :: SWord8 = if s22 then s6121 else s6116+  s6123 :: SWord8 = s18 & s6122+  s6124 :: SBool = s17 /= s6123+  s6125 :: SBool = s_2 == s6124+  s6126 :: SWord8 = s6108 >>> 1+  s6127 :: SWord8 = s24 | s6126+  s6128 :: SWord8 = s26 & s6126+  s6129 :: SWord8 = if s6103 then s6127 else s6128+  s6130 :: SWord8 = s6129 >>> 1+  s6131 :: SWord8 = s24 | s6130+  s6132 :: SWord8 = s26 & s6130+  s6133 :: SWord8 = if s6124 then s6131 else s6132+  s6134 :: SWord8 = s18 & s6117+  s6135 :: SBool = s17 /= s6134+  s6136 :: SWord8 = s6122 >>> 1+  s6137 :: SWord8 = s24 | s6136+  s6138 :: SWord8 = s26 & s6136+  s6139 :: SWord8 = if s6135 then s6137 else s6138+  s6140 :: SWord8 = if s29 then s6057 else s5699+  s6141 :: SWord8 = if s170 then s6074 else s6140+  s6142 :: SWord8 = if s29 then s6079 else s6141+  s6143 :: SWord8 = if s170 then s6095 else s6142+  s6144 :: SWord8 = if s29 then s6100 else s6143+  s6145 :: SWord8 = if s170 then s6116 else s6144+  s6146 :: SWord8 = if s29 then s6121 else s6145+  s6147 :: SWord8 = if s170 then s6139 else s6146+  s6148 :: SWord8 = s6129 + s6147+  s6149 :: SBool = s6148 < s6147+  s6150 :: SBool = s6148 < s6129+  s6151 :: SBool = s6149 | s6150+  s6152 :: SWord8 = s6148 >>> 1+  s6153 :: SWord8 = s24 | s6152+  s6154 :: SWord8 = s26 & s6152+  s6155 :: SWord8 = if s6151 then s6153 else s6154+  s6156 :: SWord8 = if s6125 then s6133 else s6155+  s6157 :: SWord8 = s6108 + s6145+  s6158 :: SWord8 = s18 & s6157+  s6159 :: SBool = s17 /= s6158+  s6160 :: SWord8 = if s6159 then s6119 else s6120+  s6161 :: SWord8 = if s22 then s6160 else s6116+  s6162 :: SWord8 = s18 & s6161+  s6163 :: SBool = s17 /= s6162+  s6164 :: SBool = s_2 == s6163+  s6165 :: SBool = s6157 < s6145+  s6166 :: SBool = s6157 < s6108+  s6167 :: SBool = s6165 | s6166+  s6168 :: SWord8 = s6157 >>> 1+  s6169 :: SWord8 = s24 | s6168+  s6170 :: SWord8 = s26 & s6168+  s6171 :: SWord8 = if s6167 then s6169 else s6170+  s6172 :: SWord8 = s6171 >>> 1+  s6173 :: SWord8 = s24 | s6172+  s6174 :: SWord8 = s26 & s6172+  s6175 :: SWord8 = if s6163 then s6173 else s6174+  s6176 :: SWord8 = s6161 >>> 1+  s6177 :: SWord8 = s24 | s6176+  s6178 :: SWord8 = s26 & s6176+  s6179 :: SWord8 = if s6135 then s6177 else s6178+  s6180 :: SWord8 = if s29 then s6160 else s6145+  s6181 :: SWord8 = if s170 then s6179 else s6180+  s6182 :: SWord8 = s6171 + s6181+  s6183 :: SBool = s6182 < s6181+  s6184 :: SBool = s6182 < s6171+  s6185 :: SBool = s6183 | s6184+  s6186 :: SWord8 = s6182 >>> 1+  s6187 :: SWord8 = s24 | s6186+  s6188 :: SWord8 = s26 & s6186+  s6189 :: SWord8 = if s6185 then s6187 else s6188+  s6190 :: SWord8 = if s6164 then s6175 else s6189+  s6191 :: SWord8 = if s6104 then s6156 else s6190+  s6192 :: SWord8 = s6087 + s6143+  s6193 :: SWord8 = s18 & s6192+  s6194 :: SBool = s17 /= s6193+  s6195 :: SWord8 = if s6194 then s6098 else s6099+  s6196 :: SWord8 = if s22 then s6195 else s6095+  s6197 :: SWord8 = s18 & s6196+  s6198 :: SBool = s17 /= s6197+  s6199 :: SBool = s_2 == s6198+  s6200 :: SBool = s6192 < s6143+  s6201 :: SBool = s6192 < s6087+  s6202 :: SBool = s6200 | s6201+  s6203 :: SWord8 = s6192 >>> 1+  s6204 :: SWord8 = s24 | s6203+  s6205 :: SWord8 = s26 & s6203+  s6206 :: SWord8 = if s6202 then s6204 else s6205+  s6207 :: SWord8 = s18 & s6206+  s6208 :: SBool = s17 /= s6207+  s6209 :: SWord8 = s6196 >>> 1+  s6210 :: SWord8 = s24 | s6209+  s6211 :: SWord8 = s26 & s6209+  s6212 :: SWord8 = if s6112 then s6210 else s6211+  s6213 :: SWord8 = if s22 then s6212 else s6195+  s6214 :: SWord8 = s6213 >>> 1+  s6215 :: SWord8 = s24 | s6214+  s6216 :: SWord8 = s26 & s6214+  s6217 :: SWord8 = if s6208 then s6215 else s6216+  s6218 :: SWord8 = if s22 then s6217 else s6212+  s6219 :: SWord8 = s18 & s6218+  s6220 :: SBool = s17 /= s6219+  s6221 :: SBool = s_2 == s6220+  s6222 :: SWord8 = s6206 >>> 1+  s6223 :: SWord8 = s24 | s6222+  s6224 :: SWord8 = s26 & s6222+  s6225 :: SWord8 = if s6198 then s6223 else s6224+  s6226 :: SWord8 = s6225 >>> 1+  s6227 :: SWord8 = s24 | s6226+  s6228 :: SWord8 = s26 & s6226+  s6229 :: SWord8 = if s6220 then s6227 else s6228+  s6230 :: SWord8 = s18 & s6213+  s6231 :: SBool = s17 /= s6230+  s6232 :: SWord8 = s6218 >>> 1+  s6233 :: SWord8 = s24 | s6232+  s6234 :: SWord8 = s26 & s6232+  s6235 :: SWord8 = if s6231 then s6233 else s6234+  s6236 :: SWord8 = if s29 then s6195 else s6143+  s6237 :: SWord8 = if s170 then s6212 else s6236+  s6238 :: SWord8 = if s29 then s6217 else s6237+  s6239 :: SWord8 = if s170 then s6235 else s6238+  s6240 :: SWord8 = s6225 + s6239+  s6241 :: SBool = s6240 < s6239+  s6242 :: SBool = s6240 < s6225+  s6243 :: SBool = s6241 | s6242+  s6244 :: SWord8 = s6240 >>> 1+  s6245 :: SWord8 = s24 | s6244+  s6246 :: SWord8 = s26 & s6244+  s6247 :: SWord8 = if s6243 then s6245 else s6246+  s6248 :: SWord8 = if s6221 then s6229 else s6247+  s6249 :: SWord8 = s6206 + s6237+  s6250 :: SWord8 = s18 & s6249+  s6251 :: SBool = s17 /= s6250+  s6252 :: SWord8 = if s6251 then s6215 else s6216+  s6253 :: SWord8 = if s22 then s6252 else s6212+  s6254 :: SWord8 = s18 & s6253+  s6255 :: SBool = s17 /= s6254+  s6256 :: SBool = s_2 == s6255+  s6257 :: SBool = s6249 < s6237+  s6258 :: SBool = s6249 < s6206+  s6259 :: SBool = s6257 | s6258+  s6260 :: SWord8 = s6249 >>> 1+  s6261 :: SWord8 = s24 | s6260+  s6262 :: SWord8 = s26 & s6260+  s6263 :: SWord8 = if s6259 then s6261 else s6262+  s6264 :: SWord8 = s6263 >>> 1+  s6265 :: SWord8 = s24 | s6264+  s6266 :: SWord8 = s26 & s6264+  s6267 :: SWord8 = if s6255 then s6265 else s6266+  s6268 :: SWord8 = s6253 >>> 1+  s6269 :: SWord8 = s24 | s6268+  s6270 :: SWord8 = s26 & s6268+  s6271 :: SWord8 = if s6231 then s6269 else s6270+  s6272 :: SWord8 = if s29 then s6252 else s6237+  s6273 :: SWord8 = if s170 then s6271 else s6272+  s6274 :: SWord8 = s6263 + s6273+  s6275 :: SBool = s6274 < s6273+  s6276 :: SBool = s6274 < s6263+  s6277 :: SBool = s6275 | s6276+  s6278 :: SWord8 = s6274 >>> 1+  s6279 :: SWord8 = s24 | s6278+  s6280 :: SWord8 = s26 & s6278+  s6281 :: SWord8 = if s6277 then s6279 else s6280+  s6282 :: SWord8 = if s6256 then s6267 else s6281+  s6283 :: SWord8 = if s6199 then s6248 else s6282+  s6284 :: SWord8 = if s6083 then s6191 else s6283+  s6285 :: SWord8 = s6068 + s6141+  s6286 :: SWord8 = s18 & s6285+  s6287 :: SBool = s17 /= s6286+  s6288 :: SWord8 = if s6287 then s6077 else s6078+  s6289 :: SWord8 = if s22 then s6288 else s6074+  s6290 :: SWord8 = s18 & s6289+  s6291 :: SBool = s17 /= s6290+  s6292 :: SBool = s_2 == s6291+  s6293 :: SBool = s6285 < s6141+  s6294 :: SBool = s6285 < s6068+  s6295 :: SBool = s6293 | s6294+  s6296 :: SWord8 = s6285 >>> 1+  s6297 :: SWord8 = s24 | s6296+  s6298 :: SWord8 = s26 & s6296+  s6299 :: SWord8 = if s6295 then s6297 else s6298+  s6300 :: SWord8 = s18 & s6299+  s6301 :: SBool = s17 /= s6300+  s6302 :: SWord8 = s6289 >>> 1+  s6303 :: SWord8 = s24 | s6302+  s6304 :: SWord8 = s26 & s6302+  s6305 :: SWord8 = if s6091 then s6303 else s6304+  s6306 :: SWord8 = if s22 then s6305 else s6288+  s6307 :: SWord8 = s6306 >>> 1+  s6308 :: SWord8 = s24 | s6307+  s6309 :: SWord8 = s26 & s6307+  s6310 :: SWord8 = if s6301 then s6308 else s6309+  s6311 :: SWord8 = if s22 then s6310 else s6305+  s6312 :: SWord8 = s18 & s6311+  s6313 :: SBool = s17 /= s6312+  s6314 :: SBool = s_2 == s6313+  s6315 :: SWord8 = s6299 >>> 1+  s6316 :: SWord8 = s24 | s6315+  s6317 :: SWord8 = s26 & s6315+  s6318 :: SWord8 = if s6291 then s6316 else s6317+  s6319 :: SWord8 = s18 & s6318+  s6320 :: SBool = s17 /= s6319+  s6321 :: SWord8 = s18 & s6306+  s6322 :: SBool = s17 /= s6321+  s6323 :: SWord8 = s6311 >>> 1+  s6324 :: SWord8 = s24 | s6323+  s6325 :: SWord8 = s26 & s6323+  s6326 :: SWord8 = if s6322 then s6324 else s6325+  s6327 :: SWord8 = if s22 then s6326 else s6310+  s6328 :: SWord8 = s6327 >>> 1+  s6329 :: SWord8 = s24 | s6328+  s6330 :: SWord8 = s26 & s6328+  s6331 :: SWord8 = if s6320 then s6329 else s6330+  s6332 :: SWord8 = if s22 then s6331 else s6326+  s6333 :: SWord8 = s18 & s6332+  s6334 :: SBool = s17 /= s6333+  s6335 :: SBool = s_2 == s6334+  s6336 :: SWord8 = s6318 >>> 1+  s6337 :: SWord8 = s24 | s6336+  s6338 :: SWord8 = s26 & s6336+  s6339 :: SWord8 = if s6313 then s6337 else s6338+  s6340 :: SWord8 = s6339 >>> 1+  s6341 :: SWord8 = s24 | s6340+  s6342 :: SWord8 = s26 & s6340+  s6343 :: SWord8 = if s6334 then s6341 else s6342+  s6344 :: SWord8 = s18 & s6327+  s6345 :: SBool = s17 /= s6344+  s6346 :: SWord8 = s6332 >>> 1+  s6347 :: SWord8 = s24 | s6346+  s6348 :: SWord8 = s26 & s6346+  s6349 :: SWord8 = if s6345 then s6347 else s6348+  s6350 :: SWord8 = if s29 then s6288 else s6141+  s6351 :: SWord8 = if s170 then s6305 else s6350+  s6352 :: SWord8 = if s29 then s6310 else s6351+  s6353 :: SWord8 = if s170 then s6326 else s6352+  s6354 :: SWord8 = if s29 then s6331 else s6353+  s6355 :: SWord8 = if s170 then s6349 else s6354+  s6356 :: SWord8 = s6339 + s6355+  s6357 :: SBool = s6356 < s6355+  s6358 :: SBool = s6356 < s6339+  s6359 :: SBool = s6357 | s6358+  s6360 :: SWord8 = s6356 >>> 1+  s6361 :: SWord8 = s24 | s6360+  s6362 :: SWord8 = s26 & s6360+  s6363 :: SWord8 = if s6359 then s6361 else s6362+  s6364 :: SWord8 = if s6335 then s6343 else s6363+  s6365 :: SWord8 = s6318 + s6353+  s6366 :: SWord8 = s18 & s6365+  s6367 :: SBool = s17 /= s6366+  s6368 :: SWord8 = if s6367 then s6329 else s6330+  s6369 :: SWord8 = if s22 then s6368 else s6326+  s6370 :: SWord8 = s18 & s6369+  s6371 :: SBool = s17 /= s6370+  s6372 :: SBool = s_2 == s6371+  s6373 :: SBool = s6365 < s6353+  s6374 :: SBool = s6365 < s6318+  s6375 :: SBool = s6373 | s6374+  s6376 :: SWord8 = s6365 >>> 1+  s6377 :: SWord8 = s24 | s6376+  s6378 :: SWord8 = s26 & s6376+  s6379 :: SWord8 = if s6375 then s6377 else s6378+  s6380 :: SWord8 = s6379 >>> 1+  s6381 :: SWord8 = s24 | s6380+  s6382 :: SWord8 = s26 & s6380+  s6383 :: SWord8 = if s6371 then s6381 else s6382+  s6384 :: SWord8 = s6369 >>> 1+  s6385 :: SWord8 = s24 | s6384+  s6386 :: SWord8 = s26 & s6384+  s6387 :: SWord8 = if s6345 then s6385 else s6386+  s6388 :: SWord8 = if s29 then s6368 else s6353+  s6389 :: SWord8 = if s170 then s6387 else s6388+  s6390 :: SWord8 = s6379 + s6389+  s6391 :: SBool = s6390 < s6389+  s6392 :: SBool = s6390 < s6379+  s6393 :: SBool = s6391 | s6392+  s6394 :: SWord8 = s6390 >>> 1+  s6395 :: SWord8 = s24 | s6394+  s6396 :: SWord8 = s26 & s6394+  s6397 :: SWord8 = if s6393 then s6395 else s6396+  s6398 :: SWord8 = if s6372 then s6383 else s6397+  s6399 :: SWord8 = if s6314 then s6364 else s6398+  s6400 :: SWord8 = s6299 + s6351+  s6401 :: SWord8 = s18 & s6400+  s6402 :: SBool = s17 /= s6401+  s6403 :: SWord8 = if s6402 then s6308 else s6309+  s6404 :: SWord8 = if s22 then s6403 else s6305+  s6405 :: SWord8 = s18 & s6404+  s6406 :: SBool = s17 /= s6405+  s6407 :: SBool = s_2 == s6406+  s6408 :: SBool = s6400 < s6351+  s6409 :: SBool = s6400 < s6299+  s6410 :: SBool = s6408 | s6409+  s6411 :: SWord8 = s6400 >>> 1+  s6412 :: SWord8 = s24 | s6411+  s6413 :: SWord8 = s26 & s6411+  s6414 :: SWord8 = if s6410 then s6412 else s6413+  s6415 :: SWord8 = s18 & s6414+  s6416 :: SBool = s17 /= s6415+  s6417 :: SWord8 = s6404 >>> 1+  s6418 :: SWord8 = s24 | s6417+  s6419 :: SWord8 = s26 & s6417+  s6420 :: SWord8 = if s6322 then s6418 else s6419+  s6421 :: SWord8 = if s22 then s6420 else s6403+  s6422 :: SWord8 = s6421 >>> 1+  s6423 :: SWord8 = s24 | s6422+  s6424 :: SWord8 = s26 & s6422+  s6425 :: SWord8 = if s6416 then s6423 else s6424+  s6426 :: SWord8 = if s22 then s6425 else s6420+  s6427 :: SWord8 = s18 & s6426+  s6428 :: SBool = s17 /= s6427+  s6429 :: SBool = s_2 == s6428+  s6430 :: SWord8 = s6414 >>> 1+  s6431 :: SWord8 = s24 | s6430+  s6432 :: SWord8 = s26 & s6430+  s6433 :: SWord8 = if s6406 then s6431 else s6432+  s6434 :: SWord8 = s6433 >>> 1+  s6435 :: SWord8 = s24 | s6434+  s6436 :: SWord8 = s26 & s6434+  s6437 :: SWord8 = if s6428 then s6435 else s6436+  s6438 :: SWord8 = s18 & s6421+  s6439 :: SBool = s17 /= s6438+  s6440 :: SWord8 = s6426 >>> 1+  s6441 :: SWord8 = s24 | s6440+  s6442 :: SWord8 = s26 & s6440+  s6443 :: SWord8 = if s6439 then s6441 else s6442+  s6444 :: SWord8 = if s29 then s6403 else s6351+  s6445 :: SWord8 = if s170 then s6420 else s6444+  s6446 :: SWord8 = if s29 then s6425 else s6445+  s6447 :: SWord8 = if s170 then s6443 else s6446+  s6448 :: SWord8 = s6433 + s6447+  s6449 :: SBool = s6448 < s6447+  s6450 :: SBool = s6448 < s6433+  s6451 :: SBool = s6449 | s6450+  s6452 :: SWord8 = s6448 >>> 1+  s6453 :: SWord8 = s24 | s6452+  s6454 :: SWord8 = s26 & s6452+  s6455 :: SWord8 = if s6451 then s6453 else s6454+  s6456 :: SWord8 = if s6429 then s6437 else s6455+  s6457 :: SWord8 = s6414 + s6445+  s6458 :: SWord8 = s18 & s6457+  s6459 :: SBool = s17 /= s6458+  s6460 :: SWord8 = if s6459 then s6423 else s6424+  s6461 :: SWord8 = if s22 then s6460 else s6420+  s6462 :: SWord8 = s18 & s6461+  s6463 :: SBool = s17 /= s6462+  s6464 :: SBool = s_2 == s6463+  s6465 :: SBool = s6457 < s6445+  s6466 :: SBool = s6457 < s6414+  s6467 :: SBool = s6465 | s6466+  s6468 :: SWord8 = s6457 >>> 1+  s6469 :: SWord8 = s24 | s6468+  s6470 :: SWord8 = s26 & s6468+  s6471 :: SWord8 = if s6467 then s6469 else s6470+  s6472 :: SWord8 = s6471 >>> 1+  s6473 :: SWord8 = s24 | s6472+  s6474 :: SWord8 = s26 & s6472+  s6475 :: SWord8 = if s6463 then s6473 else s6474+  s6476 :: SWord8 = s6461 >>> 1+  s6477 :: SWord8 = s24 | s6476+  s6478 :: SWord8 = s26 & s6476+  s6479 :: SWord8 = if s6439 then s6477 else s6478+  s6480 :: SWord8 = if s29 then s6460 else s6445+  s6481 :: SWord8 = if s170 then s6479 else s6480+  s6482 :: SWord8 = s6471 + s6481+  s6483 :: SBool = s6482 < s6481+  s6484 :: SBool = s6482 < s6471+  s6485 :: SBool = s6483 | s6484+  s6486 :: SWord8 = s6482 >>> 1+  s6487 :: SWord8 = s24 | s6486+  s6488 :: SWord8 = s26 & s6486+  s6489 :: SWord8 = if s6485 then s6487 else s6488+  s6490 :: SWord8 = if s6464 then s6475 else s6489+  s6491 :: SWord8 = if s6407 then s6456 else s6490+  s6492 :: SWord8 = if s6292 then s6399 else s6491+  s6493 :: SWord8 = if s6061 then s6284 else s6492+  s6494 :: SWord8 = if s5597 then s6053 else s6493+  s6495 :: SWord8 = s5582 + s5697+  s6496 :: SWord8 = s18 & s6495+  s6497 :: SBool = s17 /= s6496+  s6498 :: SWord8 = if s6497 then s5591 else s5592+  s6499 :: SWord8 = if s22 then s6498 else s5588+  s6500 :: SWord8 = s18 & s6499+  s6501 :: SBool = s17 /= s6500+  s6502 :: SBool = s_2 == s6501+  s6503 :: SBool = s6495 < s5697+  s6504 :: SBool = s6495 < s5582+  s6505 :: SBool = s6503 | s6504+  s6506 :: SWord8 = s6495 >>> 1+  s6507 :: SWord8 = s24 | s6506+  s6508 :: SWord8 = s26 & s6506+  s6509 :: SWord8 = if s6505 then s6507 else s6508+  s6510 :: SWord8 = s18 & s6509+  s6511 :: SBool = s17 /= s6510+  s6512 :: SWord8 = s6499 >>> 1+  s6513 :: SWord8 = s24 | s6512+  s6514 :: SWord8 = s26 & s6512+  s6515 :: SWord8 = if s5605 then s6513 else s6514+  s6516 :: SWord8 = if s22 then s6515 else s6498+  s6517 :: SWord8 = s6516 >>> 1+  s6518 :: SWord8 = s24 | s6517+  s6519 :: SWord8 = s26 & s6517+  s6520 :: SWord8 = if s6511 then s6518 else s6519+  s6521 :: SWord8 = if s22 then s6520 else s6515+  s6522 :: SWord8 = s18 & s6521+  s6523 :: SBool = s17 /= s6522+  s6524 :: SBool = s_2 == s6523+  s6525 :: SWord8 = s6509 >>> 1+  s6526 :: SWord8 = s24 | s6525+  s6527 :: SWord8 = s26 & s6525+  s6528 :: SWord8 = if s6501 then s6526 else s6527+  s6529 :: SWord8 = s18 & s6528+  s6530 :: SBool = s17 /= s6529+  s6531 :: SWord8 = s18 & s6516+  s6532 :: SBool = s17 /= s6531+  s6533 :: SWord8 = s6521 >>> 1+  s6534 :: SWord8 = s24 | s6533+  s6535 :: SWord8 = s26 & s6533+  s6536 :: SWord8 = if s6532 then s6534 else s6535+  s6537 :: SWord8 = if s22 then s6536 else s6520+  s6538 :: SWord8 = s6537 >>> 1+  s6539 :: SWord8 = s24 | s6538+  s6540 :: SWord8 = s26 & s6538+  s6541 :: SWord8 = if s6530 then s6539 else s6540+  s6542 :: SWord8 = if s22 then s6541 else s6536+  s6543 :: SWord8 = s18 & s6542+  s6544 :: SBool = s17 /= s6543+  s6545 :: SBool = s_2 == s6544+  s6546 :: SWord8 = s6528 >>> 1+  s6547 :: SWord8 = s24 | s6546+  s6548 :: SWord8 = s26 & s6546+  s6549 :: SWord8 = if s6523 then s6547 else s6548+  s6550 :: SWord8 = s18 & s6549+  s6551 :: SBool = s17 /= s6550+  s6552 :: SWord8 = s18 & s6537+  s6553 :: SBool = s17 /= s6552+  s6554 :: SWord8 = s6542 >>> 1+  s6555 :: SWord8 = s24 | s6554+  s6556 :: SWord8 = s26 & s6554+  s6557 :: SWord8 = if s6553 then s6555 else s6556+  s6558 :: SWord8 = if s22 then s6557 else s6541+  s6559 :: SWord8 = s6558 >>> 1+  s6560 :: SWord8 = s24 | s6559+  s6561 :: SWord8 = s26 & s6559+  s6562 :: SWord8 = if s6551 then s6560 else s6561+  s6563 :: SWord8 = if s22 then s6562 else s6557+  s6564 :: SWord8 = s18 & s6563+  s6565 :: SBool = s17 /= s6564+  s6566 :: SBool = s_2 == s6565+  s6567 :: SWord8 = s6549 >>> 1+  s6568 :: SWord8 = s24 | s6567+  s6569 :: SWord8 = s26 & s6567+  s6570 :: SWord8 = if s6544 then s6568 else s6569+  s6571 :: SWord8 = s18 & s6570+  s6572 :: SBool = s17 /= s6571+  s6573 :: SWord8 = s18 & s6558+  s6574 :: SBool = s17 /= s6573+  s6575 :: SWord8 = s6563 >>> 1+  s6576 :: SWord8 = s24 | s6575+  s6577 :: SWord8 = s26 & s6575+  s6578 :: SWord8 = if s6574 then s6576 else s6577+  s6579 :: SWord8 = if s22 then s6578 else s6562+  s6580 :: SWord8 = s6579 >>> 1+  s6581 :: SWord8 = s24 | s6580+  s6582 :: SWord8 = s26 & s6580+  s6583 :: SWord8 = if s6572 then s6581 else s6582+  s6584 :: SWord8 = if s22 then s6583 else s6578+  s6585 :: SWord8 = s18 & s6584+  s6586 :: SBool = s17 /= s6585+  s6587 :: SBool = s_2 == s6586+  s6588 :: SWord8 = s6570 >>> 1+  s6589 :: SWord8 = s24 | s6588+  s6590 :: SWord8 = s26 & s6588+  s6591 :: SWord8 = if s6565 then s6589 else s6590+  s6592 :: SWord8 = s6591 >>> 1+  s6593 :: SWord8 = s24 | s6592+  s6594 :: SWord8 = s26 & s6592+  s6595 :: SWord8 = if s6586 then s6593 else s6594+  s6596 :: SWord8 = s18 & s6579+  s6597 :: SBool = s17 /= s6596+  s6598 :: SWord8 = s6584 >>> 1+  s6599 :: SWord8 = s24 | s6598+  s6600 :: SWord8 = s26 & s6598+  s6601 :: SWord8 = if s6597 then s6599 else s6600+  s6602 :: SWord8 = if s29 then s6498 else s5697+  s6603 :: SWord8 = if s170 then s6515 else s6602+  s6604 :: SWord8 = if s29 then s6520 else s6603+  s6605 :: SWord8 = if s170 then s6536 else s6604+  s6606 :: SWord8 = if s29 then s6541 else s6605+  s6607 :: SWord8 = if s170 then s6557 else s6606+  s6608 :: SWord8 = if s29 then s6562 else s6607+  s6609 :: SWord8 = if s170 then s6578 else s6608+  s6610 :: SWord8 = if s29 then s6583 else s6609+  s6611 :: SWord8 = if s170 then s6601 else s6610+  s6612 :: SWord8 = s6591 + s6611+  s6613 :: SBool = s6612 < s6611+  s6614 :: SBool = s6612 < s6591+  s6615 :: SBool = s6613 | s6614+  s6616 :: SWord8 = s6612 >>> 1+  s6617 :: SWord8 = s24 | s6616+  s6618 :: SWord8 = s26 & s6616+  s6619 :: SWord8 = if s6615 then s6617 else s6618+  s6620 :: SWord8 = if s6587 then s6595 else s6619+  s6621 :: SWord8 = s6570 + s6609+  s6622 :: SWord8 = s18 & s6621+  s6623 :: SBool = s17 /= s6622+  s6624 :: SWord8 = if s6623 then s6581 else s6582+  s6625 :: SWord8 = if s22 then s6624 else s6578+  s6626 :: SWord8 = s18 & s6625+  s6627 :: SBool = s17 /= s6626+  s6628 :: SBool = s_2 == s6627+  s6629 :: SBool = s6621 < s6609+  s6630 :: SBool = s6621 < s6570+  s6631 :: SBool = s6629 | s6630+  s6632 :: SWord8 = s6621 >>> 1+  s6633 :: SWord8 = s24 | s6632+  s6634 :: SWord8 = s26 & s6632+  s6635 :: SWord8 = if s6631 then s6633 else s6634+  s6636 :: SWord8 = s6635 >>> 1+  s6637 :: SWord8 = s24 | s6636+  s6638 :: SWord8 = s26 & s6636+  s6639 :: SWord8 = if s6627 then s6637 else s6638+  s6640 :: SWord8 = s6625 >>> 1+  s6641 :: SWord8 = s24 | s6640+  s6642 :: SWord8 = s26 & s6640+  s6643 :: SWord8 = if s6597 then s6641 else s6642+  s6644 :: SWord8 = if s29 then s6624 else s6609+  s6645 :: SWord8 = if s170 then s6643 else s6644+  s6646 :: SWord8 = s6635 + s6645+  s6647 :: SBool = s6646 < s6645+  s6648 :: SBool = s6646 < s6635+  s6649 :: SBool = s6647 | s6648+  s6650 :: SWord8 = s6646 >>> 1+  s6651 :: SWord8 = s24 | s6650+  s6652 :: SWord8 = s26 & s6650+  s6653 :: SWord8 = if s6649 then s6651 else s6652+  s6654 :: SWord8 = if s6628 then s6639 else s6653+  s6655 :: SWord8 = if s6566 then s6620 else s6654+  s6656 :: SWord8 = s6549 + s6607+  s6657 :: SWord8 = s18 & s6656+  s6658 :: SBool = s17 /= s6657+  s6659 :: SWord8 = if s6658 then s6560 else s6561+  s6660 :: SWord8 = if s22 then s6659 else s6557+  s6661 :: SWord8 = s18 & s6660+  s6662 :: SBool = s17 /= s6661+  s6663 :: SBool = s_2 == s6662+  s6664 :: SBool = s6656 < s6607+  s6665 :: SBool = s6656 < s6549+  s6666 :: SBool = s6664 | s6665+  s6667 :: SWord8 = s6656 >>> 1+  s6668 :: SWord8 = s24 | s6667+  s6669 :: SWord8 = s26 & s6667+  s6670 :: SWord8 = if s6666 then s6668 else s6669+  s6671 :: SWord8 = s18 & s6670+  s6672 :: SBool = s17 /= s6671+  s6673 :: SWord8 = s6660 >>> 1+  s6674 :: SWord8 = s24 | s6673+  s6675 :: SWord8 = s26 & s6673+  s6676 :: SWord8 = if s6574 then s6674 else s6675+  s6677 :: SWord8 = if s22 then s6676 else s6659+  s6678 :: SWord8 = s6677 >>> 1+  s6679 :: SWord8 = s24 | s6678+  s6680 :: SWord8 = s26 & s6678+  s6681 :: SWord8 = if s6672 then s6679 else s6680+  s6682 :: SWord8 = if s22 then s6681 else s6676+  s6683 :: SWord8 = s18 & s6682+  s6684 :: SBool = s17 /= s6683+  s6685 :: SBool = s_2 == s6684+  s6686 :: SWord8 = s6670 >>> 1+  s6687 :: SWord8 = s24 | s6686+  s6688 :: SWord8 = s26 & s6686+  s6689 :: SWord8 = if s6662 then s6687 else s6688+  s6690 :: SWord8 = s6689 >>> 1+  s6691 :: SWord8 = s24 | s6690+  s6692 :: SWord8 = s26 & s6690+  s6693 :: SWord8 = if s6684 then s6691 else s6692+  s6694 :: SWord8 = s18 & s6677+  s6695 :: SBool = s17 /= s6694+  s6696 :: SWord8 = s6682 >>> 1+  s6697 :: SWord8 = s24 | s6696+  s6698 :: SWord8 = s26 & s6696+  s6699 :: SWord8 = if s6695 then s6697 else s6698+  s6700 :: SWord8 = if s29 then s6659 else s6607+  s6701 :: SWord8 = if s170 then s6676 else s6700+  s6702 :: SWord8 = if s29 then s6681 else s6701+  s6703 :: SWord8 = if s170 then s6699 else s6702+  s6704 :: SWord8 = s6689 + s6703+  s6705 :: SBool = s6704 < s6703+  s6706 :: SBool = s6704 < s6689+  s6707 :: SBool = s6705 | s6706+  s6708 :: SWord8 = s6704 >>> 1+  s6709 :: SWord8 = s24 | s6708+  s6710 :: SWord8 = s26 & s6708+  s6711 :: SWord8 = if s6707 then s6709 else s6710+  s6712 :: SWord8 = if s6685 then s6693 else s6711+  s6713 :: SWord8 = s6670 + s6701+  s6714 :: SWord8 = s18 & s6713+  s6715 :: SBool = s17 /= s6714+  s6716 :: SWord8 = if s6715 then s6679 else s6680+  s6717 :: SWord8 = if s22 then s6716 else s6676+  s6718 :: SWord8 = s18 & s6717+  s6719 :: SBool = s17 /= s6718+  s6720 :: SBool = s_2 == s6719+  s6721 :: SBool = s6713 < s6701+  s6722 :: SBool = s6713 < s6670+  s6723 :: SBool = s6721 | s6722+  s6724 :: SWord8 = s6713 >>> 1+  s6725 :: SWord8 = s24 | s6724+  s6726 :: SWord8 = s26 & s6724+  s6727 :: SWord8 = if s6723 then s6725 else s6726+  s6728 :: SWord8 = s6727 >>> 1+  s6729 :: SWord8 = s24 | s6728+  s6730 :: SWord8 = s26 & s6728+  s6731 :: SWord8 = if s6719 then s6729 else s6730+  s6732 :: SWord8 = s6717 >>> 1+  s6733 :: SWord8 = s24 | s6732+  s6734 :: SWord8 = s26 & s6732+  s6735 :: SWord8 = if s6695 then s6733 else s6734+  s6736 :: SWord8 = if s29 then s6716 else s6701+  s6737 :: SWord8 = if s170 then s6735 else s6736+  s6738 :: SWord8 = s6727 + s6737+  s6739 :: SBool = s6738 < s6737+  s6740 :: SBool = s6738 < s6727+  s6741 :: SBool = s6739 | s6740+  s6742 :: SWord8 = s6738 >>> 1+  s6743 :: SWord8 = s24 | s6742+  s6744 :: SWord8 = s26 & s6742+  s6745 :: SWord8 = if s6741 then s6743 else s6744+  s6746 :: SWord8 = if s6720 then s6731 else s6745+  s6747 :: SWord8 = if s6663 then s6712 else s6746+  s6748 :: SWord8 = if s6545 then s6655 else s6747+  s6749 :: SWord8 = s6528 + s6605+  s6750 :: SWord8 = s18 & s6749+  s6751 :: SBool = s17 /= s6750+  s6752 :: SWord8 = if s6751 then s6539 else s6540+  s6753 :: SWord8 = if s22 then s6752 else s6536+  s6754 :: SWord8 = s18 & s6753+  s6755 :: SBool = s17 /= s6754+  s6756 :: SBool = s_2 == s6755+  s6757 :: SBool = s6749 < s6605+  s6758 :: SBool = s6749 < s6528+  s6759 :: SBool = s6757 | s6758+  s6760 :: SWord8 = s6749 >>> 1+  s6761 :: SWord8 = s24 | s6760+  s6762 :: SWord8 = s26 & s6760+  s6763 :: SWord8 = if s6759 then s6761 else s6762+  s6764 :: SWord8 = s18 & s6763+  s6765 :: SBool = s17 /= s6764+  s6766 :: SWord8 = s6753 >>> 1+  s6767 :: SWord8 = s24 | s6766+  s6768 :: SWord8 = s26 & s6766+  s6769 :: SWord8 = if s6553 then s6767 else s6768+  s6770 :: SWord8 = if s22 then s6769 else s6752+  s6771 :: SWord8 = s6770 >>> 1+  s6772 :: SWord8 = s24 | s6771+  s6773 :: SWord8 = s26 & s6771+  s6774 :: SWord8 = if s6765 then s6772 else s6773+  s6775 :: SWord8 = if s22 then s6774 else s6769+  s6776 :: SWord8 = s18 & s6775+  s6777 :: SBool = s17 /= s6776+  s6778 :: SBool = s_2 == s6777+  s6779 :: SWord8 = s6763 >>> 1+  s6780 :: SWord8 = s24 | s6779+  s6781 :: SWord8 = s26 & s6779+  s6782 :: SWord8 = if s6755 then s6780 else s6781+  s6783 :: SWord8 = s18 & s6782+  s6784 :: SBool = s17 /= s6783+  s6785 :: SWord8 = s18 & s6770+  s6786 :: SBool = s17 /= s6785+  s6787 :: SWord8 = s6775 >>> 1+  s6788 :: SWord8 = s24 | s6787+  s6789 :: SWord8 = s26 & s6787+  s6790 :: SWord8 = if s6786 then s6788 else s6789+  s6791 :: SWord8 = if s22 then s6790 else s6774+  s6792 :: SWord8 = s6791 >>> 1+  s6793 :: SWord8 = s24 | s6792+  s6794 :: SWord8 = s26 & s6792+  s6795 :: SWord8 = if s6784 then s6793 else s6794+  s6796 :: SWord8 = if s22 then s6795 else s6790+  s6797 :: SWord8 = s18 & s6796+  s6798 :: SBool = s17 /= s6797+  s6799 :: SBool = s_2 == s6798+  s6800 :: SWord8 = s6782 >>> 1+  s6801 :: SWord8 = s24 | s6800+  s6802 :: SWord8 = s26 & s6800+  s6803 :: SWord8 = if s6777 then s6801 else s6802+  s6804 :: SWord8 = s6803 >>> 1+  s6805 :: SWord8 = s24 | s6804+  s6806 :: SWord8 = s26 & s6804+  s6807 :: SWord8 = if s6798 then s6805 else s6806+  s6808 :: SWord8 = s18 & s6791+  s6809 :: SBool = s17 /= s6808+  s6810 :: SWord8 = s6796 >>> 1+  s6811 :: SWord8 = s24 | s6810+  s6812 :: SWord8 = s26 & s6810+  s6813 :: SWord8 = if s6809 then s6811 else s6812+  s6814 :: SWord8 = if s29 then s6752 else s6605+  s6815 :: SWord8 = if s170 then s6769 else s6814+  s6816 :: SWord8 = if s29 then s6774 else s6815+  s6817 :: SWord8 = if s170 then s6790 else s6816+  s6818 :: SWord8 = if s29 then s6795 else s6817+  s6819 :: SWord8 = if s170 then s6813 else s6818+  s6820 :: SWord8 = s6803 + s6819+  s6821 :: SBool = s6820 < s6819+  s6822 :: SBool = s6820 < s6803+  s6823 :: SBool = s6821 | s6822+  s6824 :: SWord8 = s6820 >>> 1+  s6825 :: SWord8 = s24 | s6824+  s6826 :: SWord8 = s26 & s6824+  s6827 :: SWord8 = if s6823 then s6825 else s6826+  s6828 :: SWord8 = if s6799 then s6807 else s6827+  s6829 :: SWord8 = s6782 + s6817+  s6830 :: SWord8 = s18 & s6829+  s6831 :: SBool = s17 /= s6830+  s6832 :: SWord8 = if s6831 then s6793 else s6794+  s6833 :: SWord8 = if s22 then s6832 else s6790+  s6834 :: SWord8 = s18 & s6833+  s6835 :: SBool = s17 /= s6834+  s6836 :: SBool = s_2 == s6835+  s6837 :: SBool = s6829 < s6817+  s6838 :: SBool = s6829 < s6782+  s6839 :: SBool = s6837 | s6838+  s6840 :: SWord8 = s6829 >>> 1+  s6841 :: SWord8 = s24 | s6840+  s6842 :: SWord8 = s26 & s6840+  s6843 :: SWord8 = if s6839 then s6841 else s6842+  s6844 :: SWord8 = s6843 >>> 1+  s6845 :: SWord8 = s24 | s6844+  s6846 :: SWord8 = s26 & s6844+  s6847 :: SWord8 = if s6835 then s6845 else s6846+  s6848 :: SWord8 = s6833 >>> 1+  s6849 :: SWord8 = s24 | s6848+  s6850 :: SWord8 = s26 & s6848+  s6851 :: SWord8 = if s6809 then s6849 else s6850+  s6852 :: SWord8 = if s29 then s6832 else s6817+  s6853 :: SWord8 = if s170 then s6851 else s6852+  s6854 :: SWord8 = s6843 + s6853+  s6855 :: SBool = s6854 < s6853+  s6856 :: SBool = s6854 < s6843+  s6857 :: SBool = s6855 | s6856+  s6858 :: SWord8 = s6854 >>> 1+  s6859 :: SWord8 = s24 | s6858+  s6860 :: SWord8 = s26 & s6858+  s6861 :: SWord8 = if s6857 then s6859 else s6860+  s6862 :: SWord8 = if s6836 then s6847 else s6861+  s6863 :: SWord8 = if s6778 then s6828 else s6862+  s6864 :: SWord8 = s6763 + s6815+  s6865 :: SWord8 = s18 & s6864+  s6866 :: SBool = s17 /= s6865+  s6867 :: SWord8 = if s6866 then s6772 else s6773+  s6868 :: SWord8 = if s22 then s6867 else s6769+  s6869 :: SWord8 = s18 & s6868+  s6870 :: SBool = s17 /= s6869+  s6871 :: SBool = s_2 == s6870+  s6872 :: SBool = s6864 < s6815+  s6873 :: SBool = s6864 < s6763+  s6874 :: SBool = s6872 | s6873+  s6875 :: SWord8 = s6864 >>> 1+  s6876 :: SWord8 = s24 | s6875+  s6877 :: SWord8 = s26 & s6875+  s6878 :: SWord8 = if s6874 then s6876 else s6877+  s6879 :: SWord8 = s18 & s6878+  s6880 :: SBool = s17 /= s6879+  s6881 :: SWord8 = s6868 >>> 1+  s6882 :: SWord8 = s24 | s6881+  s6883 :: SWord8 = s26 & s6881+  s6884 :: SWord8 = if s6786 then s6882 else s6883+  s6885 :: SWord8 = if s22 then s6884 else s6867+  s6886 :: SWord8 = s6885 >>> 1+  s6887 :: SWord8 = s24 | s6886+  s6888 :: SWord8 = s26 & s6886+  s6889 :: SWord8 = if s6880 then s6887 else s6888+  s6890 :: SWord8 = if s22 then s6889 else s6884+  s6891 :: SWord8 = s18 & s6890+  s6892 :: SBool = s17 /= s6891+  s6893 :: SBool = s_2 == s6892+  s6894 :: SWord8 = s6878 >>> 1+  s6895 :: SWord8 = s24 | s6894+  s6896 :: SWord8 = s26 & s6894+  s6897 :: SWord8 = if s6870 then s6895 else s6896+  s6898 :: SWord8 = s6897 >>> 1+  s6899 :: SWord8 = s24 | s6898+  s6900 :: SWord8 = s26 & s6898+  s6901 :: SWord8 = if s6892 then s6899 else s6900+  s6902 :: SWord8 = s18 & s6885+  s6903 :: SBool = s17 /= s6902+  s6904 :: SWord8 = s6890 >>> 1+  s6905 :: SWord8 = s24 | s6904+  s6906 :: SWord8 = s26 & s6904+  s6907 :: SWord8 = if s6903 then s6905 else s6906+  s6908 :: SWord8 = if s29 then s6867 else s6815+  s6909 :: SWord8 = if s170 then s6884 else s6908+  s6910 :: SWord8 = if s29 then s6889 else s6909+  s6911 :: SWord8 = if s170 then s6907 else s6910+  s6912 :: SWord8 = s6897 + s6911+  s6913 :: SBool = s6912 < s6911+  s6914 :: SBool = s6912 < s6897+  s6915 :: SBool = s6913 | s6914+  s6916 :: SWord8 = s6912 >>> 1+  s6917 :: SWord8 = s24 | s6916+  s6918 :: SWord8 = s26 & s6916+  s6919 :: SWord8 = if s6915 then s6917 else s6918+  s6920 :: SWord8 = if s6893 then s6901 else s6919+  s6921 :: SWord8 = s6878 + s6909+  s6922 :: SWord8 = s18 & s6921+  s6923 :: SBool = s17 /= s6922+  s6924 :: SWord8 = if s6923 then s6887 else s6888+  s6925 :: SWord8 = if s22 then s6924 else s6884+  s6926 :: SWord8 = s18 & s6925+  s6927 :: SBool = s17 /= s6926+  s6928 :: SBool = s_2 == s6927+  s6929 :: SBool = s6921 < s6909+  s6930 :: SBool = s6921 < s6878+  s6931 :: SBool = s6929 | s6930+  s6932 :: SWord8 = s6921 >>> 1+  s6933 :: SWord8 = s24 | s6932+  s6934 :: SWord8 = s26 & s6932+  s6935 :: SWord8 = if s6931 then s6933 else s6934+  s6936 :: SWord8 = s6935 >>> 1+  s6937 :: SWord8 = s24 | s6936+  s6938 :: SWord8 = s26 & s6936+  s6939 :: SWord8 = if s6927 then s6937 else s6938+  s6940 :: SWord8 = s6925 >>> 1+  s6941 :: SWord8 = s24 | s6940+  s6942 :: SWord8 = s26 & s6940+  s6943 :: SWord8 = if s6903 then s6941 else s6942+  s6944 :: SWord8 = if s29 then s6924 else s6909+  s6945 :: SWord8 = if s170 then s6943 else s6944+  s6946 :: SWord8 = s6935 + s6945+  s6947 :: SBool = s6946 < s6945+  s6948 :: SBool = s6946 < s6935+  s6949 :: SBool = s6947 | s6948+  s6950 :: SWord8 = s6946 >>> 1+  s6951 :: SWord8 = s24 | s6950+  s6952 :: SWord8 = s26 & s6950+  s6953 :: SWord8 = if s6949 then s6951 else s6952+  s6954 :: SWord8 = if s6928 then s6939 else s6953+  s6955 :: SWord8 = if s6871 then s6920 else s6954+  s6956 :: SWord8 = if s6756 then s6863 else s6955+  s6957 :: SWord8 = if s6524 then s6748 else s6956+  s6958 :: SWord8 = s6509 + s6603+  s6959 :: SWord8 = s18 & s6958+  s6960 :: SBool = s17 /= s6959+  s6961 :: SWord8 = if s6960 then s6518 else s6519+  s6962 :: SWord8 = if s22 then s6961 else s6515+  s6963 :: SWord8 = s18 & s6962+  s6964 :: SBool = s17 /= s6963+  s6965 :: SBool = s_2 == s6964+  s6966 :: SBool = s6958 < s6603+  s6967 :: SBool = s6958 < s6509+  s6968 :: SBool = s6966 | s6967+  s6969 :: SWord8 = s6958 >>> 1+  s6970 :: SWord8 = s24 | s6969+  s6971 :: SWord8 = s26 & s6969+  s6972 :: SWord8 = if s6968 then s6970 else s6971+  s6973 :: SWord8 = s18 & s6972+  s6974 :: SBool = s17 /= s6973+  s6975 :: SWord8 = s6962 >>> 1+  s6976 :: SWord8 = s24 | s6975+  s6977 :: SWord8 = s26 & s6975+  s6978 :: SWord8 = if s6532 then s6976 else s6977+  s6979 :: SWord8 = if s22 then s6978 else s6961+  s6980 :: SWord8 = s6979 >>> 1+  s6981 :: SWord8 = s24 | s6980+  s6982 :: SWord8 = s26 & s6980+  s6983 :: SWord8 = if s6974 then s6981 else s6982+  s6984 :: SWord8 = if s22 then s6983 else s6978+  s6985 :: SWord8 = s18 & s6984+  s6986 :: SBool = s17 /= s6985+  s6987 :: SBool = s_2 == s6986+  s6988 :: SWord8 = s6972 >>> 1+  s6989 :: SWord8 = s24 | s6988+  s6990 :: SWord8 = s26 & s6988+  s6991 :: SWord8 = if s6964 then s6989 else s6990+  s6992 :: SWord8 = s18 & s6991+  s6993 :: SBool = s17 /= s6992+  s6994 :: SWord8 = s18 & s6979+  s6995 :: SBool = s17 /= s6994+  s6996 :: SWord8 = s6984 >>> 1+  s6997 :: SWord8 = s24 | s6996+  s6998 :: SWord8 = s26 & s6996+  s6999 :: SWord8 = if s6995 then s6997 else s6998+  s7000 :: SWord8 = if s22 then s6999 else s6983+  s7001 :: SWord8 = s7000 >>> 1+  s7002 :: SWord8 = s24 | s7001+  s7003 :: SWord8 = s26 & s7001+  s7004 :: SWord8 = if s6993 then s7002 else s7003+  s7005 :: SWord8 = if s22 then s7004 else s6999+  s7006 :: SWord8 = s18 & s7005+  s7007 :: SBool = s17 /= s7006+  s7008 :: SBool = s_2 == s7007+  s7009 :: SWord8 = s6991 >>> 1+  s7010 :: SWord8 = s24 | s7009+  s7011 :: SWord8 = s26 & s7009+  s7012 :: SWord8 = if s6986 then s7010 else s7011+  s7013 :: SWord8 = s18 & s7012+  s7014 :: SBool = s17 /= s7013+  s7015 :: SWord8 = s18 & s7000+  s7016 :: SBool = s17 /= s7015+  s7017 :: SWord8 = s7005 >>> 1+  s7018 :: SWord8 = s24 | s7017+  s7019 :: SWord8 = s26 & s7017+  s7020 :: SWord8 = if s7016 then s7018 else s7019+  s7021 :: SWord8 = if s22 then s7020 else s7004+  s7022 :: SWord8 = s7021 >>> 1+  s7023 :: SWord8 = s24 | s7022+  s7024 :: SWord8 = s26 & s7022+  s7025 :: SWord8 = if s7014 then s7023 else s7024+  s7026 :: SWord8 = if s22 then s7025 else s7020+  s7027 :: SWord8 = s18 & s7026+  s7028 :: SBool = s17 /= s7027+  s7029 :: SBool = s_2 == s7028+  s7030 :: SWord8 = s7012 >>> 1+  s7031 :: SWord8 = s24 | s7030+  s7032 :: SWord8 = s26 & s7030+  s7033 :: SWord8 = if s7007 then s7031 else s7032+  s7034 :: SWord8 = s7033 >>> 1+  s7035 :: SWord8 = s24 | s7034+  s7036 :: SWord8 = s26 & s7034+  s7037 :: SWord8 = if s7028 then s7035 else s7036+  s7038 :: SWord8 = s18 & s7021+  s7039 :: SBool = s17 /= s7038+  s7040 :: SWord8 = s7026 >>> 1+  s7041 :: SWord8 = s24 | s7040+  s7042 :: SWord8 = s26 & s7040+  s7043 :: SWord8 = if s7039 then s7041 else s7042+  s7044 :: SWord8 = if s29 then s6961 else s6603+  s7045 :: SWord8 = if s170 then s6978 else s7044+  s7046 :: SWord8 = if s29 then s6983 else s7045+  s7047 :: SWord8 = if s170 then s6999 else s7046+  s7048 :: SWord8 = if s29 then s7004 else s7047+  s7049 :: SWord8 = if s170 then s7020 else s7048+  s7050 :: SWord8 = if s29 then s7025 else s7049+  s7051 :: SWord8 = if s170 then s7043 else s7050+  s7052 :: SWord8 = s7033 + s7051+  s7053 :: SBool = s7052 < s7051+  s7054 :: SBool = s7052 < s7033+  s7055 :: SBool = s7053 | s7054+  s7056 :: SWord8 = s7052 >>> 1+  s7057 :: SWord8 = s24 | s7056+  s7058 :: SWord8 = s26 & s7056+  s7059 :: SWord8 = if s7055 then s7057 else s7058+  s7060 :: SWord8 = if s7029 then s7037 else s7059+  s7061 :: SWord8 = s7012 + s7049+  s7062 :: SWord8 = s18 & s7061+  s7063 :: SBool = s17 /= s7062+  s7064 :: SWord8 = if s7063 then s7023 else s7024+  s7065 :: SWord8 = if s22 then s7064 else s7020+  s7066 :: SWord8 = s18 & s7065+  s7067 :: SBool = s17 /= s7066+  s7068 :: SBool = s_2 == s7067+  s7069 :: SBool = s7061 < s7049+  s7070 :: SBool = s7061 < s7012+  s7071 :: SBool = s7069 | s7070+  s7072 :: SWord8 = s7061 >>> 1+  s7073 :: SWord8 = s24 | s7072+  s7074 :: SWord8 = s26 & s7072+  s7075 :: SWord8 = if s7071 then s7073 else s7074+  s7076 :: SWord8 = s7075 >>> 1+  s7077 :: SWord8 = s24 | s7076+  s7078 :: SWord8 = s26 & s7076+  s7079 :: SWord8 = if s7067 then s7077 else s7078+  s7080 :: SWord8 = s7065 >>> 1+  s7081 :: SWord8 = s24 | s7080+  s7082 :: SWord8 = s26 & s7080+  s7083 :: SWord8 = if s7039 then s7081 else s7082+  s7084 :: SWord8 = if s29 then s7064 else s7049+  s7085 :: SWord8 = if s170 then s7083 else s7084+  s7086 :: SWord8 = s7075 + s7085+  s7087 :: SBool = s7086 < s7085+  s7088 :: SBool = s7086 < s7075+  s7089 :: SBool = s7087 | s7088+  s7090 :: SWord8 = s7086 >>> 1+  s7091 :: SWord8 = s24 | s7090+  s7092 :: SWord8 = s26 & s7090+  s7093 :: SWord8 = if s7089 then s7091 else s7092+  s7094 :: SWord8 = if s7068 then s7079 else s7093+  s7095 :: SWord8 = if s7008 then s7060 else s7094+  s7096 :: SWord8 = s6991 + s7047+  s7097 :: SWord8 = s18 & s7096+  s7098 :: SBool = s17 /= s7097+  s7099 :: SWord8 = if s7098 then s7002 else s7003+  s7100 :: SWord8 = if s22 then s7099 else s6999+  s7101 :: SWord8 = s18 & s7100+  s7102 :: SBool = s17 /= s7101+  s7103 :: SBool = s_2 == s7102+  s7104 :: SBool = s7096 < s7047+  s7105 :: SBool = s7096 < s6991+  s7106 :: SBool = s7104 | s7105+  s7107 :: SWord8 = s7096 >>> 1+  s7108 :: SWord8 = s24 | s7107+  s7109 :: SWord8 = s26 & s7107+  s7110 :: SWord8 = if s7106 then s7108 else s7109+  s7111 :: SWord8 = s18 & s7110+  s7112 :: SBool = s17 /= s7111+  s7113 :: SWord8 = s7100 >>> 1+  s7114 :: SWord8 = s24 | s7113+  s7115 :: SWord8 = s26 & s7113+  s7116 :: SWord8 = if s7016 then s7114 else s7115+  s7117 :: SWord8 = if s22 then s7116 else s7099+  s7118 :: SWord8 = s7117 >>> 1+  s7119 :: SWord8 = s24 | s7118+  s7120 :: SWord8 = s26 & s7118+  s7121 :: SWord8 = if s7112 then s7119 else s7120+  s7122 :: SWord8 = if s22 then s7121 else s7116+  s7123 :: SWord8 = s18 & s7122+  s7124 :: SBool = s17 /= s7123+  s7125 :: SBool = s_2 == s7124+  s7126 :: SWord8 = s7110 >>> 1+  s7127 :: SWord8 = s24 | s7126+  s7128 :: SWord8 = s26 & s7126+  s7129 :: SWord8 = if s7102 then s7127 else s7128+  s7130 :: SWord8 = s7129 >>> 1+  s7131 :: SWord8 = s24 | s7130+  s7132 :: SWord8 = s26 & s7130+  s7133 :: SWord8 = if s7124 then s7131 else s7132+  s7134 :: SWord8 = s18 & s7117+  s7135 :: SBool = s17 /= s7134+  s7136 :: SWord8 = s7122 >>> 1+  s7137 :: SWord8 = s24 | s7136+  s7138 :: SWord8 = s26 & s7136+  s7139 :: SWord8 = if s7135 then s7137 else s7138+  s7140 :: SWord8 = if s29 then s7099 else s7047+  s7141 :: SWord8 = if s170 then s7116 else s7140+  s7142 :: SWord8 = if s29 then s7121 else s7141+  s7143 :: SWord8 = if s170 then s7139 else s7142+  s7144 :: SWord8 = s7129 + s7143+  s7145 :: SBool = s7144 < s7143+  s7146 :: SBool = s7144 < s7129+  s7147 :: SBool = s7145 | s7146+  s7148 :: SWord8 = s7144 >>> 1+  s7149 :: SWord8 = s24 | s7148+  s7150 :: SWord8 = s26 & s7148+  s7151 :: SWord8 = if s7147 then s7149 else s7150+  s7152 :: SWord8 = if s7125 then s7133 else s7151+  s7153 :: SWord8 = s7110 + s7141+  s7154 :: SWord8 = s18 & s7153+  s7155 :: SBool = s17 /= s7154+  s7156 :: SWord8 = if s7155 then s7119 else s7120+  s7157 :: SWord8 = if s22 then s7156 else s7116+  s7158 :: SWord8 = s18 & s7157+  s7159 :: SBool = s17 /= s7158+  s7160 :: SBool = s_2 == s7159+  s7161 :: SBool = s7153 < s7141+  s7162 :: SBool = s7153 < s7110+  s7163 :: SBool = s7161 | s7162+  s7164 :: SWord8 = s7153 >>> 1+  s7165 :: SWord8 = s24 | s7164+  s7166 :: SWord8 = s26 & s7164+  s7167 :: SWord8 = if s7163 then s7165 else s7166+  s7168 :: SWord8 = s7167 >>> 1+  s7169 :: SWord8 = s24 | s7168+  s7170 :: SWord8 = s26 & s7168+  s7171 :: SWord8 = if s7159 then s7169 else s7170+  s7172 :: SWord8 = s7157 >>> 1+  s7173 :: SWord8 = s24 | s7172+  s7174 :: SWord8 = s26 & s7172+  s7175 :: SWord8 = if s7135 then s7173 else s7174+  s7176 :: SWord8 = if s29 then s7156 else s7141+  s7177 :: SWord8 = if s170 then s7175 else s7176+  s7178 :: SWord8 = s7167 + s7177+  s7179 :: SBool = s7178 < s7177+  s7180 :: SBool = s7178 < s7167+  s7181 :: SBool = s7179 | s7180+  s7182 :: SWord8 = s7178 >>> 1+  s7183 :: SWord8 = s24 | s7182+  s7184 :: SWord8 = s26 & s7182+  s7185 :: SWord8 = if s7181 then s7183 else s7184+  s7186 :: SWord8 = if s7160 then s7171 else s7185+  s7187 :: SWord8 = if s7103 then s7152 else s7186+  s7188 :: SWord8 = if s6987 then s7095 else s7187+  s7189 :: SWord8 = s6972 + s7045+  s7190 :: SWord8 = s18 & s7189+  s7191 :: SBool = s17 /= s7190+  s7192 :: SWord8 = if s7191 then s6981 else s6982+  s7193 :: SWord8 = if s22 then s7192 else s6978+  s7194 :: SWord8 = s18 & s7193+  s7195 :: SBool = s17 /= s7194+  s7196 :: SBool = s_2 == s7195+  s7197 :: SBool = s7189 < s7045+  s7198 :: SBool = s7189 < s6972+  s7199 :: SBool = s7197 | s7198+  s7200 :: SWord8 = s7189 >>> 1+  s7201 :: SWord8 = s24 | s7200+  s7202 :: SWord8 = s26 & s7200+  s7203 :: SWord8 = if s7199 then s7201 else s7202+  s7204 :: SWord8 = s18 & s7203+  s7205 :: SBool = s17 /= s7204+  s7206 :: SWord8 = s7193 >>> 1+  s7207 :: SWord8 = s24 | s7206+  s7208 :: SWord8 = s26 & s7206+  s7209 :: SWord8 = if s6995 then s7207 else s7208+  s7210 :: SWord8 = if s22 then s7209 else s7192+  s7211 :: SWord8 = s7210 >>> 1+  s7212 :: SWord8 = s24 | s7211+  s7213 :: SWord8 = s26 & s7211+  s7214 :: SWord8 = if s7205 then s7212 else s7213+  s7215 :: SWord8 = if s22 then s7214 else s7209+  s7216 :: SWord8 = s18 & s7215+  s7217 :: SBool = s17 /= s7216+  s7218 :: SBool = s_2 == s7217+  s7219 :: SWord8 = s7203 >>> 1+  s7220 :: SWord8 = s24 | s7219+  s7221 :: SWord8 = s26 & s7219+  s7222 :: SWord8 = if s7195 then s7220 else s7221+  s7223 :: SWord8 = s18 & s7222+  s7224 :: SBool = s17 /= s7223+  s7225 :: SWord8 = s18 & s7210+  s7226 :: SBool = s17 /= s7225+  s7227 :: SWord8 = s7215 >>> 1+  s7228 :: SWord8 = s24 | s7227+  s7229 :: SWord8 = s26 & s7227+  s7230 :: SWord8 = if s7226 then s7228 else s7229+  s7231 :: SWord8 = if s22 then s7230 else s7214+  s7232 :: SWord8 = s7231 >>> 1+  s7233 :: SWord8 = s24 | s7232+  s7234 :: SWord8 = s26 & s7232+  s7235 :: SWord8 = if s7224 then s7233 else s7234+  s7236 :: SWord8 = if s22 then s7235 else s7230+  s7237 :: SWord8 = s18 & s7236+  s7238 :: SBool = s17 /= s7237+  s7239 :: SBool = s_2 == s7238+  s7240 :: SWord8 = s7222 >>> 1+  s7241 :: SWord8 = s24 | s7240+  s7242 :: SWord8 = s26 & s7240+  s7243 :: SWord8 = if s7217 then s7241 else s7242+  s7244 :: SWord8 = s7243 >>> 1+  s7245 :: SWord8 = s24 | s7244+  s7246 :: SWord8 = s26 & s7244+  s7247 :: SWord8 = if s7238 then s7245 else s7246+  s7248 :: SWord8 = s18 & s7231+  s7249 :: SBool = s17 /= s7248+  s7250 :: SWord8 = s7236 >>> 1+  s7251 :: SWord8 = s24 | s7250+  s7252 :: SWord8 = s26 & s7250+  s7253 :: SWord8 = if s7249 then s7251 else s7252+  s7254 :: SWord8 = if s29 then s7192 else s7045+  s7255 :: SWord8 = if s170 then s7209 else s7254+  s7256 :: SWord8 = if s29 then s7214 else s7255+  s7257 :: SWord8 = if s170 then s7230 else s7256+  s7258 :: SWord8 = if s29 then s7235 else s7257+  s7259 :: SWord8 = if s170 then s7253 else s7258+  s7260 :: SWord8 = s7243 + s7259+  s7261 :: SBool = s7260 < s7259+  s7262 :: SBool = s7260 < s7243+  s7263 :: SBool = s7261 | s7262+  s7264 :: SWord8 = s7260 >>> 1+  s7265 :: SWord8 = s24 | s7264+  s7266 :: SWord8 = s26 & s7264+  s7267 :: SWord8 = if s7263 then s7265 else s7266+  s7268 :: SWord8 = if s7239 then s7247 else s7267+  s7269 :: SWord8 = s7222 + s7257+  s7270 :: SWord8 = s18 & s7269+  s7271 :: SBool = s17 /= s7270+  s7272 :: SWord8 = if s7271 then s7233 else s7234+  s7273 :: SWord8 = if s22 then s7272 else s7230+  s7274 :: SWord8 = s18 & s7273+  s7275 :: SBool = s17 /= s7274+  s7276 :: SBool = s_2 == s7275+  s7277 :: SBool = s7269 < s7257+  s7278 :: SBool = s7269 < s7222+  s7279 :: SBool = s7277 | s7278+  s7280 :: SWord8 = s7269 >>> 1+  s7281 :: SWord8 = s24 | s7280+  s7282 :: SWord8 = s26 & s7280+  s7283 :: SWord8 = if s7279 then s7281 else s7282+  s7284 :: SWord8 = s7283 >>> 1+  s7285 :: SWord8 = s24 | s7284+  s7286 :: SWord8 = s26 & s7284+  s7287 :: SWord8 = if s7275 then s7285 else s7286+  s7288 :: SWord8 = s7273 >>> 1+  s7289 :: SWord8 = s24 | s7288+  s7290 :: SWord8 = s26 & s7288+  s7291 :: SWord8 = if s7249 then s7289 else s7290+  s7292 :: SWord8 = if s29 then s7272 else s7257+  s7293 :: SWord8 = if s170 then s7291 else s7292+  s7294 :: SWord8 = s7283 + s7293+  s7295 :: SBool = s7294 < s7293+  s7296 :: SBool = s7294 < s7283+  s7297 :: SBool = s7295 | s7296+  s7298 :: SWord8 = s7294 >>> 1+  s7299 :: SWord8 = s24 | s7298+  s7300 :: SWord8 = s26 & s7298+  s7301 :: SWord8 = if s7297 then s7299 else s7300+  s7302 :: SWord8 = if s7276 then s7287 else s7301+  s7303 :: SWord8 = if s7218 then s7268 else s7302+  s7304 :: SWord8 = s7203 + s7255+  s7305 :: SWord8 = s18 & s7304+  s7306 :: SBool = s17 /= s7305+  s7307 :: SWord8 = if s7306 then s7212 else s7213+  s7308 :: SWord8 = if s22 then s7307 else s7209+  s7309 :: SWord8 = s18 & s7308+  s7310 :: SBool = s17 /= s7309+  s7311 :: SBool = s_2 == s7310+  s7312 :: SBool = s7304 < s7255+  s7313 :: SBool = s7304 < s7203+  s7314 :: SBool = s7312 | s7313+  s7315 :: SWord8 = s7304 >>> 1+  s7316 :: SWord8 = s24 | s7315+  s7317 :: SWord8 = s26 & s7315+  s7318 :: SWord8 = if s7314 then s7316 else s7317+  s7319 :: SWord8 = s18 & s7318+  s7320 :: SBool = s17 /= s7319+  s7321 :: SWord8 = s7308 >>> 1+  s7322 :: SWord8 = s24 | s7321+  s7323 :: SWord8 = s26 & s7321+  s7324 :: SWord8 = if s7226 then s7322 else s7323+  s7325 :: SWord8 = if s22 then s7324 else s7307+  s7326 :: SWord8 = s7325 >>> 1+  s7327 :: SWord8 = s24 | s7326+  s7328 :: SWord8 = s26 & s7326+  s7329 :: SWord8 = if s7320 then s7327 else s7328+  s7330 :: SWord8 = if s22 then s7329 else s7324+  s7331 :: SWord8 = s18 & s7330+  s7332 :: SBool = s17 /= s7331+  s7333 :: SBool = s_2 == s7332+  s7334 :: SWord8 = s7318 >>> 1+  s7335 :: SWord8 = s24 | s7334+  s7336 :: SWord8 = s26 & s7334+  s7337 :: SWord8 = if s7310 then s7335 else s7336+  s7338 :: SWord8 = s7337 >>> 1+  s7339 :: SWord8 = s24 | s7338+  s7340 :: SWord8 = s26 & s7338+  s7341 :: SWord8 = if s7332 then s7339 else s7340+  s7342 :: SWord8 = s18 & s7325+  s7343 :: SBool = s17 /= s7342+  s7344 :: SWord8 = s7330 >>> 1+  s7345 :: SWord8 = s24 | s7344+  s7346 :: SWord8 = s26 & s7344+  s7347 :: SWord8 = if s7343 then s7345 else s7346+  s7348 :: SWord8 = if s29 then s7307 else s7255+  s7349 :: SWord8 = if s170 then s7324 else s7348+  s7350 :: SWord8 = if s29 then s7329 else s7349+  s7351 :: SWord8 = if s170 then s7347 else s7350+  s7352 :: SWord8 = s7337 + s7351+  s7353 :: SBool = s7352 < s7351+  s7354 :: SBool = s7352 < s7337+  s7355 :: SBool = s7353 | s7354+  s7356 :: SWord8 = s7352 >>> 1+  s7357 :: SWord8 = s24 | s7356+  s7358 :: SWord8 = s26 & s7356+  s7359 :: SWord8 = if s7355 then s7357 else s7358+  s7360 :: SWord8 = if s7333 then s7341 else s7359+  s7361 :: SWord8 = s7318 + s7349+  s7362 :: SWord8 = s18 & s7361+  s7363 :: SBool = s17 /= s7362+  s7364 :: SWord8 = if s7363 then s7327 else s7328+  s7365 :: SWord8 = if s22 then s7364 else s7324+  s7366 :: SWord8 = s18 & s7365+  s7367 :: SBool = s17 /= s7366+  s7368 :: SBool = s_2 == s7367+  s7369 :: SBool = s7361 < s7349+  s7370 :: SBool = s7361 < s7318+  s7371 :: SBool = s7369 | s7370+  s7372 :: SWord8 = s7361 >>> 1+  s7373 :: SWord8 = s24 | s7372+  s7374 :: SWord8 = s26 & s7372+  s7375 :: SWord8 = if s7371 then s7373 else s7374+  s7376 :: SWord8 = s7375 >>> 1+  s7377 :: SWord8 = s24 | s7376+  s7378 :: SWord8 = s26 & s7376+  s7379 :: SWord8 = if s7367 then s7377 else s7378+  s7380 :: SWord8 = s7365 >>> 1+  s7381 :: SWord8 = s24 | s7380+  s7382 :: SWord8 = s26 & s7380+  s7383 :: SWord8 = if s7343 then s7381 else s7382+  s7384 :: SWord8 = if s29 then s7364 else s7349+  s7385 :: SWord8 = if s170 then s7383 else s7384+  s7386 :: SWord8 = s7375 + s7385+  s7387 :: SBool = s7386 < s7385+  s7388 :: SBool = s7386 < s7375+  s7389 :: SBool = s7387 | s7388+  s7390 :: SWord8 = s7386 >>> 1+  s7391 :: SWord8 = s24 | s7390+  s7392 :: SWord8 = s26 & s7390+  s7393 :: SWord8 = if s7389 then s7391 else s7392+  s7394 :: SWord8 = if s7368 then s7379 else s7393+  s7395 :: SWord8 = if s7311 then s7360 else s7394+  s7396 :: SWord8 = if s7196 then s7303 else s7395+  s7397 :: SWord8 = if s6965 then s7188 else s7396+  s7398 :: SWord8 = if s6502 then s6957 else s7397+  s7399 :: SWord8 = if s5575 then s6494 else s7398+  s7400 :: SWord8 = if s3725 then s5567 else s7399+  s7401 :: SWord8 = if s21 then s3717 else s7400+  s7402 :: SWord16 = s17 # s7401+  s7403 :: SWord16 = s16 * s7402+  s7404 :: SWord8 = s18 & s165+  s7405 :: SBool = s17 /= s7404+  s7406 :: SWord8 = if s22 then s176 else s157+  s7407 :: SWord8 = s7406 >>> 1+  s7408 :: SWord8 = s24 | s7407+  s7409 :: SWord8 = s26 & s7407+  s7410 :: SWord8 = if s7405 then s7408 else s7409+  s7411 :: SWord8 = s18 & s193+  s7412 :: SBool = s17 /= s7411+  s7413 :: SWord8 = if s7412 then s7408 else s7409+  s7414 :: SWord8 = if s161 then s7410 else s7413+  s7415 :: SWord8 = s18 & s216+  s7416 :: SBool = s17 /= s7415+  s7417 :: SWord8 = if s22 then s224 else s205+  s7418 :: SWord8 = s7417 >>> 1+  s7419 :: SWord8 = s24 | s7418+  s7420 :: SWord8 = s26 & s7418+  s7421 :: SWord8 = if s7416 then s7419 else s7420+  s7422 :: SWord8 = s18 & s227+  s7423 :: SBool = s17 /= s7422+  s7424 :: SWord8 = if s7423 then s7419 else s7420+  s7425 :: SWord8 = if s209 then s7421 else s7424+  s7426 :: SWord8 = if s140 then s7414 else s7425+  s7427 :: SWord8 = s18 & s270+  s7428 :: SBool = s17 /= s7427+  s7429 :: SWord8 = if s22 then s280 else s262+  s7430 :: SWord8 = s7429 >>> 1+  s7431 :: SWord8 = s24 | s7430+  s7432 :: SWord8 = s26 & s7430+  s7433 :: SWord8 = if s7428 then s7431 else s7432+  s7434 :: SWord8 = s18 & s285+  s7435 :: SBool = s17 /= s7434+  s7436 :: SWord8 = if s7435 then s7431 else s7432+  s7437 :: SWord8 = if s266 then s7433 else s7436+  s7438 :: SWord8 = s18 & s308+  s7439 :: SBool = s17 /= s7438+  s7440 :: SWord8 = if s22 then s316 else s297+  s7441 :: SWord8 = s7440 >>> 1+  s7442 :: SWord8 = s24 | s7441+  s7443 :: SWord8 = s26 & s7441+  s7444 :: SWord8 = if s7439 then s7442 else s7443+  s7445 :: SWord8 = s18 & s319+  s7446 :: SBool = s17 /= s7445+  s7447 :: SWord8 = if s7446 then s7442 else s7443+  s7448 :: SWord8 = if s301 then s7444 else s7447+  s7449 :: SWord8 = if s244 then s7437 else s7448+  s7450 :: SWord8 = if s119 then s7426 else s7449+  s7451 :: SWord8 = s18 & s384+  s7452 :: SBool = s17 /= s7451+  s7453 :: SWord8 = if s22 then s394 else s376+  s7454 :: SWord8 = s7453 >>> 1+  s7455 :: SWord8 = s24 | s7454+  s7456 :: SWord8 = s26 & s7454+  s7457 :: SWord8 = if s7452 then s7455 else s7456+  s7458 :: SWord8 = s18 & s401+  s7459 :: SBool = s17 /= s7458+  s7460 :: SWord8 = if s7459 then s7455 else s7456+  s7461 :: SWord8 = if s380 then s7457 else s7460+  s7462 :: SWord8 = s18 & s424+  s7463 :: SBool = s17 /= s7462+  s7464 :: SWord8 = if s22 then s432 else s413+  s7465 :: SWord8 = s7464 >>> 1+  s7466 :: SWord8 = s24 | s7465+  s7467 :: SWord8 = s26 & s7465+  s7468 :: SWord8 = if s7463 then s7466 else s7467+  s7469 :: SWord8 = s18 & s435+  s7470 :: SBool = s17 /= s7469+  s7471 :: SWord8 = if s7470 then s7466 else s7467+  s7472 :: SWord8 = if s417 then s7468 else s7471+  s7473 :: SWord8 = if s359 then s7461 else s7472+  s7474 :: SWord8 = s18 & s478+  s7475 :: SBool = s17 /= s7474+  s7476 :: SWord8 = if s22 then s488 else s470+  s7477 :: SWord8 = s7476 >>> 1+  s7478 :: SWord8 = s24 | s7477+  s7479 :: SWord8 = s26 & s7477+  s7480 :: SWord8 = if s7475 then s7478 else s7479+  s7481 :: SWord8 = s18 & s493+  s7482 :: SBool = s17 /= s7481+  s7483 :: SWord8 = if s7482 then s7478 else s7479+  s7484 :: SWord8 = if s474 then s7480 else s7483+  s7485 :: SWord8 = s18 & s516+  s7486 :: SBool = s17 /= s7485+  s7487 :: SWord8 = if s22 then s524 else s505+  s7488 :: SWord8 = s7487 >>> 1+  s7489 :: SWord8 = s24 | s7488+  s7490 :: SWord8 = s26 & s7488+  s7491 :: SWord8 = if s7486 then s7489 else s7490+  s7492 :: SWord8 = s18 & s527+  s7493 :: SBool = s17 /= s7492+  s7494 :: SWord8 = if s7493 then s7489 else s7490+  s7495 :: SWord8 = if s509 then s7491 else s7494+  s7496 :: SWord8 = if s452 then s7484 else s7495+  s7497 :: SWord8 = if s337 then s7473 else s7496+  s7498 :: SWord8 = if s98 then s7450 else s7497+  s7499 :: SWord8 = s18 & s614+  s7500 :: SBool = s17 /= s7499+  s7501 :: SWord8 = if s22 then s624 else s606+  s7502 :: SWord8 = s7501 >>> 1+  s7503 :: SWord8 = s24 | s7502+  s7504 :: SWord8 = s26 & s7502+  s7505 :: SWord8 = if s7500 then s7503 else s7504+  s7506 :: SWord8 = s18 & s633+  s7507 :: SBool = s17 /= s7506+  s7508 :: SWord8 = if s7507 then s7503 else s7504+  s7509 :: SWord8 = if s610 then s7505 else s7508+  s7510 :: SWord8 = s18 & s656+  s7511 :: SBool = s17 /= s7510+  s7512 :: SWord8 = if s22 then s664 else s645+  s7513 :: SWord8 = s7512 >>> 1+  s7514 :: SWord8 = s24 | s7513+  s7515 :: SWord8 = s26 & s7513+  s7516 :: SWord8 = if s7511 then s7514 else s7515+  s7517 :: SWord8 = s18 & s667+  s7518 :: SBool = s17 /= s7517+  s7519 :: SWord8 = if s7518 then s7514 else s7515+  s7520 :: SWord8 = if s649 then s7516 else s7519+  s7521 :: SWord8 = if s589 then s7509 else s7520+  s7522 :: SWord8 = s18 & s710+  s7523 :: SBool = s17 /= s7522+  s7524 :: SWord8 = if s22 then s720 else s702+  s7525 :: SWord8 = s7524 >>> 1+  s7526 :: SWord8 = s24 | s7525+  s7527 :: SWord8 = s26 & s7525+  s7528 :: SWord8 = if s7523 then s7526 else s7527+  s7529 :: SWord8 = s18 & s725+  s7530 :: SBool = s17 /= s7529+  s7531 :: SWord8 = if s7530 then s7526 else s7527+  s7532 :: SWord8 = if s706 then s7528 else s7531+  s7533 :: SWord8 = s18 & s748+  s7534 :: SBool = s17 /= s7533+  s7535 :: SWord8 = if s22 then s756 else s737+  s7536 :: SWord8 = s7535 >>> 1+  s7537 :: SWord8 = s24 | s7536+  s7538 :: SWord8 = s26 & s7536+  s7539 :: SWord8 = if s7534 then s7537 else s7538+  s7540 :: SWord8 = s18 & s759+  s7541 :: SBool = s17 /= s7540+  s7542 :: SWord8 = if s7541 then s7537 else s7538+  s7543 :: SWord8 = if s741 then s7539 else s7542+  s7544 :: SWord8 = if s684 then s7532 else s7543+  s7545 :: SWord8 = if s568 then s7521 else s7544+  s7546 :: SWord8 = s18 & s824+  s7547 :: SBool = s17 /= s7546+  s7548 :: SWord8 = if s22 then s834 else s816+  s7549 :: SWord8 = s7548 >>> 1+  s7550 :: SWord8 = s24 | s7549+  s7551 :: SWord8 = s26 & s7549+  s7552 :: SWord8 = if s7547 then s7550 else s7551+  s7553 :: SWord8 = s18 & s841+  s7554 :: SBool = s17 /= s7553+  s7555 :: SWord8 = if s7554 then s7550 else s7551+  s7556 :: SWord8 = if s820 then s7552 else s7555+  s7557 :: SWord8 = s18 & s864+  s7558 :: SBool = s17 /= s7557+  s7559 :: SWord8 = if s22 then s872 else s853+  s7560 :: SWord8 = s7559 >>> 1+  s7561 :: SWord8 = s24 | s7560+  s7562 :: SWord8 = s26 & s7560+  s7563 :: SWord8 = if s7558 then s7561 else s7562+  s7564 :: SWord8 = s18 & s875+  s7565 :: SBool = s17 /= s7564+  s7566 :: SWord8 = if s7565 then s7561 else s7562+  s7567 :: SWord8 = if s857 then s7563 else s7566+  s7568 :: SWord8 = if s799 then s7556 else s7567+  s7569 :: SWord8 = s18 & s918+  s7570 :: SBool = s17 /= s7569+  s7571 :: SWord8 = if s22 then s928 else s910+  s7572 :: SWord8 = s7571 >>> 1+  s7573 :: SWord8 = s24 | s7572+  s7574 :: SWord8 = s26 & s7572+  s7575 :: SWord8 = if s7570 then s7573 else s7574+  s7576 :: SWord8 = s18 & s933+  s7577 :: SBool = s17 /= s7576+  s7578 :: SWord8 = if s7577 then s7573 else s7574+  s7579 :: SWord8 = if s914 then s7575 else s7578+  s7580 :: SWord8 = s18 & s956+  s7581 :: SBool = s17 /= s7580+  s7582 :: SWord8 = if s22 then s964 else s945+  s7583 :: SWord8 = s7582 >>> 1+  s7584 :: SWord8 = s24 | s7583+  s7585 :: SWord8 = s26 & s7583+  s7586 :: SWord8 = if s7581 then s7584 else s7585+  s7587 :: SWord8 = s18 & s967+  s7588 :: SBool = s17 /= s7587+  s7589 :: SWord8 = if s7588 then s7584 else s7585+  s7590 :: SWord8 = if s949 then s7586 else s7589+  s7591 :: SWord8 = if s892 then s7579 else s7590+  s7592 :: SWord8 = if s777 then s7568 else s7591+  s7593 :: SWord8 = if s546 then s7545 else s7592+  s7594 :: SWord8 = if s77 then s7498 else s7593+  s7595 :: SWord8 = s18 & s1076+  s7596 :: SBool = s17 /= s7595+  s7597 :: SWord8 = if s22 then s1086 else s1068+  s7598 :: SWord8 = s7597 >>> 1+  s7599 :: SWord8 = s24 | s7598+  s7600 :: SWord8 = s26 & s7598+  s7601 :: SWord8 = if s7596 then s7599 else s7600+  s7602 :: SWord8 = s18 & s1097+  s7603 :: SBool = s17 /= s7602+  s7604 :: SWord8 = if s7603 then s7599 else s7600+  s7605 :: SWord8 = if s1072 then s7601 else s7604+  s7606 :: SWord8 = s18 & s1120+  s7607 :: SBool = s17 /= s7606+  s7608 :: SWord8 = if s22 then s1128 else s1109+  s7609 :: SWord8 = s7608 >>> 1+  s7610 :: SWord8 = s24 | s7609+  s7611 :: SWord8 = s26 & s7609+  s7612 :: SWord8 = if s7607 then s7610 else s7611+  s7613 :: SWord8 = s18 & s1131+  s7614 :: SBool = s17 /= s7613+  s7615 :: SWord8 = if s7614 then s7610 else s7611+  s7616 :: SWord8 = if s1113 then s7612 else s7615+  s7617 :: SWord8 = if s1051 then s7605 else s7616+  s7618 :: SWord8 = s18 & s1174+  s7619 :: SBool = s17 /= s7618+  s7620 :: SWord8 = if s22 then s1184 else s1166+  s7621 :: SWord8 = s7620 >>> 1+  s7622 :: SWord8 = s24 | s7621+  s7623 :: SWord8 = s26 & s7621+  s7624 :: SWord8 = if s7619 then s7622 else s7623+  s7625 :: SWord8 = s18 & s1189+  s7626 :: SBool = s17 /= s7625+  s7627 :: SWord8 = if s7626 then s7622 else s7623+  s7628 :: SWord8 = if s1170 then s7624 else s7627+  s7629 :: SWord8 = s18 & s1212+  s7630 :: SBool = s17 /= s7629+  s7631 :: SWord8 = if s22 then s1220 else s1201+  s7632 :: SWord8 = s7631 >>> 1+  s7633 :: SWord8 = s24 | s7632+  s7634 :: SWord8 = s26 & s7632+  s7635 :: SWord8 = if s7630 then s7633 else s7634+  s7636 :: SWord8 = s18 & s1223+  s7637 :: SBool = s17 /= s7636+  s7638 :: SWord8 = if s7637 then s7633 else s7634+  s7639 :: SWord8 = if s1205 then s7635 else s7638+  s7640 :: SWord8 = if s1148 then s7628 else s7639+  s7641 :: SWord8 = if s1030 then s7617 else s7640+  s7642 :: SWord8 = s18 & s1288+  s7643 :: SBool = s17 /= s7642+  s7644 :: SWord8 = if s22 then s1298 else s1280+  s7645 :: SWord8 = s7644 >>> 1+  s7646 :: SWord8 = s24 | s7645+  s7647 :: SWord8 = s26 & s7645+  s7648 :: SWord8 = if s7643 then s7646 else s7647+  s7649 :: SWord8 = s18 & s1305+  s7650 :: SBool = s17 /= s7649+  s7651 :: SWord8 = if s7650 then s7646 else s7647+  s7652 :: SWord8 = if s1284 then s7648 else s7651+  s7653 :: SWord8 = s18 & s1328+  s7654 :: SBool = s17 /= s7653+  s7655 :: SWord8 = if s22 then s1336 else s1317+  s7656 :: SWord8 = s7655 >>> 1+  s7657 :: SWord8 = s24 | s7656+  s7658 :: SWord8 = s26 & s7656+  s7659 :: SWord8 = if s7654 then s7657 else s7658+  s7660 :: SWord8 = s18 & s1339+  s7661 :: SBool = s17 /= s7660+  s7662 :: SWord8 = if s7661 then s7657 else s7658+  s7663 :: SWord8 = if s1321 then s7659 else s7662+  s7664 :: SWord8 = if s1263 then s7652 else s7663+  s7665 :: SWord8 = s18 & s1382+  s7666 :: SBool = s17 /= s7665+  s7667 :: SWord8 = if s22 then s1392 else s1374+  s7668 :: SWord8 = s7667 >>> 1+  s7669 :: SWord8 = s24 | s7668+  s7670 :: SWord8 = s26 & s7668+  s7671 :: SWord8 = if s7666 then s7669 else s7670+  s7672 :: SWord8 = s18 & s1397+  s7673 :: SBool = s17 /= s7672+  s7674 :: SWord8 = if s7673 then s7669 else s7670+  s7675 :: SWord8 = if s1378 then s7671 else s7674+  s7676 :: SWord8 = s18 & s1420+  s7677 :: SBool = s17 /= s7676+  s7678 :: SWord8 = if s22 then s1428 else s1409+  s7679 :: SWord8 = s7678 >>> 1+  s7680 :: SWord8 = s24 | s7679+  s7681 :: SWord8 = s26 & s7679+  s7682 :: SWord8 = if s7677 then s7680 else s7681+  s7683 :: SWord8 = s18 & s1431+  s7684 :: SBool = s17 /= s7683+  s7685 :: SWord8 = if s7684 then s7680 else s7681+  s7686 :: SWord8 = if s1413 then s7682 else s7685+  s7687 :: SWord8 = if s1356 then s7675 else s7686+  s7688 :: SWord8 = if s1241 then s7664 else s7687+  s7689 :: SWord8 = if s1009 then s7641 else s7688+  s7690 :: SWord8 = s18 & s1518+  s7691 :: SBool = s17 /= s7690+  s7692 :: SWord8 = if s22 then s1528 else s1510+  s7693 :: SWord8 = s7692 >>> 1+  s7694 :: SWord8 = s24 | s7693+  s7695 :: SWord8 = s26 & s7693+  s7696 :: SWord8 = if s7691 then s7694 else s7695+  s7697 :: SWord8 = s18 & s1537+  s7698 :: SBool = s17 /= s7697+  s7699 :: SWord8 = if s7698 then s7694 else s7695+  s7700 :: SWord8 = if s1514 then s7696 else s7699+  s7701 :: SWord8 = s18 & s1560+  s7702 :: SBool = s17 /= s7701+  s7703 :: SWord8 = if s22 then s1568 else s1549+  s7704 :: SWord8 = s7703 >>> 1+  s7705 :: SWord8 = s24 | s7704+  s7706 :: SWord8 = s26 & s7704+  s7707 :: SWord8 = if s7702 then s7705 else s7706+  s7708 :: SWord8 = s18 & s1571+  s7709 :: SBool = s17 /= s7708+  s7710 :: SWord8 = if s7709 then s7705 else s7706+  s7711 :: SWord8 = if s1553 then s7707 else s7710+  s7712 :: SWord8 = if s1493 then s7700 else s7711+  s7713 :: SWord8 = s18 & s1614+  s7714 :: SBool = s17 /= s7713+  s7715 :: SWord8 = if s22 then s1624 else s1606+  s7716 :: SWord8 = s7715 >>> 1+  s7717 :: SWord8 = s24 | s7716+  s7718 :: SWord8 = s26 & s7716+  s7719 :: SWord8 = if s7714 then s7717 else s7718+  s7720 :: SWord8 = s18 & s1629+  s7721 :: SBool = s17 /= s7720+  s7722 :: SWord8 = if s7721 then s7717 else s7718+  s7723 :: SWord8 = if s1610 then s7719 else s7722+  s7724 :: SWord8 = s18 & s1652+  s7725 :: SBool = s17 /= s7724+  s7726 :: SWord8 = if s22 then s1660 else s1641+  s7727 :: SWord8 = s7726 >>> 1+  s7728 :: SWord8 = s24 | s7727+  s7729 :: SWord8 = s26 & s7727+  s7730 :: SWord8 = if s7725 then s7728 else s7729+  s7731 :: SWord8 = s18 & s1663+  s7732 :: SBool = s17 /= s7731+  s7733 :: SWord8 = if s7732 then s7728 else s7729+  s7734 :: SWord8 = if s1645 then s7730 else s7733+  s7735 :: SWord8 = if s1588 then s7723 else s7734+  s7736 :: SWord8 = if s1472 then s7712 else s7735+  s7737 :: SWord8 = s18 & s1728+  s7738 :: SBool = s17 /= s7737+  s7739 :: SWord8 = if s22 then s1738 else s1720+  s7740 :: SWord8 = s7739 >>> 1+  s7741 :: SWord8 = s24 | s7740+  s7742 :: SWord8 = s26 & s7740+  s7743 :: SWord8 = if s7738 then s7741 else s7742+  s7744 :: SWord8 = s18 & s1745+  s7745 :: SBool = s17 /= s7744+  s7746 :: SWord8 = if s7745 then s7741 else s7742+  s7747 :: SWord8 = if s1724 then s7743 else s7746+  s7748 :: SWord8 = s18 & s1768+  s7749 :: SBool = s17 /= s7748+  s7750 :: SWord8 = if s22 then s1776 else s1757+  s7751 :: SWord8 = s7750 >>> 1+  s7752 :: SWord8 = s24 | s7751+  s7753 :: SWord8 = s26 & s7751+  s7754 :: SWord8 = if s7749 then s7752 else s7753+  s7755 :: SWord8 = s18 & s1779+  s7756 :: SBool = s17 /= s7755+  s7757 :: SWord8 = if s7756 then s7752 else s7753+  s7758 :: SWord8 = if s1761 then s7754 else s7757+  s7759 :: SWord8 = if s1703 then s7747 else s7758+  s7760 :: SWord8 = s18 & s1822+  s7761 :: SBool = s17 /= s7760+  s7762 :: SWord8 = if s22 then s1832 else s1814+  s7763 :: SWord8 = s7762 >>> 1+  s7764 :: SWord8 = s24 | s7763+  s7765 :: SWord8 = s26 & s7763+  s7766 :: SWord8 = if s7761 then s7764 else s7765+  s7767 :: SWord8 = s18 & s1837+  s7768 :: SBool = s17 /= s7767+  s7769 :: SWord8 = if s7768 then s7764 else s7765+  s7770 :: SWord8 = if s1818 then s7766 else s7769+  s7771 :: SWord8 = s18 & s1860+  s7772 :: SBool = s17 /= s7771+  s7773 :: SWord8 = if s22 then s1868 else s1849+  s7774 :: SWord8 = s7773 >>> 1+  s7775 :: SWord8 = s24 | s7774+  s7776 :: SWord8 = s26 & s7774+  s7777 :: SWord8 = if s7772 then s7775 else s7776+  s7778 :: SWord8 = s18 & s1871+  s7779 :: SBool = s17 /= s7778+  s7780 :: SWord8 = if s7779 then s7775 else s7776+  s7781 :: SWord8 = if s1853 then s7777 else s7780+  s7782 :: SWord8 = if s1796 then s7770 else s7781+  s7783 :: SWord8 = if s1681 then s7759 else s7782+  s7784 :: SWord8 = if s1450 then s7736 else s7783+  s7785 :: SWord8 = if s987 then s7689 else s7784+  s7786 :: SWord8 = if s56 then s7594 else s7785+  s7787 :: SWord8 = s18 & s2002+  s7788 :: SBool = s17 /= s7787+  s7789 :: SWord8 = if s22 then s2012 else s1994+  s7790 :: SWord8 = s7789 >>> 1+  s7791 :: SWord8 = s24 | s7790+  s7792 :: SWord8 = s26 & s7790+  s7793 :: SWord8 = if s7788 then s7791 else s7792+  s7794 :: SWord8 = s18 & s2025+  s7795 :: SBool = s17 /= s7794+  s7796 :: SWord8 = if s7795 then s7791 else s7792+  s7797 :: SWord8 = if s1998 then s7793 else s7796+  s7798 :: SWord8 = s18 & s2048+  s7799 :: SBool = s17 /= s7798+  s7800 :: SWord8 = if s22 then s2056 else s2037+  s7801 :: SWord8 = s7800 >>> 1+  s7802 :: SWord8 = s24 | s7801+  s7803 :: SWord8 = s26 & s7801+  s7804 :: SWord8 = if s7799 then s7802 else s7803+  s7805 :: SWord8 = s18 & s2059+  s7806 :: SBool = s17 /= s7805+  s7807 :: SWord8 = if s7806 then s7802 else s7803+  s7808 :: SWord8 = if s2041 then s7804 else s7807+  s7809 :: SWord8 = if s1977 then s7797 else s7808+  s7810 :: SWord8 = s18 & s2102+  s7811 :: SBool = s17 /= s7810+  s7812 :: SWord8 = if s22 then s2112 else s2094+  s7813 :: SWord8 = s7812 >>> 1+  s7814 :: SWord8 = s24 | s7813+  s7815 :: SWord8 = s26 & s7813+  s7816 :: SWord8 = if s7811 then s7814 else s7815+  s7817 :: SWord8 = s18 & s2117+  s7818 :: SBool = s17 /= s7817+  s7819 :: SWord8 = if s7818 then s7814 else s7815+  s7820 :: SWord8 = if s2098 then s7816 else s7819+  s7821 :: SWord8 = s18 & s2140+  s7822 :: SBool = s17 /= s7821+  s7823 :: SWord8 = if s22 then s2148 else s2129+  s7824 :: SWord8 = s7823 >>> 1+  s7825 :: SWord8 = s24 | s7824+  s7826 :: SWord8 = s26 & s7824+  s7827 :: SWord8 = if s7822 then s7825 else s7826+  s7828 :: SWord8 = s18 & s2151+  s7829 :: SBool = s17 /= s7828+  s7830 :: SWord8 = if s7829 then s7825 else s7826+  s7831 :: SWord8 = if s2133 then s7827 else s7830+  s7832 :: SWord8 = if s2076 then s7820 else s7831+  s7833 :: SWord8 = if s1956 then s7809 else s7832+  s7834 :: SWord8 = s18 & s2216+  s7835 :: SBool = s17 /= s7834+  s7836 :: SWord8 = if s22 then s2226 else s2208+  s7837 :: SWord8 = s7836 >>> 1+  s7838 :: SWord8 = s24 | s7837+  s7839 :: SWord8 = s26 & s7837+  s7840 :: SWord8 = if s7835 then s7838 else s7839+  s7841 :: SWord8 = s18 & s2233+  s7842 :: SBool = s17 /= s7841+  s7843 :: SWord8 = if s7842 then s7838 else s7839+  s7844 :: SWord8 = if s2212 then s7840 else s7843+  s7845 :: SWord8 = s18 & s2256+  s7846 :: SBool = s17 /= s7845+  s7847 :: SWord8 = if s22 then s2264 else s2245+  s7848 :: SWord8 = s7847 >>> 1+  s7849 :: SWord8 = s24 | s7848+  s7850 :: SWord8 = s26 & s7848+  s7851 :: SWord8 = if s7846 then s7849 else s7850+  s7852 :: SWord8 = s18 & s2267+  s7853 :: SBool = s17 /= s7852+  s7854 :: SWord8 = if s7853 then s7849 else s7850+  s7855 :: SWord8 = if s2249 then s7851 else s7854+  s7856 :: SWord8 = if s2191 then s7844 else s7855+  s7857 :: SWord8 = s18 & s2310+  s7858 :: SBool = s17 /= s7857+  s7859 :: SWord8 = if s22 then s2320 else s2302+  s7860 :: SWord8 = s7859 >>> 1+  s7861 :: SWord8 = s24 | s7860+  s7862 :: SWord8 = s26 & s7860+  s7863 :: SWord8 = if s7858 then s7861 else s7862+  s7864 :: SWord8 = s18 & s2325+  s7865 :: SBool = s17 /= s7864+  s7866 :: SWord8 = if s7865 then s7861 else s7862+  s7867 :: SWord8 = if s2306 then s7863 else s7866+  s7868 :: SWord8 = s18 & s2348+  s7869 :: SBool = s17 /= s7868+  s7870 :: SWord8 = if s22 then s2356 else s2337+  s7871 :: SWord8 = s7870 >>> 1+  s7872 :: SWord8 = s24 | s7871+  s7873 :: SWord8 = s26 & s7871+  s7874 :: SWord8 = if s7869 then s7872 else s7873+  s7875 :: SWord8 = s18 & s2359+  s7876 :: SBool = s17 /= s7875+  s7877 :: SWord8 = if s7876 then s7872 else s7873+  s7878 :: SWord8 = if s2341 then s7874 else s7877+  s7879 :: SWord8 = if s2284 then s7867 else s7878+  s7880 :: SWord8 = if s2169 then s7856 else s7879+  s7881 :: SWord8 = if s1935 then s7833 else s7880+  s7882 :: SWord8 = s18 & s2446+  s7883 :: SBool = s17 /= s7882+  s7884 :: SWord8 = if s22 then s2456 else s2438+  s7885 :: SWord8 = s7884 >>> 1+  s7886 :: SWord8 = s24 | s7885+  s7887 :: SWord8 = s26 & s7885+  s7888 :: SWord8 = if s7883 then s7886 else s7887+  s7889 :: SWord8 = s18 & s2465+  s7890 :: SBool = s17 /= s7889+  s7891 :: SWord8 = if s7890 then s7886 else s7887+  s7892 :: SWord8 = if s2442 then s7888 else s7891+  s7893 :: SWord8 = s18 & s2488+  s7894 :: SBool = s17 /= s7893+  s7895 :: SWord8 = if s22 then s2496 else s2477+  s7896 :: SWord8 = s7895 >>> 1+  s7897 :: SWord8 = s24 | s7896+  s7898 :: SWord8 = s26 & s7896+  s7899 :: SWord8 = if s7894 then s7897 else s7898+  s7900 :: SWord8 = s18 & s2499+  s7901 :: SBool = s17 /= s7900+  s7902 :: SWord8 = if s7901 then s7897 else s7898+  s7903 :: SWord8 = if s2481 then s7899 else s7902+  s7904 :: SWord8 = if s2421 then s7892 else s7903+  s7905 :: SWord8 = s18 & s2542+  s7906 :: SBool = s17 /= s7905+  s7907 :: SWord8 = if s22 then s2552 else s2534+  s7908 :: SWord8 = s7907 >>> 1+  s7909 :: SWord8 = s24 | s7908+  s7910 :: SWord8 = s26 & s7908+  s7911 :: SWord8 = if s7906 then s7909 else s7910+  s7912 :: SWord8 = s18 & s2557+  s7913 :: SBool = s17 /= s7912+  s7914 :: SWord8 = if s7913 then s7909 else s7910+  s7915 :: SWord8 = if s2538 then s7911 else s7914+  s7916 :: SWord8 = s18 & s2580+  s7917 :: SBool = s17 /= s7916+  s7918 :: SWord8 = if s22 then s2588 else s2569+  s7919 :: SWord8 = s7918 >>> 1+  s7920 :: SWord8 = s24 | s7919+  s7921 :: SWord8 = s26 & s7919+  s7922 :: SWord8 = if s7917 then s7920 else s7921+  s7923 :: SWord8 = s18 & s2591+  s7924 :: SBool = s17 /= s7923+  s7925 :: SWord8 = if s7924 then s7920 else s7921+  s7926 :: SWord8 = if s2573 then s7922 else s7925+  s7927 :: SWord8 = if s2516 then s7915 else s7926+  s7928 :: SWord8 = if s2400 then s7904 else s7927+  s7929 :: SWord8 = s18 & s2656+  s7930 :: SBool = s17 /= s7929+  s7931 :: SWord8 = if s22 then s2666 else s2648+  s7932 :: SWord8 = s7931 >>> 1+  s7933 :: SWord8 = s24 | s7932+  s7934 :: SWord8 = s26 & s7932+  s7935 :: SWord8 = if s7930 then s7933 else s7934+  s7936 :: SWord8 = s18 & s2673+  s7937 :: SBool = s17 /= s7936+  s7938 :: SWord8 = if s7937 then s7933 else s7934+  s7939 :: SWord8 = if s2652 then s7935 else s7938+  s7940 :: SWord8 = s18 & s2696+  s7941 :: SBool = s17 /= s7940+  s7942 :: SWord8 = if s22 then s2704 else s2685+  s7943 :: SWord8 = s7942 >>> 1+  s7944 :: SWord8 = s24 | s7943+  s7945 :: SWord8 = s26 & s7943+  s7946 :: SWord8 = if s7941 then s7944 else s7945+  s7947 :: SWord8 = s18 & s2707+  s7948 :: SBool = s17 /= s7947+  s7949 :: SWord8 = if s7948 then s7944 else s7945+  s7950 :: SWord8 = if s2689 then s7946 else s7949+  s7951 :: SWord8 = if s2631 then s7939 else s7950+  s7952 :: SWord8 = s18 & s2750+  s7953 :: SBool = s17 /= s7952+  s7954 :: SWord8 = if s22 then s2760 else s2742+  s7955 :: SWord8 = s7954 >>> 1+  s7956 :: SWord8 = s24 | s7955+  s7957 :: SWord8 = s26 & s7955+  s7958 :: SWord8 = if s7953 then s7956 else s7957+  s7959 :: SWord8 = s18 & s2765+  s7960 :: SBool = s17 /= s7959+  s7961 :: SWord8 = if s7960 then s7956 else s7957+  s7962 :: SWord8 = if s2746 then s7958 else s7961+  s7963 :: SWord8 = s18 & s2788+  s7964 :: SBool = s17 /= s7963+  s7965 :: SWord8 = if s22 then s2796 else s2777+  s7966 :: SWord8 = s7965 >>> 1+  s7967 :: SWord8 = s24 | s7966+  s7968 :: SWord8 = s26 & s7966+  s7969 :: SWord8 = if s7964 then s7967 else s7968+  s7970 :: SWord8 = s18 & s2799+  s7971 :: SBool = s17 /= s7970+  s7972 :: SWord8 = if s7971 then s7967 else s7968+  s7973 :: SWord8 = if s2781 then s7969 else s7972+  s7974 :: SWord8 = if s2724 then s7962 else s7973+  s7975 :: SWord8 = if s2609 then s7951 else s7974+  s7976 :: SWord8 = if s2378 then s7928 else s7975+  s7977 :: SWord8 = if s1914 then s7881 else s7976+  s7978 :: SWord8 = s18 & s2908+  s7979 :: SBool = s17 /= s7978+  s7980 :: SWord8 = if s22 then s2918 else s2900+  s7981 :: SWord8 = s7980 >>> 1+  s7982 :: SWord8 = s24 | s7981+  s7983 :: SWord8 = s26 & s7981+  s7984 :: SWord8 = if s7979 then s7982 else s7983+  s7985 :: SWord8 = s18 & s2929+  s7986 :: SBool = s17 /= s7985+  s7987 :: SWord8 = if s7986 then s7982 else s7983+  s7988 :: SWord8 = if s2904 then s7984 else s7987+  s7989 :: SWord8 = s18 & s2952+  s7990 :: SBool = s17 /= s7989+  s7991 :: SWord8 = if s22 then s2960 else s2941+  s7992 :: SWord8 = s7991 >>> 1+  s7993 :: SWord8 = s24 | s7992+  s7994 :: SWord8 = s26 & s7992+  s7995 :: SWord8 = if s7990 then s7993 else s7994+  s7996 :: SWord8 = s18 & s2963+  s7997 :: SBool = s17 /= s7996+  s7998 :: SWord8 = if s7997 then s7993 else s7994+  s7999 :: SWord8 = if s2945 then s7995 else s7998+  s8000 :: SWord8 = if s2883 then s7988 else s7999+  s8001 :: SWord8 = s18 & s3006+  s8002 :: SBool = s17 /= s8001+  s8003 :: SWord8 = if s22 then s3016 else s2998+  s8004 :: SWord8 = s8003 >>> 1+  s8005 :: SWord8 = s24 | s8004+  s8006 :: SWord8 = s26 & s8004+  s8007 :: SWord8 = if s8002 then s8005 else s8006+  s8008 :: SWord8 = s18 & s3021+  s8009 :: SBool = s17 /= s8008+  s8010 :: SWord8 = if s8009 then s8005 else s8006+  s8011 :: SWord8 = if s3002 then s8007 else s8010+  s8012 :: SWord8 = s18 & s3044+  s8013 :: SBool = s17 /= s8012+  s8014 :: SWord8 = if s22 then s3052 else s3033+  s8015 :: SWord8 = s8014 >>> 1+  s8016 :: SWord8 = s24 | s8015+  s8017 :: SWord8 = s26 & s8015+  s8018 :: SWord8 = if s8013 then s8016 else s8017+  s8019 :: SWord8 = s18 & s3055+  s8020 :: SBool = s17 /= s8019+  s8021 :: SWord8 = if s8020 then s8016 else s8017+  s8022 :: SWord8 = if s3037 then s8018 else s8021+  s8023 :: SWord8 = if s2980 then s8011 else s8022+  s8024 :: SWord8 = if s2862 then s8000 else s8023+  s8025 :: SWord8 = s18 & s3120+  s8026 :: SBool = s17 /= s8025+  s8027 :: SWord8 = if s22 then s3130 else s3112+  s8028 :: SWord8 = s8027 >>> 1+  s8029 :: SWord8 = s24 | s8028+  s8030 :: SWord8 = s26 & s8028+  s8031 :: SWord8 = if s8026 then s8029 else s8030+  s8032 :: SWord8 = s18 & s3137+  s8033 :: SBool = s17 /= s8032+  s8034 :: SWord8 = if s8033 then s8029 else s8030+  s8035 :: SWord8 = if s3116 then s8031 else s8034+  s8036 :: SWord8 = s18 & s3160+  s8037 :: SBool = s17 /= s8036+  s8038 :: SWord8 = if s22 then s3168 else s3149+  s8039 :: SWord8 = s8038 >>> 1+  s8040 :: SWord8 = s24 | s8039+  s8041 :: SWord8 = s26 & s8039+  s8042 :: SWord8 = if s8037 then s8040 else s8041+  s8043 :: SWord8 = s18 & s3171+  s8044 :: SBool = s17 /= s8043+  s8045 :: SWord8 = if s8044 then s8040 else s8041+  s8046 :: SWord8 = if s3153 then s8042 else s8045+  s8047 :: SWord8 = if s3095 then s8035 else s8046+  s8048 :: SWord8 = s18 & s3214+  s8049 :: SBool = s17 /= s8048+  s8050 :: SWord8 = if s22 then s3224 else s3206+  s8051 :: SWord8 = s8050 >>> 1+  s8052 :: SWord8 = s24 | s8051+  s8053 :: SWord8 = s26 & s8051+  s8054 :: SWord8 = if s8049 then s8052 else s8053+  s8055 :: SWord8 = s18 & s3229+  s8056 :: SBool = s17 /= s8055+  s8057 :: SWord8 = if s8056 then s8052 else s8053+  s8058 :: SWord8 = if s3210 then s8054 else s8057+  s8059 :: SWord8 = s18 & s3252+  s8060 :: SBool = s17 /= s8059+  s8061 :: SWord8 = if s22 then s3260 else s3241+  s8062 :: SWord8 = s8061 >>> 1+  s8063 :: SWord8 = s24 | s8062+  s8064 :: SWord8 = s26 & s8062+  s8065 :: SWord8 = if s8060 then s8063 else s8064+  s8066 :: SWord8 = s18 & s3263+  s8067 :: SBool = s17 /= s8066+  s8068 :: SWord8 = if s8067 then s8063 else s8064+  s8069 :: SWord8 = if s3245 then s8065 else s8068+  s8070 :: SWord8 = if s3188 then s8058 else s8069+  s8071 :: SWord8 = if s3073 then s8047 else s8070+  s8072 :: SWord8 = if s2841 then s8024 else s8071+  s8073 :: SWord8 = s18 & s3350+  s8074 :: SBool = s17 /= s8073+  s8075 :: SWord8 = if s22 then s3360 else s3342+  s8076 :: SWord8 = s8075 >>> 1+  s8077 :: SWord8 = s24 | s8076+  s8078 :: SWord8 = s26 & s8076+  s8079 :: SWord8 = if s8074 then s8077 else s8078+  s8080 :: SWord8 = s18 & s3369+  s8081 :: SBool = s17 /= s8080+  s8082 :: SWord8 = if s8081 then s8077 else s8078+  s8083 :: SWord8 = if s3346 then s8079 else s8082+  s8084 :: SWord8 = s18 & s3392+  s8085 :: SBool = s17 /= s8084+  s8086 :: SWord8 = if s22 then s3400 else s3381+  s8087 :: SWord8 = s8086 >>> 1+  s8088 :: SWord8 = s24 | s8087+  s8089 :: SWord8 = s26 & s8087+  s8090 :: SWord8 = if s8085 then s8088 else s8089+  s8091 :: SWord8 = s18 & s3403+  s8092 :: SBool = s17 /= s8091+  s8093 :: SWord8 = if s8092 then s8088 else s8089+  s8094 :: SWord8 = if s3385 then s8090 else s8093+  s8095 :: SWord8 = if s3325 then s8083 else s8094+  s8096 :: SWord8 = s18 & s3446+  s8097 :: SBool = s17 /= s8096+  s8098 :: SWord8 = if s22 then s3456 else s3438+  s8099 :: SWord8 = s8098 >>> 1+  s8100 :: SWord8 = s24 | s8099+  s8101 :: SWord8 = s26 & s8099+  s8102 :: SWord8 = if s8097 then s8100 else s8101+  s8103 :: SWord8 = s18 & s3461+  s8104 :: SBool = s17 /= s8103+  s8105 :: SWord8 = if s8104 then s8100 else s8101+  s8106 :: SWord8 = if s3442 then s8102 else s8105+  s8107 :: SWord8 = s18 & s3484+  s8108 :: SBool = s17 /= s8107+  s8109 :: SWord8 = if s22 then s3492 else s3473+  s8110 :: SWord8 = s8109 >>> 1+  s8111 :: SWord8 = s24 | s8110+  s8112 :: SWord8 = s26 & s8110+  s8113 :: SWord8 = if s8108 then s8111 else s8112+  s8114 :: SWord8 = s18 & s3495+  s8115 :: SBool = s17 /= s8114+  s8116 :: SWord8 = if s8115 then s8111 else s8112+  s8117 :: SWord8 = if s3477 then s8113 else s8116+  s8118 :: SWord8 = if s3420 then s8106 else s8117+  s8119 :: SWord8 = if s3304 then s8095 else s8118+  s8120 :: SWord8 = s18 & s3560+  s8121 :: SBool = s17 /= s8120+  s8122 :: SWord8 = if s22 then s3570 else s3552+  s8123 :: SWord8 = s8122 >>> 1+  s8124 :: SWord8 = s24 | s8123+  s8125 :: SWord8 = s26 & s8123+  s8126 :: SWord8 = if s8121 then s8124 else s8125+  s8127 :: SWord8 = s18 & s3577+  s8128 :: SBool = s17 /= s8127+  s8129 :: SWord8 = if s8128 then s8124 else s8125+  s8130 :: SWord8 = if s3556 then s8126 else s8129+  s8131 :: SWord8 = s18 & s3600+  s8132 :: SBool = s17 /= s8131+  s8133 :: SWord8 = if s22 then s3608 else s3589+  s8134 :: SWord8 = s8133 >>> 1+  s8135 :: SWord8 = s24 | s8134+  s8136 :: SWord8 = s26 & s8134+  s8137 :: SWord8 = if s8132 then s8135 else s8136+  s8138 :: SWord8 = s18 & s3611+  s8139 :: SBool = s17 /= s8138+  s8140 :: SWord8 = if s8139 then s8135 else s8136+  s8141 :: SWord8 = if s3593 then s8137 else s8140+  s8142 :: SWord8 = if s3535 then s8130 else s8141+  s8143 :: SWord8 = s18 & s3654+  s8144 :: SBool = s17 /= s8143+  s8145 :: SWord8 = if s22 then s3664 else s3646+  s8146 :: SWord8 = s8145 >>> 1+  s8147 :: SWord8 = s24 | s8146+  s8148 :: SWord8 = s26 & s8146+  s8149 :: SWord8 = if s8144 then s8147 else s8148+  s8150 :: SWord8 = s18 & s3669+  s8151 :: SBool = s17 /= s8150+  s8152 :: SWord8 = if s8151 then s8147 else s8148+  s8153 :: SWord8 = if s3650 then s8149 else s8152+  s8154 :: SWord8 = s18 & s3692+  s8155 :: SBool = s17 /= s8154+  s8156 :: SWord8 = if s22 then s3700 else s3681+  s8157 :: SWord8 = s8156 >>> 1+  s8158 :: SWord8 = s24 | s8157+  s8159 :: SWord8 = s26 & s8157+  s8160 :: SWord8 = if s8155 then s8158 else s8159+  s8161 :: SWord8 = s18 & s3703+  s8162 :: SBool = s17 /= s8161+  s8163 :: SWord8 = if s8162 then s8158 else s8159+  s8164 :: SWord8 = if s3685 then s8160 else s8163+  s8165 :: SWord8 = if s3628 then s8153 else s8164+  s8166 :: SWord8 = if s3513 then s8142 else s8165+  s8167 :: SWord8 = if s3282 then s8119 else s8166+  s8168 :: SWord8 = if s2819 then s8072 else s8167+  s8169 :: SWord8 = if s1892 then s7977 else s8168+  s8170 :: SWord8 = if s38 then s7786 else s8169+  s8171 :: SWord8 = s18 & s3851+  s8172 :: SBool = s17 /= s8171+  s8173 :: SWord8 = if s22 then s3861 else s3843+  s8174 :: SWord8 = s8173 >>> 1+  s8175 :: SWord8 = s24 | s8174+  s8176 :: SWord8 = s26 & s8174+  s8177 :: SWord8 = if s8172 then s8175 else s8176+  s8178 :: SWord8 = s18 & s3876+  s8179 :: SBool = s17 /= s8178+  s8180 :: SWord8 = if s8179 then s8175 else s8176+  s8181 :: SWord8 = if s3847 then s8177 else s8180+  s8182 :: SWord8 = s18 & s3899+  s8183 :: SBool = s17 /= s8182+  s8184 :: SWord8 = if s22 then s3907 else s3888+  s8185 :: SWord8 = s8184 >>> 1+  s8186 :: SWord8 = s24 | s8185+  s8187 :: SWord8 = s26 & s8185+  s8188 :: SWord8 = if s8183 then s8186 else s8187+  s8189 :: SWord8 = s18 & s3910+  s8190 :: SBool = s17 /= s8189+  s8191 :: SWord8 = if s8190 then s8186 else s8187+  s8192 :: SWord8 = if s3892 then s8188 else s8191+  s8193 :: SWord8 = if s3826 then s8181 else s8192+  s8194 :: SWord8 = s18 & s3953+  s8195 :: SBool = s17 /= s8194+  s8196 :: SWord8 = if s22 then s3963 else s3945+  s8197 :: SWord8 = s8196 >>> 1+  s8198 :: SWord8 = s24 | s8197+  s8199 :: SWord8 = s26 & s8197+  s8200 :: SWord8 = if s8195 then s8198 else s8199+  s8201 :: SWord8 = s18 & s3968+  s8202 :: SBool = s17 /= s8201+  s8203 :: SWord8 = if s8202 then s8198 else s8199+  s8204 :: SWord8 = if s3949 then s8200 else s8203+  s8205 :: SWord8 = s18 & s3991+  s8206 :: SBool = s17 /= s8205+  s8207 :: SWord8 = if s22 then s3999 else s3980+  s8208 :: SWord8 = s8207 >>> 1+  s8209 :: SWord8 = s24 | s8208+  s8210 :: SWord8 = s26 & s8208+  s8211 :: SWord8 = if s8206 then s8209 else s8210+  s8212 :: SWord8 = s18 & s4002+  s8213 :: SBool = s17 /= s8212+  s8214 :: SWord8 = if s8213 then s8209 else s8210+  s8215 :: SWord8 = if s3984 then s8211 else s8214+  s8216 :: SWord8 = if s3927 then s8204 else s8215+  s8217 :: SWord8 = if s3805 then s8193 else s8216+  s8218 :: SWord8 = s18 & s4067+  s8219 :: SBool = s17 /= s8218+  s8220 :: SWord8 = if s22 then s4077 else s4059+  s8221 :: SWord8 = s8220 >>> 1+  s8222 :: SWord8 = s24 | s8221+  s8223 :: SWord8 = s26 & s8221+  s8224 :: SWord8 = if s8219 then s8222 else s8223+  s8225 :: SWord8 = s18 & s4084+  s8226 :: SBool = s17 /= s8225+  s8227 :: SWord8 = if s8226 then s8222 else s8223+  s8228 :: SWord8 = if s4063 then s8224 else s8227+  s8229 :: SWord8 = s18 & s4107+  s8230 :: SBool = s17 /= s8229+  s8231 :: SWord8 = if s22 then s4115 else s4096+  s8232 :: SWord8 = s8231 >>> 1+  s8233 :: SWord8 = s24 | s8232+  s8234 :: SWord8 = s26 & s8232+  s8235 :: SWord8 = if s8230 then s8233 else s8234+  s8236 :: SWord8 = s18 & s4118+  s8237 :: SBool = s17 /= s8236+  s8238 :: SWord8 = if s8237 then s8233 else s8234+  s8239 :: SWord8 = if s4100 then s8235 else s8238+  s8240 :: SWord8 = if s4042 then s8228 else s8239+  s8241 :: SWord8 = s18 & s4161+  s8242 :: SBool = s17 /= s8241+  s8243 :: SWord8 = if s22 then s4171 else s4153+  s8244 :: SWord8 = s8243 >>> 1+  s8245 :: SWord8 = s24 | s8244+  s8246 :: SWord8 = s26 & s8244+  s8247 :: SWord8 = if s8242 then s8245 else s8246+  s8248 :: SWord8 = s18 & s4176+  s8249 :: SBool = s17 /= s8248+  s8250 :: SWord8 = if s8249 then s8245 else s8246+  s8251 :: SWord8 = if s4157 then s8247 else s8250+  s8252 :: SWord8 = s18 & s4199+  s8253 :: SBool = s17 /= s8252+  s8254 :: SWord8 = if s22 then s4207 else s4188+  s8255 :: SWord8 = s8254 >>> 1+  s8256 :: SWord8 = s24 | s8255+  s8257 :: SWord8 = s26 & s8255+  s8258 :: SWord8 = if s8253 then s8256 else s8257+  s8259 :: SWord8 = s18 & s4210+  s8260 :: SBool = s17 /= s8259+  s8261 :: SWord8 = if s8260 then s8256 else s8257+  s8262 :: SWord8 = if s4192 then s8258 else s8261+  s8263 :: SWord8 = if s4135 then s8251 else s8262+  s8264 :: SWord8 = if s4020 then s8240 else s8263+  s8265 :: SWord8 = if s3784 then s8217 else s8264+  s8266 :: SWord8 = s18 & s4297+  s8267 :: SBool = s17 /= s8266+  s8268 :: SWord8 = if s22 then s4307 else s4289+  s8269 :: SWord8 = s8268 >>> 1+  s8270 :: SWord8 = s24 | s8269+  s8271 :: SWord8 = s26 & s8269+  s8272 :: SWord8 = if s8267 then s8270 else s8271+  s8273 :: SWord8 = s18 & s4316+  s8274 :: SBool = s17 /= s8273+  s8275 :: SWord8 = if s8274 then s8270 else s8271+  s8276 :: SWord8 = if s4293 then s8272 else s8275+  s8277 :: SWord8 = s18 & s4339+  s8278 :: SBool = s17 /= s8277+  s8279 :: SWord8 = if s22 then s4347 else s4328+  s8280 :: SWord8 = s8279 >>> 1+  s8281 :: SWord8 = s24 | s8280+  s8282 :: SWord8 = s26 & s8280+  s8283 :: SWord8 = if s8278 then s8281 else s8282+  s8284 :: SWord8 = s18 & s4350+  s8285 :: SBool = s17 /= s8284+  s8286 :: SWord8 = if s8285 then s8281 else s8282+  s8287 :: SWord8 = if s4332 then s8283 else s8286+  s8288 :: SWord8 = if s4272 then s8276 else s8287+  s8289 :: SWord8 = s18 & s4393+  s8290 :: SBool = s17 /= s8289+  s8291 :: SWord8 = if s22 then s4403 else s4385+  s8292 :: SWord8 = s8291 >>> 1+  s8293 :: SWord8 = s24 | s8292+  s8294 :: SWord8 = s26 & s8292+  s8295 :: SWord8 = if s8290 then s8293 else s8294+  s8296 :: SWord8 = s18 & s4408+  s8297 :: SBool = s17 /= s8296+  s8298 :: SWord8 = if s8297 then s8293 else s8294+  s8299 :: SWord8 = if s4389 then s8295 else s8298+  s8300 :: SWord8 = s18 & s4431+  s8301 :: SBool = s17 /= s8300+  s8302 :: SWord8 = if s22 then s4439 else s4420+  s8303 :: SWord8 = s8302 >>> 1+  s8304 :: SWord8 = s24 | s8303+  s8305 :: SWord8 = s26 & s8303+  s8306 :: SWord8 = if s8301 then s8304 else s8305+  s8307 :: SWord8 = s18 & s4442+  s8308 :: SBool = s17 /= s8307+  s8309 :: SWord8 = if s8308 then s8304 else s8305+  s8310 :: SWord8 = if s4424 then s8306 else s8309+  s8311 :: SWord8 = if s4367 then s8299 else s8310+  s8312 :: SWord8 = if s4251 then s8288 else s8311+  s8313 :: SWord8 = s18 & s4507+  s8314 :: SBool = s17 /= s8313+  s8315 :: SWord8 = if s22 then s4517 else s4499+  s8316 :: SWord8 = s8315 >>> 1+  s8317 :: SWord8 = s24 | s8316+  s8318 :: SWord8 = s26 & s8316+  s8319 :: SWord8 = if s8314 then s8317 else s8318+  s8320 :: SWord8 = s18 & s4524+  s8321 :: SBool = s17 /= s8320+  s8322 :: SWord8 = if s8321 then s8317 else s8318+  s8323 :: SWord8 = if s4503 then s8319 else s8322+  s8324 :: SWord8 = s18 & s4547+  s8325 :: SBool = s17 /= s8324+  s8326 :: SWord8 = if s22 then s4555 else s4536+  s8327 :: SWord8 = s8326 >>> 1+  s8328 :: SWord8 = s24 | s8327+  s8329 :: SWord8 = s26 & s8327+  s8330 :: SWord8 = if s8325 then s8328 else s8329+  s8331 :: SWord8 = s18 & s4558+  s8332 :: SBool = s17 /= s8331+  s8333 :: SWord8 = if s8332 then s8328 else s8329+  s8334 :: SWord8 = if s4540 then s8330 else s8333+  s8335 :: SWord8 = if s4482 then s8323 else s8334+  s8336 :: SWord8 = s18 & s4601+  s8337 :: SBool = s17 /= s8336+  s8338 :: SWord8 = if s22 then s4611 else s4593+  s8339 :: SWord8 = s8338 >>> 1+  s8340 :: SWord8 = s24 | s8339+  s8341 :: SWord8 = s26 & s8339+  s8342 :: SWord8 = if s8337 then s8340 else s8341+  s8343 :: SWord8 = s18 & s4616+  s8344 :: SBool = s17 /= s8343+  s8345 :: SWord8 = if s8344 then s8340 else s8341+  s8346 :: SWord8 = if s4597 then s8342 else s8345+  s8347 :: SWord8 = s18 & s4639+  s8348 :: SBool = s17 /= s8347+  s8349 :: SWord8 = if s22 then s4647 else s4628+  s8350 :: SWord8 = s8349 >>> 1+  s8351 :: SWord8 = s24 | s8350+  s8352 :: SWord8 = s26 & s8350+  s8353 :: SWord8 = if s8348 then s8351 else s8352+  s8354 :: SWord8 = s18 & s4650+  s8355 :: SBool = s17 /= s8354+  s8356 :: SWord8 = if s8355 then s8351 else s8352+  s8357 :: SWord8 = if s4632 then s8353 else s8356+  s8358 :: SWord8 = if s4575 then s8346 else s8357+  s8359 :: SWord8 = if s4460 then s8335 else s8358+  s8360 :: SWord8 = if s4229 then s8312 else s8359+  s8361 :: SWord8 = if s3763 then s8265 else s8360+  s8362 :: SWord8 = s18 & s4759+  s8363 :: SBool = s17 /= s8362+  s8364 :: SWord8 = if s22 then s4769 else s4751+  s8365 :: SWord8 = s8364 >>> 1+  s8366 :: SWord8 = s24 | s8365+  s8367 :: SWord8 = s26 & s8365+  s8368 :: SWord8 = if s8363 then s8366 else s8367+  s8369 :: SWord8 = s18 & s4780+  s8370 :: SBool = s17 /= s8369+  s8371 :: SWord8 = if s8370 then s8366 else s8367+  s8372 :: SWord8 = if s4755 then s8368 else s8371+  s8373 :: SWord8 = s18 & s4803+  s8374 :: SBool = s17 /= s8373+  s8375 :: SWord8 = if s22 then s4811 else s4792+  s8376 :: SWord8 = s8375 >>> 1+  s8377 :: SWord8 = s24 | s8376+  s8378 :: SWord8 = s26 & s8376+  s8379 :: SWord8 = if s8374 then s8377 else s8378+  s8380 :: SWord8 = s18 & s4814+  s8381 :: SBool = s17 /= s8380+  s8382 :: SWord8 = if s8381 then s8377 else s8378+  s8383 :: SWord8 = if s4796 then s8379 else s8382+  s8384 :: SWord8 = if s4734 then s8372 else s8383+  s8385 :: SWord8 = s18 & s4857+  s8386 :: SBool = s17 /= s8385+  s8387 :: SWord8 = if s22 then s4867 else s4849+  s8388 :: SWord8 = s8387 >>> 1+  s8389 :: SWord8 = s24 | s8388+  s8390 :: SWord8 = s26 & s8388+  s8391 :: SWord8 = if s8386 then s8389 else s8390+  s8392 :: SWord8 = s18 & s4872+  s8393 :: SBool = s17 /= s8392+  s8394 :: SWord8 = if s8393 then s8389 else s8390+  s8395 :: SWord8 = if s4853 then s8391 else s8394+  s8396 :: SWord8 = s18 & s4895+  s8397 :: SBool = s17 /= s8396+  s8398 :: SWord8 = if s22 then s4903 else s4884+  s8399 :: SWord8 = s8398 >>> 1+  s8400 :: SWord8 = s24 | s8399+  s8401 :: SWord8 = s26 & s8399+  s8402 :: SWord8 = if s8397 then s8400 else s8401+  s8403 :: SWord8 = s18 & s4906+  s8404 :: SBool = s17 /= s8403+  s8405 :: SWord8 = if s8404 then s8400 else s8401+  s8406 :: SWord8 = if s4888 then s8402 else s8405+  s8407 :: SWord8 = if s4831 then s8395 else s8406+  s8408 :: SWord8 = if s4713 then s8384 else s8407+  s8409 :: SWord8 = s18 & s4971+  s8410 :: SBool = s17 /= s8409+  s8411 :: SWord8 = if s22 then s4981 else s4963+  s8412 :: SWord8 = s8411 >>> 1+  s8413 :: SWord8 = s24 | s8412+  s8414 :: SWord8 = s26 & s8412+  s8415 :: SWord8 = if s8410 then s8413 else s8414+  s8416 :: SWord8 = s18 & s4988+  s8417 :: SBool = s17 /= s8416+  s8418 :: SWord8 = if s8417 then s8413 else s8414+  s8419 :: SWord8 = if s4967 then s8415 else s8418+  s8420 :: SWord8 = s18 & s5011+  s8421 :: SBool = s17 /= s8420+  s8422 :: SWord8 = if s22 then s5019 else s5000+  s8423 :: SWord8 = s8422 >>> 1+  s8424 :: SWord8 = s24 | s8423+  s8425 :: SWord8 = s26 & s8423+  s8426 :: SWord8 = if s8421 then s8424 else s8425+  s8427 :: SWord8 = s18 & s5022+  s8428 :: SBool = s17 /= s8427+  s8429 :: SWord8 = if s8428 then s8424 else s8425+  s8430 :: SWord8 = if s5004 then s8426 else s8429+  s8431 :: SWord8 = if s4946 then s8419 else s8430+  s8432 :: SWord8 = s18 & s5065+  s8433 :: SBool = s17 /= s8432+  s8434 :: SWord8 = if s22 then s5075 else s5057+  s8435 :: SWord8 = s8434 >>> 1+  s8436 :: SWord8 = s24 | s8435+  s8437 :: SWord8 = s26 & s8435+  s8438 :: SWord8 = if s8433 then s8436 else s8437+  s8439 :: SWord8 = s18 & s5080+  s8440 :: SBool = s17 /= s8439+  s8441 :: SWord8 = if s8440 then s8436 else s8437+  s8442 :: SWord8 = if s5061 then s8438 else s8441+  s8443 :: SWord8 = s18 & s5103+  s8444 :: SBool = s17 /= s8443+  s8445 :: SWord8 = if s22 then s5111 else s5092+  s8446 :: SWord8 = s8445 >>> 1+  s8447 :: SWord8 = s24 | s8446+  s8448 :: SWord8 = s26 & s8446+  s8449 :: SWord8 = if s8444 then s8447 else s8448+  s8450 :: SWord8 = s18 & s5114+  s8451 :: SBool = s17 /= s8450+  s8452 :: SWord8 = if s8451 then s8447 else s8448+  s8453 :: SWord8 = if s5096 then s8449 else s8452+  s8454 :: SWord8 = if s5039 then s8442 else s8453+  s8455 :: SWord8 = if s4924 then s8431 else s8454+  s8456 :: SWord8 = if s4692 then s8408 else s8455+  s8457 :: SWord8 = s18 & s5201+  s8458 :: SBool = s17 /= s8457+  s8459 :: SWord8 = if s22 then s5211 else s5193+  s8460 :: SWord8 = s8459 >>> 1+  s8461 :: SWord8 = s24 | s8460+  s8462 :: SWord8 = s26 & s8460+  s8463 :: SWord8 = if s8458 then s8461 else s8462+  s8464 :: SWord8 = s18 & s5220+  s8465 :: SBool = s17 /= s8464+  s8466 :: SWord8 = if s8465 then s8461 else s8462+  s8467 :: SWord8 = if s5197 then s8463 else s8466+  s8468 :: SWord8 = s18 & s5243+  s8469 :: SBool = s17 /= s8468+  s8470 :: SWord8 = if s22 then s5251 else s5232+  s8471 :: SWord8 = s8470 >>> 1+  s8472 :: SWord8 = s24 | s8471+  s8473 :: SWord8 = s26 & s8471+  s8474 :: SWord8 = if s8469 then s8472 else s8473+  s8475 :: SWord8 = s18 & s5254+  s8476 :: SBool = s17 /= s8475+  s8477 :: SWord8 = if s8476 then s8472 else s8473+  s8478 :: SWord8 = if s5236 then s8474 else s8477+  s8479 :: SWord8 = if s5176 then s8467 else s8478+  s8480 :: SWord8 = s18 & s5297+  s8481 :: SBool = s17 /= s8480+  s8482 :: SWord8 = if s22 then s5307 else s5289+  s8483 :: SWord8 = s8482 >>> 1+  s8484 :: SWord8 = s24 | s8483+  s8485 :: SWord8 = s26 & s8483+  s8486 :: SWord8 = if s8481 then s8484 else s8485+  s8487 :: SWord8 = s18 & s5312+  s8488 :: SBool = s17 /= s8487+  s8489 :: SWord8 = if s8488 then s8484 else s8485+  s8490 :: SWord8 = if s5293 then s8486 else s8489+  s8491 :: SWord8 = s18 & s5335+  s8492 :: SBool = s17 /= s8491+  s8493 :: SWord8 = if s22 then s5343 else s5324+  s8494 :: SWord8 = s8493 >>> 1+  s8495 :: SWord8 = s24 | s8494+  s8496 :: SWord8 = s26 & s8494+  s8497 :: SWord8 = if s8492 then s8495 else s8496+  s8498 :: SWord8 = s18 & s5346+  s8499 :: SBool = s17 /= s8498+  s8500 :: SWord8 = if s8499 then s8495 else s8496+  s8501 :: SWord8 = if s5328 then s8497 else s8500+  s8502 :: SWord8 = if s5271 then s8490 else s8501+  s8503 :: SWord8 = if s5155 then s8479 else s8502+  s8504 :: SWord8 = s18 & s5411+  s8505 :: SBool = s17 /= s8504+  s8506 :: SWord8 = if s22 then s5421 else s5403+  s8507 :: SWord8 = s8506 >>> 1+  s8508 :: SWord8 = s24 | s8507+  s8509 :: SWord8 = s26 & s8507+  s8510 :: SWord8 = if s8505 then s8508 else s8509+  s8511 :: SWord8 = s18 & s5428+  s8512 :: SBool = s17 /= s8511+  s8513 :: SWord8 = if s8512 then s8508 else s8509+  s8514 :: SWord8 = if s5407 then s8510 else s8513+  s8515 :: SWord8 = s18 & s5451+  s8516 :: SBool = s17 /= s8515+  s8517 :: SWord8 = if s22 then s5459 else s5440+  s8518 :: SWord8 = s8517 >>> 1+  s8519 :: SWord8 = s24 | s8518+  s8520 :: SWord8 = s26 & s8518+  s8521 :: SWord8 = if s8516 then s8519 else s8520+  s8522 :: SWord8 = s18 & s5462+  s8523 :: SBool = s17 /= s8522+  s8524 :: SWord8 = if s8523 then s8519 else s8520+  s8525 :: SWord8 = if s5444 then s8521 else s8524+  s8526 :: SWord8 = if s5386 then s8514 else s8525+  s8527 :: SWord8 = s18 & s5505+  s8528 :: SBool = s17 /= s8527+  s8529 :: SWord8 = if s22 then s5515 else s5497+  s8530 :: SWord8 = s8529 >>> 1+  s8531 :: SWord8 = s24 | s8530+  s8532 :: SWord8 = s26 & s8530+  s8533 :: SWord8 = if s8528 then s8531 else s8532+  s8534 :: SWord8 = s18 & s5520+  s8535 :: SBool = s17 /= s8534+  s8536 :: SWord8 = if s8535 then s8531 else s8532+  s8537 :: SWord8 = if s5501 then s8533 else s8536+  s8538 :: SWord8 = s18 & s5543+  s8539 :: SBool = s17 /= s8538+  s8540 :: SWord8 = if s22 then s5551 else s5532+  s8541 :: SWord8 = s8540 >>> 1+  s8542 :: SWord8 = s24 | s8541+  s8543 :: SWord8 = s26 & s8541+  s8544 :: SWord8 = if s8539 then s8542 else s8543+  s8545 :: SWord8 = s18 & s5554+  s8546 :: SBool = s17 /= s8545+  s8547 :: SWord8 = if s8546 then s8542 else s8543+  s8548 :: SWord8 = if s5536 then s8544 else s8547+  s8549 :: SWord8 = if s5479 then s8537 else s8548+  s8550 :: SWord8 = if s5364 then s8526 else s8549+  s8551 :: SWord8 = if s5133 then s8503 else s8550+  s8552 :: SWord8 = if s4670 then s8456 else s8551+  s8553 :: SWord8 = if s3742 then s8361 else s8552+  s8554 :: SWord8 = s18 & s5685+  s8555 :: SBool = s17 /= s8554+  s8556 :: SWord8 = if s22 then s5695 else s5677+  s8557 :: SWord8 = s8556 >>> 1+  s8558 :: SWord8 = s24 | s8557+  s8559 :: SWord8 = s26 & s8557+  s8560 :: SWord8 = if s8555 then s8558 else s8559+  s8561 :: SWord8 = s18 & s5708+  s8562 :: SBool = s17 /= s8561+  s8563 :: SWord8 = if s8562 then s8558 else s8559+  s8564 :: SWord8 = if s5681 then s8560 else s8563+  s8565 :: SWord8 = s18 & s5731+  s8566 :: SBool = s17 /= s8565+  s8567 :: SWord8 = if s22 then s5739 else s5720+  s8568 :: SWord8 = s8567 >>> 1+  s8569 :: SWord8 = s24 | s8568+  s8570 :: SWord8 = s26 & s8568+  s8571 :: SWord8 = if s8566 then s8569 else s8570+  s8572 :: SWord8 = s18 & s5742+  s8573 :: SBool = s17 /= s8572+  s8574 :: SWord8 = if s8573 then s8569 else s8570+  s8575 :: SWord8 = if s5724 then s8571 else s8574+  s8576 :: SWord8 = if s5660 then s8564 else s8575+  s8577 :: SWord8 = s18 & s5785+  s8578 :: SBool = s17 /= s8577+  s8579 :: SWord8 = if s22 then s5795 else s5777+  s8580 :: SWord8 = s8579 >>> 1+  s8581 :: SWord8 = s24 | s8580+  s8582 :: SWord8 = s26 & s8580+  s8583 :: SWord8 = if s8578 then s8581 else s8582+  s8584 :: SWord8 = s18 & s5800+  s8585 :: SBool = s17 /= s8584+  s8586 :: SWord8 = if s8585 then s8581 else s8582+  s8587 :: SWord8 = if s5781 then s8583 else s8586+  s8588 :: SWord8 = s18 & s5823+  s8589 :: SBool = s17 /= s8588+  s8590 :: SWord8 = if s22 then s5831 else s5812+  s8591 :: SWord8 = s8590 >>> 1+  s8592 :: SWord8 = s24 | s8591+  s8593 :: SWord8 = s26 & s8591+  s8594 :: SWord8 = if s8589 then s8592 else s8593+  s8595 :: SWord8 = s18 & s5834+  s8596 :: SBool = s17 /= s8595+  s8597 :: SWord8 = if s8596 then s8592 else s8593+  s8598 :: SWord8 = if s5816 then s8594 else s8597+  s8599 :: SWord8 = if s5759 then s8587 else s8598+  s8600 :: SWord8 = if s5639 then s8576 else s8599+  s8601 :: SWord8 = s18 & s5899+  s8602 :: SBool = s17 /= s8601+  s8603 :: SWord8 = if s22 then s5909 else s5891+  s8604 :: SWord8 = s8603 >>> 1+  s8605 :: SWord8 = s24 | s8604+  s8606 :: SWord8 = s26 & s8604+  s8607 :: SWord8 = if s8602 then s8605 else s8606+  s8608 :: SWord8 = s18 & s5916+  s8609 :: SBool = s17 /= s8608+  s8610 :: SWord8 = if s8609 then s8605 else s8606+  s8611 :: SWord8 = if s5895 then s8607 else s8610+  s8612 :: SWord8 = s18 & s5939+  s8613 :: SBool = s17 /= s8612+  s8614 :: SWord8 = if s22 then s5947 else s5928+  s8615 :: SWord8 = s8614 >>> 1+  s8616 :: SWord8 = s24 | s8615+  s8617 :: SWord8 = s26 & s8615+  s8618 :: SWord8 = if s8613 then s8616 else s8617+  s8619 :: SWord8 = s18 & s5950+  s8620 :: SBool = s17 /= s8619+  s8621 :: SWord8 = if s8620 then s8616 else s8617+  s8622 :: SWord8 = if s5932 then s8618 else s8621+  s8623 :: SWord8 = if s5874 then s8611 else s8622+  s8624 :: SWord8 = s18 & s5993+  s8625 :: SBool = s17 /= s8624+  s8626 :: SWord8 = if s22 then s6003 else s5985+  s8627 :: SWord8 = s8626 >>> 1+  s8628 :: SWord8 = s24 | s8627+  s8629 :: SWord8 = s26 & s8627+  s8630 :: SWord8 = if s8625 then s8628 else s8629+  s8631 :: SWord8 = s18 & s6008+  s8632 :: SBool = s17 /= s8631+  s8633 :: SWord8 = if s8632 then s8628 else s8629+  s8634 :: SWord8 = if s5989 then s8630 else s8633+  s8635 :: SWord8 = s18 & s6031+  s8636 :: SBool = s17 /= s8635+  s8637 :: SWord8 = if s22 then s6039 else s6020+  s8638 :: SWord8 = s8637 >>> 1+  s8639 :: SWord8 = s24 | s8638+  s8640 :: SWord8 = s26 & s8638+  s8641 :: SWord8 = if s8636 then s8639 else s8640+  s8642 :: SWord8 = s18 & s6042+  s8643 :: SBool = s17 /= s8642+  s8644 :: SWord8 = if s8643 then s8639 else s8640+  s8645 :: SWord8 = if s6024 then s8641 else s8644+  s8646 :: SWord8 = if s5967 then s8634 else s8645+  s8647 :: SWord8 = if s5852 then s8623 else s8646+  s8648 :: SWord8 = if s5618 then s8600 else s8647+  s8649 :: SWord8 = s18 & s6129+  s8650 :: SBool = s17 /= s8649+  s8651 :: SWord8 = if s22 then s6139 else s6121+  s8652 :: SWord8 = s8651 >>> 1+  s8653 :: SWord8 = s24 | s8652+  s8654 :: SWord8 = s26 & s8652+  s8655 :: SWord8 = if s8650 then s8653 else s8654+  s8656 :: SWord8 = s18 & s6148+  s8657 :: SBool = s17 /= s8656+  s8658 :: SWord8 = if s8657 then s8653 else s8654+  s8659 :: SWord8 = if s6125 then s8655 else s8658+  s8660 :: SWord8 = s18 & s6171+  s8661 :: SBool = s17 /= s8660+  s8662 :: SWord8 = if s22 then s6179 else s6160+  s8663 :: SWord8 = s8662 >>> 1+  s8664 :: SWord8 = s24 | s8663+  s8665 :: SWord8 = s26 & s8663+  s8666 :: SWord8 = if s8661 then s8664 else s8665+  s8667 :: SWord8 = s18 & s6182+  s8668 :: SBool = s17 /= s8667+  s8669 :: SWord8 = if s8668 then s8664 else s8665+  s8670 :: SWord8 = if s6164 then s8666 else s8669+  s8671 :: SWord8 = if s6104 then s8659 else s8670+  s8672 :: SWord8 = s18 & s6225+  s8673 :: SBool = s17 /= s8672+  s8674 :: SWord8 = if s22 then s6235 else s6217+  s8675 :: SWord8 = s8674 >>> 1+  s8676 :: SWord8 = s24 | s8675+  s8677 :: SWord8 = s26 & s8675+  s8678 :: SWord8 = if s8673 then s8676 else s8677+  s8679 :: SWord8 = s18 & s6240+  s8680 :: SBool = s17 /= s8679+  s8681 :: SWord8 = if s8680 then s8676 else s8677+  s8682 :: SWord8 = if s6221 then s8678 else s8681+  s8683 :: SWord8 = s18 & s6263+  s8684 :: SBool = s17 /= s8683+  s8685 :: SWord8 = if s22 then s6271 else s6252+  s8686 :: SWord8 = s8685 >>> 1+  s8687 :: SWord8 = s24 | s8686+  s8688 :: SWord8 = s26 & s8686+  s8689 :: SWord8 = if s8684 then s8687 else s8688+  s8690 :: SWord8 = s18 & s6274+  s8691 :: SBool = s17 /= s8690+  s8692 :: SWord8 = if s8691 then s8687 else s8688+  s8693 :: SWord8 = if s6256 then s8689 else s8692+  s8694 :: SWord8 = if s6199 then s8682 else s8693+  s8695 :: SWord8 = if s6083 then s8671 else s8694+  s8696 :: SWord8 = s18 & s6339+  s8697 :: SBool = s17 /= s8696+  s8698 :: SWord8 = if s22 then s6349 else s6331+  s8699 :: SWord8 = s8698 >>> 1+  s8700 :: SWord8 = s24 | s8699+  s8701 :: SWord8 = s26 & s8699+  s8702 :: SWord8 = if s8697 then s8700 else s8701+  s8703 :: SWord8 = s18 & s6356+  s8704 :: SBool = s17 /= s8703+  s8705 :: SWord8 = if s8704 then s8700 else s8701+  s8706 :: SWord8 = if s6335 then s8702 else s8705+  s8707 :: SWord8 = s18 & s6379+  s8708 :: SBool = s17 /= s8707+  s8709 :: SWord8 = if s22 then s6387 else s6368+  s8710 :: SWord8 = s8709 >>> 1+  s8711 :: SWord8 = s24 | s8710+  s8712 :: SWord8 = s26 & s8710+  s8713 :: SWord8 = if s8708 then s8711 else s8712+  s8714 :: SWord8 = s18 & s6390+  s8715 :: SBool = s17 /= s8714+  s8716 :: SWord8 = if s8715 then s8711 else s8712+  s8717 :: SWord8 = if s6372 then s8713 else s8716+  s8718 :: SWord8 = if s6314 then s8706 else s8717+  s8719 :: SWord8 = s18 & s6433+  s8720 :: SBool = s17 /= s8719+  s8721 :: SWord8 = if s22 then s6443 else s6425+  s8722 :: SWord8 = s8721 >>> 1+  s8723 :: SWord8 = s24 | s8722+  s8724 :: SWord8 = s26 & s8722+  s8725 :: SWord8 = if s8720 then s8723 else s8724+  s8726 :: SWord8 = s18 & s6448+  s8727 :: SBool = s17 /= s8726+  s8728 :: SWord8 = if s8727 then s8723 else s8724+  s8729 :: SWord8 = if s6429 then s8725 else s8728+  s8730 :: SWord8 = s18 & s6471+  s8731 :: SBool = s17 /= s8730+  s8732 :: SWord8 = if s22 then s6479 else s6460+  s8733 :: SWord8 = s8732 >>> 1+  s8734 :: SWord8 = s24 | s8733+  s8735 :: SWord8 = s26 & s8733+  s8736 :: SWord8 = if s8731 then s8734 else s8735+  s8737 :: SWord8 = s18 & s6482+  s8738 :: SBool = s17 /= s8737+  s8739 :: SWord8 = if s8738 then s8734 else s8735+  s8740 :: SWord8 = if s6464 then s8736 else s8739+  s8741 :: SWord8 = if s6407 then s8729 else s8740+  s8742 :: SWord8 = if s6292 then s8718 else s8741+  s8743 :: SWord8 = if s6061 then s8695 else s8742+  s8744 :: SWord8 = if s5597 then s8648 else s8743+  s8745 :: SWord8 = s18 & s6591+  s8746 :: SBool = s17 /= s8745+  s8747 :: SWord8 = if s22 then s6601 else s6583+  s8748 :: SWord8 = s8747 >>> 1+  s8749 :: SWord8 = s24 | s8748+  s8750 :: SWord8 = s26 & s8748+  s8751 :: SWord8 = if s8746 then s8749 else s8750+  s8752 :: SWord8 = s18 & s6612+  s8753 :: SBool = s17 /= s8752+  s8754 :: SWord8 = if s8753 then s8749 else s8750+  s8755 :: SWord8 = if s6587 then s8751 else s8754+  s8756 :: SWord8 = s18 & s6635+  s8757 :: SBool = s17 /= s8756+  s8758 :: SWord8 = if s22 then s6643 else s6624+  s8759 :: SWord8 = s8758 >>> 1+  s8760 :: SWord8 = s24 | s8759+  s8761 :: SWord8 = s26 & s8759+  s8762 :: SWord8 = if s8757 then s8760 else s8761+  s8763 :: SWord8 = s18 & s6646+  s8764 :: SBool = s17 /= s8763+  s8765 :: SWord8 = if s8764 then s8760 else s8761+  s8766 :: SWord8 = if s6628 then s8762 else s8765+  s8767 :: SWord8 = if s6566 then s8755 else s8766+  s8768 :: SWord8 = s18 & s6689+  s8769 :: SBool = s17 /= s8768+  s8770 :: SWord8 = if s22 then s6699 else s6681+  s8771 :: SWord8 = s8770 >>> 1+  s8772 :: SWord8 = s24 | s8771+  s8773 :: SWord8 = s26 & s8771+  s8774 :: SWord8 = if s8769 then s8772 else s8773+  s8775 :: SWord8 = s18 & s6704+  s8776 :: SBool = s17 /= s8775+  s8777 :: SWord8 = if s8776 then s8772 else s8773+  s8778 :: SWord8 = if s6685 then s8774 else s8777+  s8779 :: SWord8 = s18 & s6727+  s8780 :: SBool = s17 /= s8779+  s8781 :: SWord8 = if s22 then s6735 else s6716+  s8782 :: SWord8 = s8781 >>> 1+  s8783 :: SWord8 = s24 | s8782+  s8784 :: SWord8 = s26 & s8782+  s8785 :: SWord8 = if s8780 then s8783 else s8784+  s8786 :: SWord8 = s18 & s6738+  s8787 :: SBool = s17 /= s8786+  s8788 :: SWord8 = if s8787 then s8783 else s8784+  s8789 :: SWord8 = if s6720 then s8785 else s8788+  s8790 :: SWord8 = if s6663 then s8778 else s8789+  s8791 :: SWord8 = if s6545 then s8767 else s8790+  s8792 :: SWord8 = s18 & s6803+  s8793 :: SBool = s17 /= s8792+  s8794 :: SWord8 = if s22 then s6813 else s6795+  s8795 :: SWord8 = s8794 >>> 1+  s8796 :: SWord8 = s24 | s8795+  s8797 :: SWord8 = s26 & s8795+  s8798 :: SWord8 = if s8793 then s8796 else s8797+  s8799 :: SWord8 = s18 & s6820+  s8800 :: SBool = s17 /= s8799+  s8801 :: SWord8 = if s8800 then s8796 else s8797+  s8802 :: SWord8 = if s6799 then s8798 else s8801+  s8803 :: SWord8 = s18 & s6843+  s8804 :: SBool = s17 /= s8803+  s8805 :: SWord8 = if s22 then s6851 else s6832+  s8806 :: SWord8 = s8805 >>> 1+  s8807 :: SWord8 = s24 | s8806+  s8808 :: SWord8 = s26 & s8806+  s8809 :: SWord8 = if s8804 then s8807 else s8808+  s8810 :: SWord8 = s18 & s6854+  s8811 :: SBool = s17 /= s8810+  s8812 :: SWord8 = if s8811 then s8807 else s8808+  s8813 :: SWord8 = if s6836 then s8809 else s8812+  s8814 :: SWord8 = if s6778 then s8802 else s8813+  s8815 :: SWord8 = s18 & s6897+  s8816 :: SBool = s17 /= s8815+  s8817 :: SWord8 = if s22 then s6907 else s6889+  s8818 :: SWord8 = s8817 >>> 1+  s8819 :: SWord8 = s24 | s8818+  s8820 :: SWord8 = s26 & s8818+  s8821 :: SWord8 = if s8816 then s8819 else s8820+  s8822 :: SWord8 = s18 & s6912+  s8823 :: SBool = s17 /= s8822+  s8824 :: SWord8 = if s8823 then s8819 else s8820+  s8825 :: SWord8 = if s6893 then s8821 else s8824+  s8826 :: SWord8 = s18 & s6935+  s8827 :: SBool = s17 /= s8826+  s8828 :: SWord8 = if s22 then s6943 else s6924+  s8829 :: SWord8 = s8828 >>> 1+  s8830 :: SWord8 = s24 | s8829+  s8831 :: SWord8 = s26 & s8829+  s8832 :: SWord8 = if s8827 then s8830 else s8831+  s8833 :: SWord8 = s18 & s6946+  s8834 :: SBool = s17 /= s8833+  s8835 :: SWord8 = if s8834 then s8830 else s8831+  s8836 :: SWord8 = if s6928 then s8832 else s8835+  s8837 :: SWord8 = if s6871 then s8825 else s8836+  s8838 :: SWord8 = if s6756 then s8814 else s8837+  s8839 :: SWord8 = if s6524 then s8791 else s8838+  s8840 :: SWord8 = s18 & s7033+  s8841 :: SBool = s17 /= s8840+  s8842 :: SWord8 = if s22 then s7043 else s7025+  s8843 :: SWord8 = s8842 >>> 1+  s8844 :: SWord8 = s24 | s8843+  s8845 :: SWord8 = s26 & s8843+  s8846 :: SWord8 = if s8841 then s8844 else s8845+  s8847 :: SWord8 = s18 & s7052+  s8848 :: SBool = s17 /= s8847+  s8849 :: SWord8 = if s8848 then s8844 else s8845+  s8850 :: SWord8 = if s7029 then s8846 else s8849+  s8851 :: SWord8 = s18 & s7075+  s8852 :: SBool = s17 /= s8851+  s8853 :: SWord8 = if s22 then s7083 else s7064+  s8854 :: SWord8 = s8853 >>> 1+  s8855 :: SWord8 = s24 | s8854+  s8856 :: SWord8 = s26 & s8854+  s8857 :: SWord8 = if s8852 then s8855 else s8856+  s8858 :: SWord8 = s18 & s7086+  s8859 :: SBool = s17 /= s8858+  s8860 :: SWord8 = if s8859 then s8855 else s8856+  s8861 :: SWord8 = if s7068 then s8857 else s8860+  s8862 :: SWord8 = if s7008 then s8850 else s8861+  s8863 :: SWord8 = s18 & s7129+  s8864 :: SBool = s17 /= s8863+  s8865 :: SWord8 = if s22 then s7139 else s7121+  s8866 :: SWord8 = s8865 >>> 1+  s8867 :: SWord8 = s24 | s8866+  s8868 :: SWord8 = s26 & s8866+  s8869 :: SWord8 = if s8864 then s8867 else s8868+  s8870 :: SWord8 = s18 & s7144+  s8871 :: SBool = s17 /= s8870+  s8872 :: SWord8 = if s8871 then s8867 else s8868+  s8873 :: SWord8 = if s7125 then s8869 else s8872+  s8874 :: SWord8 = s18 & s7167+  s8875 :: SBool = s17 /= s8874+  s8876 :: SWord8 = if s22 then s7175 else s7156+  s8877 :: SWord8 = s8876 >>> 1+  s8878 :: SWord8 = s24 | s8877+  s8879 :: SWord8 = s26 & s8877+  s8880 :: SWord8 = if s8875 then s8878 else s8879+  s8881 :: SWord8 = s18 & s7178+  s8882 :: SBool = s17 /= s8881+  s8883 :: SWord8 = if s8882 then s8878 else s8879+  s8884 :: SWord8 = if s7160 then s8880 else s8883+  s8885 :: SWord8 = if s7103 then s8873 else s8884+  s8886 :: SWord8 = if s6987 then s8862 else s8885+  s8887 :: SWord8 = s18 & s7243+  s8888 :: SBool = s17 /= s8887+  s8889 :: SWord8 = if s22 then s7253 else s7235+  s8890 :: SWord8 = s8889 >>> 1+  s8891 :: SWord8 = s24 | s8890+  s8892 :: SWord8 = s26 & s8890+  s8893 :: SWord8 = if s8888 then s8891 else s8892+  s8894 :: SWord8 = s18 & s7260+  s8895 :: SBool = s17 /= s8894+  s8896 :: SWord8 = if s8895 then s8891 else s8892+  s8897 :: SWord8 = if s7239 then s8893 else s8896+  s8898 :: SWord8 = s18 & s7283+  s8899 :: SBool = s17 /= s8898+  s8900 :: SWord8 = if s22 then s7291 else s7272+  s8901 :: SWord8 = s8900 >>> 1+  s8902 :: SWord8 = s24 | s8901+  s8903 :: SWord8 = s26 & s8901+  s8904 :: SWord8 = if s8899 then s8902 else s8903+  s8905 :: SWord8 = s18 & s7294+  s8906 :: SBool = s17 /= s8905+  s8907 :: SWord8 = if s8906 then s8902 else s8903+  s8908 :: SWord8 = if s7276 then s8904 else s8907+  s8909 :: SWord8 = if s7218 then s8897 else s8908+  s8910 :: SWord8 = s18 & s7337+  s8911 :: SBool = s17 /= s8910+  s8912 :: SWord8 = if s22 then s7347 else s7329+  s8913 :: SWord8 = s8912 >>> 1+  s8914 :: SWord8 = s24 | s8913+  s8915 :: SWord8 = s26 & s8913+  s8916 :: SWord8 = if s8911 then s8914 else s8915+  s8917 :: SWord8 = s18 & s7352+  s8918 :: SBool = s17 /= s8917+  s8919 :: SWord8 = if s8918 then s8914 else s8915+  s8920 :: SWord8 = if s7333 then s8916 else s8919+  s8921 :: SWord8 = s18 & s7375+  s8922 :: SBool = s17 /= s8921+  s8923 :: SWord8 = if s22 then s7383 else s7364+  s8924 :: SWord8 = s8923 >>> 1+  s8925 :: SWord8 = s24 | s8924+  s8926 :: SWord8 = s26 & s8924+  s8927 :: SWord8 = if s8922 then s8925 else s8926+  s8928 :: SWord8 = s18 & s7386+  s8929 :: SBool = s17 /= s8928+  s8930 :: SWord8 = if s8929 then s8925 else s8926+  s8931 :: SWord8 = if s7368 then s8927 else s8930+  s8932 :: SWord8 = if s7311 then s8920 else s8931+  s8933 :: SWord8 = if s7196 then s8909 else s8932+  s8934 :: SWord8 = if s6965 then s8886 else s8933+  s8935 :: SWord8 = if s6502 then s8839 else s8934+  s8936 :: SWord8 = if s5575 then s8744 else s8935+  s8937 :: SWord8 = if s3725 then s8553 else s8936+  s8938 :: SWord8 = if s21 then s8170 else s8937+  s8939 :: SWord16 = s17 # s8938+  s8940 :: SWord16 = s7403 + s8939+  s8941 :: SWord16 = s17 # s1+  s8942 :: SWord16 = s17 # s3+  s8943 :: SWord16 = s8941 * s8942+  s8944 :: SBool = s8940 == s8943+  s8945 :: SBool = s15 | s8944+OUTPUTS+  s8945
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/legato_c.gold view
@@ -0,0 +1,6413 @@+== BEGIN: "Makefile" ================+# Makefile for legatoMult. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#include "legatoMult.h"++void legatoMult(const SWord8 x, const SWord8 y, SWord8 *hi,+                SWord8 *lo)+{+  const SWord8 s0 = x;+  const SWord8 s1 = y;+  const SWord8 s3 = s0 & 1;+  const SBool  s5 = s3 != 0;+  const SBool  s6 = 0 == s5;+  const SWord8 s7 = (s0 >> 1) | (s0 << 7);+  const SWord8 s9 = s7 & 127;+  const SWord8 s10 = 1 & s9;+  const SBool  s11 = 0 != s10;+  const SBool  s12 = 0 == s11;+  const SWord8 s13 = (s9 >> 1) | (s9 << 7);+  const SWord8 s14 = 127 & s13;+  const SWord8 s15 = 1 & s14;+  const SBool  s16 = 0 != s15;+  const SBool  s17 = 0 == s16;+  const SWord8 s18 = (s14 >> 1) | (s14 << 7);+  const SWord8 s19 = 127 & s18;+  const SWord8 s20 = 1 & s19;+  const SBool  s21 = 0 != s20;+  const SBool  s22 = 0 == s21;+  const SWord8 s24 = s5 ? 128 : 0;+  const SWord8 s25 = 1 & s24;+  const SBool  s26 = 0 != s25;+  const SWord8 s27 = s26 ? 128 : 0;+  const SWord8 s28 = 1 & s27;+  const SBool  s29 = 0 != s28;+  const SWord8 s30 = (s19 >> 1) | (s19 << 7);+  const SWord8 s31 = 128 | s30;+  const SWord8 s32 = 127 & s30;+  const SWord8 s33 = s29 ? s31 : s32;+  const SWord8 s34 = 1 & s33;+  const SBool  s35 = 0 != s34;+  const SBool  s36 = 0 == s35;+  const SWord8 s37 = (s24 >> 1) | (s24 << 7);+  const SWord8 s38 = 128 | s37;+  const SWord8 s39 = 127 & s37;+  const SWord8 s40 = s11 ? s38 : s39;+  const SWord8 s41 = 1 & s40;+  const SBool  s42 = 0 != 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 SWord8 s47 = 1 & s46;+  const SBool  s48 = 0 != 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 SWord8 s53 = 1 & s52;+  const SBool  s54 = 0 != s53;+  const SBool  s55 = 0 == s54;+  const SWord8 s56 = (s40 >> 1) | (s40 << 7);+  const SWord8 s57 = 128 | s56;+  const SWord8 s58 = 127 & s56;+  const SWord8 s59 = s16 ? s57 : s58;+  const SWord8 s60 = 1 & s59;+  const SBool  s61 = 0 != 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 SWord8 s66 = 1 & s65;+  const SBool  s67 = 0 != 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 SWord8 s72 = 1 & s71;+  const SBool  s73 = 0 != s72;+  const SBool  s74 = 0 == s73;+  const SWord8 s75 = (s59 >> 1) | (s59 << 7);+  const SWord8 s76 = 128 | s75;+  const SWord8 s77 = 127 & s75;+  const SWord8 s78 = s21 ? s76 : s77;+  const SWord8 s79 = 1 & s78;+  const SBool  s80 = 0 != 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 SWord8 s85 = 1 & s84;+  const SBool  s86 = 0 != 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 SWord8 s91 = 1 & s90;+  const SBool  s92 = 0 != s91;+  const SBool  s93 = 0 == 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 SWord8 s190 = 1 & s189;+  const SBool  s191 = 0 != s190;+  const SWord8 s192 = s191 ? s82 : s83;+  const SWord8 s193 = 1 & s192;+  const SBool  s194 = 0 != s193;+  const SWord8 s195 = s194 ? s88 : s89;+  const SWord8 s196 = 1 & s195;+  const SBool  s197 = 0 != s196;+  const SBool  s198 = 0 == 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 SWord8 s299 = 1 & s298;+  const SBool  s300 = 0 != s299;+  const SWord8 s301 = s300 ? s63 : s64;+  const SWord8 s302 = 1 & s301;+  const SBool  s303 = 0 != s302;+  const SWord8 s304 = s303 ? s69 : s70;+  const SWord8 s305 = 1 & s304;+  const SBool  s306 = 0 != s305;+  const SBool  s307 = 0 == 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 SWord8 s315 = 1 & s314;+  const SBool  s316 = 0 != 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 SWord8 s321 = 1 & s320;+  const SBool  s322 = 0 != 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 SWord8 s327 = 1 & s326;+  const SBool  s328 = 0 != s327;+  const SBool  s329 = 0 == 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 SWord8 s426 = 1 & s425;+  const SBool  s427 = 0 != s426;+  const SWord8 s428 = s427 ? s318 : s319;+  const SWord8 s429 = 1 & s428;+  const SBool  s430 = 0 != s429;+  const SWord8 s431 = s430 ? s324 : s325;+  const SWord8 s432 = 1 & s431;+  const SBool  s433 = 0 != s432;+  const SBool  s434 = 0 == 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 = s22 ? s297 : s533;+  const SWord8 s535 = s1 + s40;+  const SWord8 s536 = 1 & s535;+  const SBool  s537 = 0 != s536;+  const SWord8 s538 = s537 ? s44 : s45;+  const SWord8 s539 = 1 & s538;+  const SBool  s540 = 0 != s539;+  const SWord8 s541 = s540 ? s50 : s51;+  const SWord8 s542 = 1 & s541;+  const SBool  s543 = 0 != s542;+  const SBool  s544 = 0 == 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 SWord8 s552 = 1 & s551;+  const SBool  s553 = 0 != 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 SWord8 s558 = 1 & s557;+  const SBool  s559 = 0 != 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 SWord8 s564 = 1 & s563;+  const SBool  s565 = 0 != s564;+  const SBool  s566 = 0 == s565;+  const SWord8 s567 = (s551 >> 1) | (s551 << 7);+  const SWord8 s568 = 128 | s567;+  const SWord8 s569 = 127 & s567;+  const SWord8 s570 = s21 ? s568 : s569;+  const SWord8 s571 = 1 & s570;+  const SBool  s572 = 0 != 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 SWord8 s577 = 1 & s576;+  const SBool  s578 = 0 != 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 SWord8 s583 = 1 & s582;+  const SBool  s584 = 0 != s583;+  const SBool  s585 = 0 == 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 SWord8 s682 = 1 & s681;+  const SBool  s683 = 0 != s682;+  const SWord8 s684 = s683 ? s574 : s575;+  const SWord8 s685 = 1 & s684;+  const SBool  s686 = 0 != s685;+  const SWord8 s687 = s686 ? s580 : s581;+  const SWord8 s688 = 1 & s687;+  const SBool  s689 = 0 != s688;+  const SBool  s690 = 0 == 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 SWord8 s791 = 1 & s790;+  const SBool  s792 = 0 != s791;+  const SWord8 s793 = s792 ? s555 : s556;+  const SWord8 s794 = 1 & s793;+  const SBool  s795 = 0 != s794;+  const SWord8 s796 = s795 ? s561 : s562;+  const SWord8 s797 = 1 & s796;+  const SBool  s798 = 0 != s797;+  const SBool  s799 = 0 == 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 SWord8 s807 = 1 & s806;+  const SBool  s808 = 0 != 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 SWord8 s813 = 1 & s812;+  const SBool  s814 = 0 != 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 SWord8 s819 = 1 & s818;+  const SBool  s820 = 0 != s819;+  const SBool  s821 = 0 == 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 SWord8 s918 = 1 & s917;+  const SBool  s919 = 0 != s918;+  const SWord8 s920 = s919 ? s810 : s811;+  const SWord8 s921 = 1 & s920;+  const SBool  s922 = 0 != s921;+  const SWord8 s923 = s922 ? s816 : s817;+  const SWord8 s924 = 1 & s923;+  const SBool  s925 = 0 != s924;+  const SBool  s926 = 0 == 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 = s22 ? s789 : s1025;+  const SWord8 s1027 = s17 ? s534 : s1026;+  const SWord8 s1028 = s1 + s24;+  const SWord8 s1029 = 1 & s1028;+  const SBool  s1030 = 0 != s1029;+  const SWord8 s1031 = s1030 ? 128 : 0;+  const SWord8 s1032 = 1 & s1031;+  const SBool  s1033 = 0 != s1032;+  const SWord8 s1034 = s1033 ? s31 : s32;+  const SWord8 s1035 = 1 & s1034;+  const SBool  s1036 = 0 != s1035;+  const SBool  s1037 = 0 == 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 SWord8 s1045 = 1 & s1044;+  const SBool  s1046 = 0 != 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 SWord8 s1051 = 1 & s1050;+  const SBool  s1052 = 0 != 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 SWord8 s1057 = 1 & s1056;+  const SBool  s1058 = 0 != s1057;+  const SBool  s1059 = 0 == s1058;+  const SWord8 s1060 = (s1044 >> 1) | (s1044 << 7);+  const SWord8 s1061 = 128 | s1060;+  const SWord8 s1062 = 127 & s1060;+  const SWord8 s1063 = s16 ? s1061 : s1062;+  const SWord8 s1064 = 1 & s1063;+  const SBool  s1065 = 0 != 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 SWord8 s1070 = 1 & s1069;+  const SBool  s1071 = 0 != 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 SWord8 s1076 = 1 & s1075;+  const SBool  s1077 = 0 != s1076;+  const SBool  s1078 = 0 == s1077;+  const SWord8 s1079 = (s1063 >> 1) | (s1063 << 7);+  const SWord8 s1080 = 128 | s1079;+  const SWord8 s1081 = 127 & s1079;+  const SWord8 s1082 = s21 ? s1080 : s1081;+  const SWord8 s1083 = 1 & s1082;+  const SBool  s1084 = 0 != 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 SWord8 s1089 = 1 & s1088;+  const SBool  s1090 = 0 != 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 SWord8 s1095 = 1 & s1094;+  const SBool  s1096 = 0 != s1095;+  const SBool  s1097 = 0 == 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 SWord8 s1194 = 1 & s1193;+  const SBool  s1195 = 0 != s1194;+  const SWord8 s1196 = s1195 ? s1086 : s1087;+  const SWord8 s1197 = 1 & s1196;+  const SBool  s1198 = 0 != s1197;+  const SWord8 s1199 = s1198 ? s1092 : s1093;+  const SWord8 s1200 = 1 & s1199;+  const SBool  s1201 = 0 != s1200;+  const SBool  s1202 = 0 == 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 SWord8 s1303 = 1 & s1302;+  const SBool  s1304 = 0 != s1303;+  const SWord8 s1305 = s1304 ? s1067 : s1068;+  const SWord8 s1306 = 1 & s1305;+  const SBool  s1307 = 0 != s1306;+  const SWord8 s1308 = s1307 ? s1073 : s1074;+  const SWord8 s1309 = 1 & s1308;+  const SBool  s1310 = 0 != s1309;+  const SBool  s1311 = 0 == 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 SWord8 s1319 = 1 & s1318;+  const SBool  s1320 = 0 != 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 SWord8 s1325 = 1 & s1324;+  const SBool  s1326 = 0 != 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 SWord8 s1331 = 1 & s1330;+  const SBool  s1332 = 0 != s1331;+  const SBool  s1333 = 0 == 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 SWord8 s1430 = 1 & s1429;+  const SBool  s1431 = 0 != s1430;+  const SWord8 s1432 = s1431 ? s1322 : s1323;+  const SWord8 s1433 = 1 & s1432;+  const SBool  s1434 = 0 != s1433;+  const SWord8 s1435 = s1434 ? s1328 : s1329;+  const SWord8 s1436 = 1 & s1435;+  const SBool  s1437 = 0 != s1436;+  const SBool  s1438 = 0 == 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 = s22 ? s1301 : s1537;+  const SWord8 s1539 = s1 + s1044;+  const SWord8 s1540 = 1 & s1539;+  const SBool  s1541 = 0 != s1540;+  const SWord8 s1542 = s1541 ? s1048 : s1049;+  const SWord8 s1543 = 1 & s1542;+  const SBool  s1544 = 0 != s1543;+  const SWord8 s1545 = s1544 ? s1054 : s1055;+  const SWord8 s1546 = 1 & s1545;+  const SBool  s1547 = 0 != s1546;+  const SBool  s1548 = 0 == 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 SWord8 s1556 = 1 & s1555;+  const SBool  s1557 = 0 != 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 SWord8 s1562 = 1 & s1561;+  const SBool  s1563 = 0 != 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 SWord8 s1568 = 1 & s1567;+  const SBool  s1569 = 0 != s1568;+  const SBool  s1570 = 0 == s1569;+  const SWord8 s1571 = (s1555 >> 1) | (s1555 << 7);+  const SWord8 s1572 = 128 | s1571;+  const SWord8 s1573 = 127 & s1571;+  const SWord8 s1574 = s21 ? s1572 : s1573;+  const SWord8 s1575 = 1 & s1574;+  const SBool  s1576 = 0 != 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 SWord8 s1581 = 1 & s1580;+  const SBool  s1582 = 0 != 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 SWord8 s1587 = 1 & s1586;+  const SBool  s1588 = 0 != s1587;+  const SBool  s1589 = 0 == 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 SWord8 s1686 = 1 & s1685;+  const SBool  s1687 = 0 != s1686;+  const SWord8 s1688 = s1687 ? s1578 : s1579;+  const SWord8 s1689 = 1 & s1688;+  const SBool  s1690 = 0 != s1689;+  const SWord8 s1691 = s1690 ? s1584 : s1585;+  const SWord8 s1692 = 1 & s1691;+  const SBool  s1693 = 0 != s1692;+  const SBool  s1694 = 0 == 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 SWord8 s1795 = 1 & s1794;+  const SBool  s1796 = 0 != s1795;+  const SWord8 s1797 = s1796 ? s1559 : s1560;+  const SWord8 s1798 = 1 & s1797;+  const SBool  s1799 = 0 != s1798;+  const SWord8 s1800 = s1799 ? s1565 : s1566;+  const SWord8 s1801 = 1 & s1800;+  const SBool  s1802 = 0 != s1801;+  const SBool  s1803 = 0 == 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 SWord8 s1811 = 1 & s1810;+  const SBool  s1812 = 0 != 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 SWord8 s1817 = 1 & s1816;+  const SBool  s1818 = 0 != 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 SWord8 s1823 = 1 & s1822;+  const SBool  s1824 = 0 != s1823;+  const SBool  s1825 = 0 == 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 SWord8 s1922 = 1 & s1921;+  const SBool  s1923 = 0 != s1922;+  const SWord8 s1924 = s1923 ? s1814 : s1815;+  const SWord8 s1925 = 1 & s1924;+  const SBool  s1926 = 0 != s1925;+  const SWord8 s1927 = s1926 ? s1820 : s1821;+  const SWord8 s1928 = 1 & s1927;+  const SBool  s1929 = 0 != s1928;+  const SBool  s1930 = 0 == 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 = s22 ? s1793 : s2029;+  const SWord8 s2031 = s17 ? s1538 : s2030;+  const SWord8 s2032 = s12 ? s1027 : s2031;+  const SWord8 s2033 = s1 & 1;+  const SBool  s2034 = 0 != s2033;+  const SWord8 s2035 = s2034 ? 128 : 0;+  const SWord8 s2036 = 1 & s2035;+  const SBool  s2037 = 0 != s2036;+  const SWord8 s2038 = s18 | 128;+  const SWord8 s2039 = s2037 ? s2038 : s19;+  const SWord8 s2040 = 1 & s2039;+  const SBool  s2041 = 0 != s2040;+  const SBool  s2042 = 0 == s2041;+  const SWord8 s2043 = (s1 >> 1) | (s1 << 7);+  const SWord8 s2044 = 127 & s2043;+  const SWord8 s2045 = 1 & s2044;+  const SBool  s2046 = 0 != 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 SWord8 s2051 = 1 & s2050;+  const SBool  s2052 = 0 != 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 SWord8 s2057 = 1 & s2056;+  const SBool  s2058 = 0 != s2057;+  const SBool  s2059 = 0 == s2058;+  const SWord8 s2060 = (s2044 >> 1) | (s2044 << 7);+  const SWord8 s2061 = 128 | s2060;+  const SWord8 s2062 = 127 & s2060;+  const SWord8 s2063 = s11 ? s2061 : s2062;+  const SWord8 s2064 = 1 & s2063;+  const SBool  s2065 = 0 != 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 SWord8 s2070 = 1 & s2069;+  const SBool  s2071 = 0 != 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 SWord8 s2076 = 1 & s2075;+  const SBool  s2077 = 0 != s2076;+  const SBool  s2078 = 0 == s2077;+  const SWord8 s2079 = (s2063 >> 1) | (s2063 << 7);+  const SWord8 s2080 = 128 | s2079;+  const SWord8 s2081 = 127 & s2079;+  const SWord8 s2082 = s16 ? s2080 : s2081;+  const SWord8 s2083 = 1 & s2082;+  const SBool  s2084 = 0 != 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 SWord8 s2089 = 1 & s2088;+  const SBool  s2090 = 0 != 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 SWord8 s2095 = 1 & s2094;+  const SBool  s2096 = 0 != s2095;+  const SBool  s2097 = 0 == 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 SWord8 s2102 = 1 & s2101;+  const SBool  s2103 = 0 != 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 SWord8 s2108 = 1 & s2107;+  const SBool  s2109 = 0 != 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 SWord8 s2114 = 1 & s2113;+  const SBool  s2115 = 0 != s2114;+  const SBool  s2116 = 0 == 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 SWord8 s2213 = 1 & s2212;+  const SBool  s2214 = 0 != s2213;+  const SWord8 s2215 = s2214 ? s2105 : s2106;+  const SWord8 s2216 = 1 & s2215;+  const SBool  s2217 = 0 != s2216;+  const SWord8 s2218 = s2217 ? s2111 : s2112;+  const SWord8 s2219 = 1 & s2218;+  const SBool  s2220 = 0 != s2219;+  const SBool  s2221 = 0 == 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 SWord8 s2322 = 1 & s2321;+  const SBool  s2323 = 0 != s2322;+  const SWord8 s2324 = s2323 ? s2086 : s2087;+  const SWord8 s2325 = 1 & s2324;+  const SBool  s2326 = 0 != s2325;+  const SWord8 s2327 = s2326 ? s2092 : s2093;+  const SWord8 s2328 = 1 & s2327;+  const SBool  s2329 = 0 != s2328;+  const SBool  s2330 = 0 == 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 SWord8 s2338 = 1 & s2337;+  const SBool  s2339 = 0 != 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 SWord8 s2344 = 1 & s2343;+  const SBool  s2345 = 0 != 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 SWord8 s2350 = 1 & s2349;+  const SBool  s2351 = 0 != s2350;+  const SBool  s2352 = 0 == 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 SWord8 s2449 = 1 & s2448;+  const SBool  s2450 = 0 != s2449;+  const SWord8 s2451 = s2450 ? s2341 : s2342;+  const SWord8 s2452 = 1 & s2451;+  const SBool  s2453 = 0 != s2452;+  const SWord8 s2454 = s2453 ? s2347 : s2348;+  const SWord8 s2455 = 1 & s2454;+  const SBool  s2456 = 0 != s2455;+  const SBool  s2457 = 0 == 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 SWord8 s2559 = 1 & s2558;+  const SBool  s2560 = 0 != s2559;+  const SWord8 s2561 = s2560 ? s2067 : s2068;+  const SWord8 s2562 = 1 & s2561;+  const SBool  s2563 = 0 != s2562;+  const SWord8 s2564 = s2563 ? s2073 : s2074;+  const SWord8 s2565 = 1 & s2564;+  const SBool  s2566 = 0 != s2565;+  const SBool  s2567 = 0 == 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 SWord8 s2575 = 1 & s2574;+  const SBool  s2576 = 0 != 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 SWord8 s2581 = 1 & s2580;+  const SBool  s2582 = 0 != 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 SWord8 s2587 = 1 & s2586;+  const SBool  s2588 = 0 != s2587;+  const SBool  s2589 = 0 == 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 SWord8 s2594 = 1 & s2593;+  const SBool  s2595 = 0 != 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 SWord8 s2600 = 1 & s2599;+  const SBool  s2601 = 0 != 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 SWord8 s2606 = 1 & s2605;+  const SBool  s2607 = 0 != s2606;+  const SBool  s2608 = 0 == 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 SWord8 s2705 = 1 & s2704;+  const SBool  s2706 = 0 != s2705;+  const SWord8 s2707 = s2706 ? s2597 : s2598;+  const SWord8 s2708 = 1 & s2707;+  const SBool  s2709 = 0 != s2708;+  const SWord8 s2710 = s2709 ? s2603 : s2604;+  const SWord8 s2711 = 1 & s2710;+  const SBool  s2712 = 0 != s2711;+  const SBool  s2713 = 0 == 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 SWord8 s2814 = 1 & s2813;+  const SBool  s2815 = 0 != s2814;+  const SWord8 s2816 = s2815 ? s2578 : s2579;+  const SWord8 s2817 = 1 & s2816;+  const SBool  s2818 = 0 != s2817;+  const SWord8 s2819 = s2818 ? s2584 : s2585;+  const SWord8 s2820 = 1 & s2819;+  const SBool  s2821 = 0 != s2820;+  const SBool  s2822 = 0 == 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 SWord8 s2830 = 1 & s2829;+  const SBool  s2831 = 0 != 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 SWord8 s2836 = 1 & s2835;+  const SBool  s2837 = 0 != 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 SWord8 s2842 = 1 & s2841;+  const SBool  s2843 = 0 != s2842;+  const SBool  s2844 = 0 == 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 SWord8 s2941 = 1 & s2940;+  const SBool  s2942 = 0 != s2941;+  const SWord8 s2943 = s2942 ? s2833 : s2834;+  const SWord8 s2944 = 1 & s2943;+  const SBool  s2945 = 0 != s2944;+  const SWord8 s2946 = s2945 ? s2839 : s2840;+  const SWord8 s2947 = 1 & s2946;+  const SBool  s2948 = 0 != s2947;+  const SBool  s2949 = 0 == 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 = s17 ? s2557 : s3049;+  const SWord8 s3051 = s1 + s2044;+  const SWord8 s3052 = 1 & s3051;+  const SBool  s3053 = 0 != s3052;+  const SWord8 s3054 = s3053 ? s2048 : s2049;+  const SWord8 s3055 = 1 & s3054;+  const SBool  s3056 = 0 != s3055;+  const SWord8 s3057 = s3056 ? s2054 : s2055;+  const SWord8 s3058 = 1 & s3057;+  const SBool  s3059 = 0 != s3058;+  const SBool  s3060 = 0 == 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 SWord8 s3068 = 1 & s3067;+  const SBool  s3069 = 0 != 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 SWord8 s3074 = 1 & s3073;+  const SBool  s3075 = 0 != 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 SWord8 s3080 = 1 & s3079;+  const SBool  s3081 = 0 != s3080;+  const SBool  s3082 = 0 == s3081;+  const SWord8 s3083 = (s3067 >> 1) | (s3067 << 7);+  const SWord8 s3084 = 128 | s3083;+  const SWord8 s3085 = 127 & s3083;+  const SWord8 s3086 = s16 ? s3084 : s3085;+  const SWord8 s3087 = 1 & s3086;+  const SBool  s3088 = 0 != 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 SWord8 s3093 = 1 & s3092;+  const SBool  s3094 = 0 != 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 SWord8 s3099 = 1 & s3098;+  const SBool  s3100 = 0 != s3099;+  const SBool  s3101 = 0 == 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 SWord8 s3106 = 1 & s3105;+  const SBool  s3107 = 0 != 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 SWord8 s3112 = 1 & s3111;+  const SBool  s3113 = 0 != 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 SWord8 s3118 = 1 & s3117;+  const SBool  s3119 = 0 != s3118;+  const SBool  s3120 = 0 == 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 SWord8 s3217 = 1 & s3216;+  const SBool  s3218 = 0 != s3217;+  const SWord8 s3219 = s3218 ? s3109 : s3110;+  const SWord8 s3220 = 1 & s3219;+  const SBool  s3221 = 0 != s3220;+  const SWord8 s3222 = s3221 ? s3115 : s3116;+  const SWord8 s3223 = 1 & s3222;+  const SBool  s3224 = 0 != s3223;+  const SBool  s3225 = 0 == 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 SWord8 s3326 = 1 & s3325;+  const SBool  s3327 = 0 != s3326;+  const SWord8 s3328 = s3327 ? s3090 : s3091;+  const SWord8 s3329 = 1 & s3328;+  const SBool  s3330 = 0 != s3329;+  const SWord8 s3331 = s3330 ? s3096 : s3097;+  const SWord8 s3332 = 1 & s3331;+  const SBool  s3333 = 0 != s3332;+  const SBool  s3334 = 0 == 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 SWord8 s3342 = 1 & s3341;+  const SBool  s3343 = 0 != 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 SWord8 s3348 = 1 & s3347;+  const SBool  s3349 = 0 != 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 SWord8 s3354 = 1 & s3353;+  const SBool  s3355 = 0 != s3354;+  const SBool  s3356 = 0 == 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 SWord8 s3453 = 1 & s3452;+  const SBool  s3454 = 0 != s3453;+  const SWord8 s3455 = s3454 ? s3345 : s3346;+  const SWord8 s3456 = 1 & s3455;+  const SBool  s3457 = 0 != s3456;+  const SWord8 s3458 = s3457 ? s3351 : s3352;+  const SWord8 s3459 = 1 & s3458;+  const SBool  s3460 = 0 != s3459;+  const SBool  s3461 = 0 == 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 SWord8 s3563 = 1 & s3562;+  const SBool  s3564 = 0 != s3563;+  const SWord8 s3565 = s3564 ? s3071 : s3072;+  const SWord8 s3566 = 1 & s3565;+  const SBool  s3567 = 0 != s3566;+  const SWord8 s3568 = s3567 ? s3077 : s3078;+  const SWord8 s3569 = 1 & s3568;+  const SBool  s3570 = 0 != s3569;+  const SBool  s3571 = 0 == 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 SWord8 s3579 = 1 & s3578;+  const SBool  s3580 = 0 != 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 SWord8 s3585 = 1 & s3584;+  const SBool  s3586 = 0 != 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 SWord8 s3591 = 1 & s3590;+  const SBool  s3592 = 0 != s3591;+  const SBool  s3593 = 0 == 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 SWord8 s3598 = 1 & s3597;+  const SBool  s3599 = 0 != 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 SWord8 s3604 = 1 & s3603;+  const SBool  s3605 = 0 != 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 SWord8 s3610 = 1 & s3609;+  const SBool  s3611 = 0 != s3610;+  const SBool  s3612 = 0 == 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 SWord8 s3709 = 1 & s3708;+  const SBool  s3710 = 0 != s3709;+  const SWord8 s3711 = s3710 ? s3601 : s3602;+  const SWord8 s3712 = 1 & s3711;+  const SBool  s3713 = 0 != s3712;+  const SWord8 s3714 = s3713 ? s3607 : s3608;+  const SWord8 s3715 = 1 & s3714;+  const SBool  s3716 = 0 != s3715;+  const SBool  s3717 = 0 == 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 SWord8 s3818 = 1 & s3817;+  const SBool  s3819 = 0 != s3818;+  const SWord8 s3820 = s3819 ? s3582 : s3583;+  const SWord8 s3821 = 1 & s3820;+  const SBool  s3822 = 0 != s3821;+  const SWord8 s3823 = s3822 ? s3588 : s3589;+  const SWord8 s3824 = 1 & s3823;+  const SBool  s3825 = 0 != s3824;+  const SBool  s3826 = 0 == 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 SWord8 s3834 = 1 & s3833;+  const SBool  s3835 = 0 != 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 SWord8 s3840 = 1 & s3839;+  const SBool  s3841 = 0 != 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 SWord8 s3846 = 1 & s3845;+  const SBool  s3847 = 0 != s3846;+  const SBool  s3848 = 0 == 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 SWord8 s3945 = 1 & s3944;+  const SBool  s3946 = 0 != s3945;+  const SWord8 s3947 = s3946 ? s3837 : s3838;+  const SWord8 s3948 = 1 & s3947;+  const SBool  s3949 = 0 != s3948;+  const SWord8 s3950 = s3949 ? s3843 : s3844;+  const SWord8 s3951 = 1 & s3950;+  const SBool  s3952 = 0 != s3951;+  const SBool  s3953 = 0 == 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 = s17 ? s3561 : s4053;+  const SWord8 s4055 = s12 ? s3050 : s4054;+  const SWord8 s4056 = s6 ? s2032 : s4055;+  const SWord8 s4057 = 1 & s105;+  const SBool  s4058 = 0 != s4057;+  const SWord8 s4059 = 1 & s101;+  const SBool  s4060 = 0 != s4059;+  const SWord8 s4061 = 1 & s97;+  const SBool  s4062 = 0 != 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 SWord8 s4075 = 1 & s110;+  const SBool  s4076 = 0 != s4075;+  const SWord8 s4077 = s4076 ? s4072 : s4073;+  const SWord8 s4078 = s93 ? s4074 : s4077;+  const SWord8 s4079 = 1 & s126;+  const SBool  s4080 = 0 != s4079;+  const SWord8 s4081 = 1 & s119;+  const SBool  s4082 = 0 != 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 SWord8 s4088 = 1 & s131;+  const SBool  s4089 = 0 != s4088;+  const SWord8 s4090 = s4089 ? s4085 : s4086;+  const SWord8 s4091 = s93 ? s4087 : s4090;+  const SWord8 s4092 = s74 ? s4078 : s4091;+  const SWord8 s4093 = 1 & s152;+  const SBool  s4094 = 0 != s4093;+  const SWord8 s4095 = 1 & s148;+  const SBool  s4096 = 0 != s4095;+  const SWord8 s4097 = 1 & s141;+  const SBool  s4098 = 0 != 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 SWord8 s4108 = 1 & s157;+  const SBool  s4109 = 0 != s4108;+  const SWord8 s4110 = s4109 ? s4105 : s4106;+  const SWord8 s4111 = s93 ? s4107 : s4110;+  const SWord8 s4112 = 1 & s173;+  const SBool  s4113 = 0 != s4112;+  const SWord8 s4114 = 1 & s166;+  const SBool  s4115 = 0 != 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 SWord8 s4121 = 1 & s178;+  const SBool  s4122 = 0 != 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 SWord8 s4127 = 1 & s213;+  const SBool  s4128 = 0 != s4127;+  const SWord8 s4129 = 1 & s209;+  const SBool  s4130 = 0 != s4129;+  const SWord8 s4131 = 1 & s205;+  const SBool  s4132 = 0 != 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 SWord8 s4145 = 1 & s218;+  const SBool  s4146 = 0 != s4145;+  const SWord8 s4147 = s4146 ? s4142 : s4143;+  const SWord8 s4148 = s198 ? s4144 : s4147;+  const SWord8 s4149 = 1 & s234;+  const SBool  s4150 = 0 != s4149;+  const SWord8 s4151 = 1 & s227;+  const SBool  s4152 = 0 != 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 SWord8 s4158 = 1 & s239;+  const SBool  s4159 = 0 != s4158;+  const SWord8 s4160 = s4159 ? s4155 : s4156;+  const SWord8 s4161 = s198 ? s4157 : s4160;+  const SWord8 s4162 = s74 ? s4148 : s4161;+  const SWord8 s4163 = 1 & s260;+  const SBool  s4164 = 0 != s4163;+  const SWord8 s4165 = 1 & s256;+  const SBool  s4166 = 0 != s4165;+  const SWord8 s4167 = 1 & s249;+  const SBool  s4168 = 0 != 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 SWord8 s4178 = 1 & s265;+  const SBool  s4179 = 0 != s4178;+  const SWord8 s4180 = s4179 ? s4175 : s4176;+  const SWord8 s4181 = s198 ? s4177 : s4180;+  const SWord8 s4182 = 1 & s281;+  const SBool  s4183 = 0 != s4182;+  const SWord8 s4184 = 1 & s274;+  const SBool  s4185 = 0 != 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 SWord8 s4191 = 1 & s286;+  const SBool  s4192 = 0 != 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 SWord8 s4198 = 1 & s341;+  const SBool  s4199 = 0 != s4198;+  const SWord8 s4200 = 1 & s337;+  const SBool  s4201 = 0 != s4200;+  const SWord8 s4202 = 1 & s333;+  const SBool  s4203 = 0 != 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 SWord8 s4216 = 1 & s346;+  const SBool  s4217 = 0 != s4216;+  const SWord8 s4218 = s4217 ? s4213 : s4214;+  const SWord8 s4219 = s329 ? s4215 : s4218;+  const SWord8 s4220 = 1 & s362;+  const SBool  s4221 = 0 != s4220;+  const SWord8 s4222 = 1 & s355;+  const SBool  s4223 = 0 != 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 SWord8 s4229 = 1 & s367;+  const SBool  s4230 = 0 != s4229;+  const SWord8 s4231 = s4230 ? s4226 : s4227;+  const SWord8 s4232 = s329 ? s4228 : s4231;+  const SWord8 s4233 = s307 ? s4219 : s4232;+  const SWord8 s4234 = 1 & s388;+  const SBool  s4235 = 0 != s4234;+  const SWord8 s4236 = 1 & s384;+  const SBool  s4237 = 0 != s4236;+  const SWord8 s4238 = 1 & s377;+  const SBool  s4239 = 0 != 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 SWord8 s4249 = 1 & s393;+  const SBool  s4250 = 0 != s4249;+  const SWord8 s4251 = s4250 ? s4246 : s4247;+  const SWord8 s4252 = s329 ? s4248 : s4251;+  const SWord8 s4253 = 1 & s409;+  const SBool  s4254 = 0 != s4253;+  const SWord8 s4255 = 1 & s402;+  const SBool  s4256 = 0 != 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 SWord8 s4262 = 1 & s414;+  const SBool  s4263 = 0 != 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 SWord8 s4268 = 1 & s449;+  const SBool  s4269 = 0 != s4268;+  const SWord8 s4270 = 1 & s445;+  const SBool  s4271 = 0 != s4270;+  const SWord8 s4272 = 1 & s441;+  const SBool  s4273 = 0 != 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 SWord8 s4286 = 1 & s454;+  const SBool  s4287 = 0 != s4286;+  const SWord8 s4288 = s4287 ? s4283 : s4284;+  const SWord8 s4289 = s434 ? s4285 : s4288;+  const SWord8 s4290 = 1 & s470;+  const SBool  s4291 = 0 != s4290;+  const SWord8 s4292 = 1 & s463;+  const SBool  s4293 = 0 != 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 SWord8 s4299 = 1 & s475;+  const SBool  s4300 = 0 != s4299;+  const SWord8 s4301 = s4300 ? s4296 : s4297;+  const SWord8 s4302 = s434 ? s4298 : s4301;+  const SWord8 s4303 = s307 ? s4289 : s4302;+  const SWord8 s4304 = 1 & s496;+  const SBool  s4305 = 0 != s4304;+  const SWord8 s4306 = 1 & s492;+  const SBool  s4307 = 0 != s4306;+  const SWord8 s4308 = 1 & s485;+  const SBool  s4309 = 0 != 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 SWord8 s4319 = 1 & s501;+  const SBool  s4320 = 0 != s4319;+  const SWord8 s4321 = s4320 ? s4316 : s4317;+  const SWord8 s4322 = s434 ? s4318 : s4321;+  const SWord8 s4323 = 1 & s517;+  const SBool  s4324 = 0 != s4323;+  const SWord8 s4325 = 1 & s510;+  const SBool  s4326 = 0 != 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 SWord8 s4332 = 1 & s522;+  const SBool  s4333 = 0 != 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 = s22 ? s4197 : s4338;+  const SWord8 s4340 = 1 & s597;+  const SBool  s4341 = 0 != s4340;+  const SWord8 s4342 = 1 & s593;+  const SBool  s4343 = 0 != s4342;+  const SWord8 s4344 = 1 & s589;+  const SBool  s4345 = 0 != 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 SWord8 s4358 = 1 & s602;+  const SBool  s4359 = 0 != s4358;+  const SWord8 s4360 = s4359 ? s4355 : s4356;+  const SWord8 s4361 = s585 ? s4357 : s4360;+  const SWord8 s4362 = 1 & s618;+  const SBool  s4363 = 0 != s4362;+  const SWord8 s4364 = 1 & s611;+  const SBool  s4365 = 0 != 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 SWord8 s4371 = 1 & s623;+  const SBool  s4372 = 0 != s4371;+  const SWord8 s4373 = s4372 ? s4368 : s4369;+  const SWord8 s4374 = s585 ? s4370 : s4373;+  const SWord8 s4375 = s566 ? s4361 : s4374;+  const SWord8 s4376 = 1 & s644;+  const SBool  s4377 = 0 != s4376;+  const SWord8 s4378 = 1 & s640;+  const SBool  s4379 = 0 != s4378;+  const SWord8 s4380 = 1 & s633;+  const SBool  s4381 = 0 != 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 SWord8 s4391 = 1 & s649;+  const SBool  s4392 = 0 != s4391;+  const SWord8 s4393 = s4392 ? s4388 : s4389;+  const SWord8 s4394 = s585 ? s4390 : s4393;+  const SWord8 s4395 = 1 & s665;+  const SBool  s4396 = 0 != s4395;+  const SWord8 s4397 = 1 & s658;+  const SBool  s4398 = 0 != 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 SWord8 s4404 = 1 & s670;+  const SBool  s4405 = 0 != 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 SWord8 s4410 = 1 & s705;+  const SBool  s4411 = 0 != s4410;+  const SWord8 s4412 = 1 & s701;+  const SBool  s4413 = 0 != s4412;+  const SWord8 s4414 = 1 & s697;+  const SBool  s4415 = 0 != 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 SWord8 s4428 = 1 & s710;+  const SBool  s4429 = 0 != s4428;+  const SWord8 s4430 = s4429 ? s4425 : s4426;+  const SWord8 s4431 = s690 ? s4427 : s4430;+  const SWord8 s4432 = 1 & s726;+  const SBool  s4433 = 0 != s4432;+  const SWord8 s4434 = 1 & s719;+  const SBool  s4435 = 0 != 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 SWord8 s4441 = 1 & s731;+  const SBool  s4442 = 0 != s4441;+  const SWord8 s4443 = s4442 ? s4438 : s4439;+  const SWord8 s4444 = s690 ? s4440 : s4443;+  const SWord8 s4445 = s566 ? s4431 : s4444;+  const SWord8 s4446 = 1 & s752;+  const SBool  s4447 = 0 != s4446;+  const SWord8 s4448 = 1 & s748;+  const SBool  s4449 = 0 != s4448;+  const SWord8 s4450 = 1 & s741;+  const SBool  s4451 = 0 != 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 SWord8 s4461 = 1 & s757;+  const SBool  s4462 = 0 != s4461;+  const SWord8 s4463 = s4462 ? s4458 : s4459;+  const SWord8 s4464 = s690 ? s4460 : s4463;+  const SWord8 s4465 = 1 & s773;+  const SBool  s4466 = 0 != s4465;+  const SWord8 s4467 = 1 & s766;+  const SBool  s4468 = 0 != 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 SWord8 s4474 = 1 & s778;+  const SBool  s4475 = 0 != 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 SWord8 s4481 = 1 & s833;+  const SBool  s4482 = 0 != s4481;+  const SWord8 s4483 = 1 & s829;+  const SBool  s4484 = 0 != s4483;+  const SWord8 s4485 = 1 & s825;+  const SBool  s4486 = 0 != 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 SWord8 s4499 = 1 & s838;+  const SBool  s4500 = 0 != s4499;+  const SWord8 s4501 = s4500 ? s4496 : s4497;+  const SWord8 s4502 = s821 ? s4498 : s4501;+  const SWord8 s4503 = 1 & s854;+  const SBool  s4504 = 0 != s4503;+  const SWord8 s4505 = 1 & s847;+  const SBool  s4506 = 0 != 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 SWord8 s4512 = 1 & s859;+  const SBool  s4513 = 0 != s4512;+  const SWord8 s4514 = s4513 ? s4509 : s4510;+  const SWord8 s4515 = s821 ? s4511 : s4514;+  const SWord8 s4516 = s799 ? s4502 : s4515;+  const SWord8 s4517 = 1 & s880;+  const SBool  s4518 = 0 != s4517;+  const SWord8 s4519 = 1 & s876;+  const SBool  s4520 = 0 != s4519;+  const SWord8 s4521 = 1 & s869;+  const SBool  s4522 = 0 != 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 SWord8 s4532 = 1 & s885;+  const SBool  s4533 = 0 != s4532;+  const SWord8 s4534 = s4533 ? s4529 : s4530;+  const SWord8 s4535 = s821 ? s4531 : s4534;+  const SWord8 s4536 = 1 & s901;+  const SBool  s4537 = 0 != s4536;+  const SWord8 s4538 = 1 & s894;+  const SBool  s4539 = 0 != 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 SWord8 s4545 = 1 & s906;+  const SBool  s4546 = 0 != 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 SWord8 s4551 = 1 & s941;+  const SBool  s4552 = 0 != s4551;+  const SWord8 s4553 = 1 & s937;+  const SBool  s4554 = 0 != s4553;+  const SWord8 s4555 = 1 & s933;+  const SBool  s4556 = 0 != 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 SWord8 s4569 = 1 & s946;+  const SBool  s4570 = 0 != s4569;+  const SWord8 s4571 = s4570 ? s4566 : s4567;+  const SWord8 s4572 = s926 ? s4568 : s4571;+  const SWord8 s4573 = 1 & s962;+  const SBool  s4574 = 0 != s4573;+  const SWord8 s4575 = 1 & s955;+  const SBool  s4576 = 0 != 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 SWord8 s4582 = 1 & s967;+  const SBool  s4583 = 0 != s4582;+  const SWord8 s4584 = s4583 ? s4579 : s4580;+  const SWord8 s4585 = s926 ? s4581 : s4584;+  const SWord8 s4586 = s799 ? s4572 : s4585;+  const SWord8 s4587 = 1 & s988;+  const SBool  s4588 = 0 != s4587;+  const SWord8 s4589 = 1 & s984;+  const SBool  s4590 = 0 != s4589;+  const SWord8 s4591 = 1 & s977;+  const SBool  s4592 = 0 != 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 SWord8 s4602 = 1 & s993;+  const SBool  s4603 = 0 != s4602;+  const SWord8 s4604 = s4603 ? s4599 : s4600;+  const SWord8 s4605 = s926 ? s4601 : s4604;+  const SWord8 s4606 = 1 & s1009;+  const SBool  s4607 = 0 != s4606;+  const SWord8 s4608 = 1 & s1002;+  const SBool  s4609 = 0 != 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 SWord8 s4615 = 1 & s1014;+  const SBool  s4616 = 0 != 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 = s22 ? s4480 : s4621;+  const SWord8 s4623 = s17 ? s4339 : s4622;+  const SWord8 s4624 = 1 & s1109;+  const SBool  s4625 = 0 != s4624;+  const SWord8 s4626 = 1 & s1105;+  const SBool  s4627 = 0 != s4626;+  const SWord8 s4628 = 1 & s1101;+  const SBool  s4629 = 0 != 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 SWord8 s4642 = 1 & s1114;+  const SBool  s4643 = 0 != s4642;+  const SWord8 s4644 = s4643 ? s4639 : s4640;+  const SWord8 s4645 = s1097 ? s4641 : s4644;+  const SWord8 s4646 = 1 & s1130;+  const SBool  s4647 = 0 != s4646;+  const SWord8 s4648 = 1 & s1123;+  const SBool  s4649 = 0 != 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 SWord8 s4655 = 1 & s1135;+  const SBool  s4656 = 0 != s4655;+  const SWord8 s4657 = s4656 ? s4652 : s4653;+  const SWord8 s4658 = s1097 ? s4654 : s4657;+  const SWord8 s4659 = s1078 ? s4645 : s4658;+  const SWord8 s4660 = 1 & s1156;+  const SBool  s4661 = 0 != s4660;+  const SWord8 s4662 = 1 & s1152;+  const SBool  s4663 = 0 != s4662;+  const SWord8 s4664 = 1 & s1145;+  const SBool  s4665 = 0 != 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 SWord8 s4675 = 1 & s1161;+  const SBool  s4676 = 0 != s4675;+  const SWord8 s4677 = s4676 ? s4672 : s4673;+  const SWord8 s4678 = s1097 ? s4674 : s4677;+  const SWord8 s4679 = 1 & s1177;+  const SBool  s4680 = 0 != s4679;+  const SWord8 s4681 = 1 & s1170;+  const SBool  s4682 = 0 != 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 SWord8 s4688 = 1 & s1182;+  const SBool  s4689 = 0 != 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 SWord8 s4694 = 1 & s1217;+  const SBool  s4695 = 0 != s4694;+  const SWord8 s4696 = 1 & s1213;+  const SBool  s4697 = 0 != s4696;+  const SWord8 s4698 = 1 & s1209;+  const SBool  s4699 = 0 != 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 SWord8 s4712 = 1 & s1222;+  const SBool  s4713 = 0 != s4712;+  const SWord8 s4714 = s4713 ? s4709 : s4710;+  const SWord8 s4715 = s1202 ? s4711 : s4714;+  const SWord8 s4716 = 1 & s1238;+  const SBool  s4717 = 0 != s4716;+  const SWord8 s4718 = 1 & s1231;+  const SBool  s4719 = 0 != 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 SWord8 s4725 = 1 & s1243;+  const SBool  s4726 = 0 != s4725;+  const SWord8 s4727 = s4726 ? s4722 : s4723;+  const SWord8 s4728 = s1202 ? s4724 : s4727;+  const SWord8 s4729 = s1078 ? s4715 : s4728;+  const SWord8 s4730 = 1 & s1264;+  const SBool  s4731 = 0 != s4730;+  const SWord8 s4732 = 1 & s1260;+  const SBool  s4733 = 0 != s4732;+  const SWord8 s4734 = 1 & s1253;+  const SBool  s4735 = 0 != 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 SWord8 s4745 = 1 & s1269;+  const SBool  s4746 = 0 != s4745;+  const SWord8 s4747 = s4746 ? s4742 : s4743;+  const SWord8 s4748 = s1202 ? s4744 : s4747;+  const SWord8 s4749 = 1 & s1285;+  const SBool  s4750 = 0 != s4749;+  const SWord8 s4751 = 1 & s1278;+  const SBool  s4752 = 0 != 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 SWord8 s4758 = 1 & s1290;+  const SBool  s4759 = 0 != 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 SWord8 s4765 = 1 & s1345;+  const SBool  s4766 = 0 != s4765;+  const SWord8 s4767 = 1 & s1341;+  const SBool  s4768 = 0 != s4767;+  const SWord8 s4769 = 1 & s1337;+  const SBool  s4770 = 0 != 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 SWord8 s4783 = 1 & s1350;+  const SBool  s4784 = 0 != s4783;+  const SWord8 s4785 = s4784 ? s4780 : s4781;+  const SWord8 s4786 = s1333 ? s4782 : s4785;+  const SWord8 s4787 = 1 & s1366;+  const SBool  s4788 = 0 != s4787;+  const SWord8 s4789 = 1 & s1359;+  const SBool  s4790 = 0 != 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 SWord8 s4796 = 1 & s1371;+  const SBool  s4797 = 0 != s4796;+  const SWord8 s4798 = s4797 ? s4793 : s4794;+  const SWord8 s4799 = s1333 ? s4795 : s4798;+  const SWord8 s4800 = s1311 ? s4786 : s4799;+  const SWord8 s4801 = 1 & s1392;+  const SBool  s4802 = 0 != s4801;+  const SWord8 s4803 = 1 & s1388;+  const SBool  s4804 = 0 != s4803;+  const SWord8 s4805 = 1 & s1381;+  const SBool  s4806 = 0 != 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 SWord8 s4816 = 1 & s1397;+  const SBool  s4817 = 0 != s4816;+  const SWord8 s4818 = s4817 ? s4813 : s4814;+  const SWord8 s4819 = s1333 ? s4815 : s4818;+  const SWord8 s4820 = 1 & s1413;+  const SBool  s4821 = 0 != s4820;+  const SWord8 s4822 = 1 & s1406;+  const SBool  s4823 = 0 != 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 SWord8 s4829 = 1 & s1418;+  const SBool  s4830 = 0 != 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 SWord8 s4835 = 1 & s1453;+  const SBool  s4836 = 0 != s4835;+  const SWord8 s4837 = 1 & s1449;+  const SBool  s4838 = 0 != s4837;+  const SWord8 s4839 = 1 & s1445;+  const SBool  s4840 = 0 != 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 SWord8 s4853 = 1 & s1458;+  const SBool  s4854 = 0 != s4853;+  const SWord8 s4855 = s4854 ? s4850 : s4851;+  const SWord8 s4856 = s1438 ? s4852 : s4855;+  const SWord8 s4857 = 1 & s1474;+  const SBool  s4858 = 0 != s4857;+  const SWord8 s4859 = 1 & s1467;+  const SBool  s4860 = 0 != 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 SWord8 s4866 = 1 & s1479;+  const SBool  s4867 = 0 != s4866;+  const SWord8 s4868 = s4867 ? s4863 : s4864;+  const SWord8 s4869 = s1438 ? s4865 : s4868;+  const SWord8 s4870 = s1311 ? s4856 : s4869;+  const SWord8 s4871 = 1 & s1500;+  const SBool  s4872 = 0 != s4871;+  const SWord8 s4873 = 1 & s1496;+  const SBool  s4874 = 0 != s4873;+  const SWord8 s4875 = 1 & s1489;+  const SBool  s4876 = 0 != 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 SWord8 s4886 = 1 & s1505;+  const SBool  s4887 = 0 != s4886;+  const SWord8 s4888 = s4887 ? s4883 : s4884;+  const SWord8 s4889 = s1438 ? s4885 : s4888;+  const SWord8 s4890 = 1 & s1521;+  const SBool  s4891 = 0 != s4890;+  const SWord8 s4892 = 1 & s1514;+  const SBool  s4893 = 0 != 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 SWord8 s4899 = 1 & s1526;+  const SBool  s4900 = 0 != 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 = s22 ? s4764 : s4905;+  const SWord8 s4907 = 1 & s1601;+  const SBool  s4908 = 0 != s4907;+  const SWord8 s4909 = 1 & s1597;+  const SBool  s4910 = 0 != s4909;+  const SWord8 s4911 = 1 & s1593;+  const SBool  s4912 = 0 != 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 SWord8 s4925 = 1 & s1606;+  const SBool  s4926 = 0 != s4925;+  const SWord8 s4927 = s4926 ? s4922 : s4923;+  const SWord8 s4928 = s1589 ? s4924 : s4927;+  const SWord8 s4929 = 1 & s1622;+  const SBool  s4930 = 0 != s4929;+  const SWord8 s4931 = 1 & s1615;+  const SBool  s4932 = 0 != 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 SWord8 s4938 = 1 & s1627;+  const SBool  s4939 = 0 != s4938;+  const SWord8 s4940 = s4939 ? s4935 : s4936;+  const SWord8 s4941 = s1589 ? s4937 : s4940;+  const SWord8 s4942 = s1570 ? s4928 : s4941;+  const SWord8 s4943 = 1 & s1648;+  const SBool  s4944 = 0 != s4943;+  const SWord8 s4945 = 1 & s1644;+  const SBool  s4946 = 0 != s4945;+  const SWord8 s4947 = 1 & s1637;+  const SBool  s4948 = 0 != 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 SWord8 s4958 = 1 & s1653;+  const SBool  s4959 = 0 != s4958;+  const SWord8 s4960 = s4959 ? s4955 : s4956;+  const SWord8 s4961 = s1589 ? s4957 : s4960;+  const SWord8 s4962 = 1 & s1669;+  const SBool  s4963 = 0 != s4962;+  const SWord8 s4964 = 1 & s1662;+  const SBool  s4965 = 0 != 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 SWord8 s4971 = 1 & s1674;+  const SBool  s4972 = 0 != 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 SWord8 s4977 = 1 & s1709;+  const SBool  s4978 = 0 != s4977;+  const SWord8 s4979 = 1 & s1705;+  const SBool  s4980 = 0 != s4979;+  const SWord8 s4981 = 1 & s1701;+  const SBool  s4982 = 0 != 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 SWord8 s4995 = 1 & s1714;+  const SBool  s4996 = 0 != s4995;+  const SWord8 s4997 = s4996 ? s4992 : s4993;+  const SWord8 s4998 = s1694 ? s4994 : s4997;+  const SWord8 s4999 = 1 & s1730;+  const SBool  s5000 = 0 != s4999;+  const SWord8 s5001 = 1 & s1723;+  const SBool  s5002 = 0 != 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 SWord8 s5008 = 1 & s1735;+  const SBool  s5009 = 0 != s5008;+  const SWord8 s5010 = s5009 ? s5005 : s5006;+  const SWord8 s5011 = s1694 ? s5007 : s5010;+  const SWord8 s5012 = s1570 ? s4998 : s5011;+  const SWord8 s5013 = 1 & s1756;+  const SBool  s5014 = 0 != s5013;+  const SWord8 s5015 = 1 & s1752;+  const SBool  s5016 = 0 != s5015;+  const SWord8 s5017 = 1 & s1745;+  const SBool  s5018 = 0 != 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 SWord8 s5028 = 1 & s1761;+  const SBool  s5029 = 0 != s5028;+  const SWord8 s5030 = s5029 ? s5025 : s5026;+  const SWord8 s5031 = s1694 ? s5027 : s5030;+  const SWord8 s5032 = 1 & s1777;+  const SBool  s5033 = 0 != s5032;+  const SWord8 s5034 = 1 & s1770;+  const SBool  s5035 = 0 != 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 SWord8 s5041 = 1 & s1782;+  const SBool  s5042 = 0 != 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 SWord8 s5048 = 1 & s1837;+  const SBool  s5049 = 0 != s5048;+  const SWord8 s5050 = 1 & s1833;+  const SBool  s5051 = 0 != s5050;+  const SWord8 s5052 = 1 & s1829;+  const SBool  s5053 = 0 != 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 SWord8 s5066 = 1 & s1842;+  const SBool  s5067 = 0 != s5066;+  const SWord8 s5068 = s5067 ? s5063 : s5064;+  const SWord8 s5069 = s1825 ? s5065 : s5068;+  const SWord8 s5070 = 1 & s1858;+  const SBool  s5071 = 0 != s5070;+  const SWord8 s5072 = 1 & s1851;+  const SBool  s5073 = 0 != 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 SWord8 s5079 = 1 & s1863;+  const SBool  s5080 = 0 != s5079;+  const SWord8 s5081 = s5080 ? s5076 : s5077;+  const SWord8 s5082 = s1825 ? s5078 : s5081;+  const SWord8 s5083 = s1803 ? s5069 : s5082;+  const SWord8 s5084 = 1 & s1884;+  const SBool  s5085 = 0 != s5084;+  const SWord8 s5086 = 1 & s1880;+  const SBool  s5087 = 0 != s5086;+  const SWord8 s5088 = 1 & s1873;+  const SBool  s5089 = 0 != 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 SWord8 s5099 = 1 & s1889;+  const SBool  s5100 = 0 != s5099;+  const SWord8 s5101 = s5100 ? s5096 : s5097;+  const SWord8 s5102 = s1825 ? s5098 : s5101;+  const SWord8 s5103 = 1 & s1905;+  const SBool  s5104 = 0 != s5103;+  const SWord8 s5105 = 1 & s1898;+  const SBool  s5106 = 0 != 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 SWord8 s5112 = 1 & s1910;+  const SBool  s5113 = 0 != 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 SWord8 s5118 = 1 & s1945;+  const SBool  s5119 = 0 != s5118;+  const SWord8 s5120 = 1 & s1941;+  const SBool  s5121 = 0 != s5120;+  const SWord8 s5122 = 1 & s1937;+  const SBool  s5123 = 0 != 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 SWord8 s5136 = 1 & s1950;+  const SBool  s5137 = 0 != s5136;+  const SWord8 s5138 = s5137 ? s5133 : s5134;+  const SWord8 s5139 = s1930 ? s5135 : s5138;+  const SWord8 s5140 = 1 & s1966;+  const SBool  s5141 = 0 != s5140;+  const SWord8 s5142 = 1 & s1959;+  const SBool  s5143 = 0 != 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 SWord8 s5149 = 1 & s1971;+  const SBool  s5150 = 0 != s5149;+  const SWord8 s5151 = s5150 ? s5146 : s5147;+  const SWord8 s5152 = s1930 ? s5148 : s5151;+  const SWord8 s5153 = s1803 ? s5139 : s5152;+  const SWord8 s5154 = 1 & s1992;+  const SBool  s5155 = 0 != s5154;+  const SWord8 s5156 = 1 & s1988;+  const SBool  s5157 = 0 != s5156;+  const SWord8 s5158 = 1 & s1981;+  const SBool  s5159 = 0 != 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 SWord8 s5169 = 1 & s1997;+  const SBool  s5170 = 0 != s5169;+  const SWord8 s5171 = s5170 ? s5166 : s5167;+  const SWord8 s5172 = s1930 ? s5168 : s5171;+  const SWord8 s5173 = 1 & s2013;+  const SBool  s5174 = 0 != s5173;+  const SWord8 s5175 = 1 & s2006;+  const SBool  s5176 = 0 != 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 SWord8 s5182 = 1 & s2018;+  const SBool  s5183 = 0 != 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 = s22 ? s5047 : s5188;+  const SWord8 s5190 = s17 ? s4906 : s5189;+  const SWord8 s5191 = s12 ? s4623 : s5190;+  const SWord8 s5192 = 1 & s2128;+  const SBool  s5193 = 0 != s5192;+  const SWord8 s5194 = 1 & s2124;+  const SBool  s5195 = 0 != s5194;+  const SWord8 s5196 = 1 & s2120;+  const SBool  s5197 = 0 != 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 SWord8 s5210 = 1 & s2133;+  const SBool  s5211 = 0 != s5210;+  const SWord8 s5212 = s5211 ? s5207 : s5208;+  const SWord8 s5213 = s2116 ? s5209 : s5212;+  const SWord8 s5214 = 1 & s2149;+  const SBool  s5215 = 0 != s5214;+  const SWord8 s5216 = 1 & s2142;+  const SBool  s5217 = 0 != 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 SWord8 s5223 = 1 & s2154;+  const SBool  s5224 = 0 != s5223;+  const SWord8 s5225 = s5224 ? s5220 : s5221;+  const SWord8 s5226 = s2116 ? s5222 : s5225;+  const SWord8 s5227 = s2097 ? s5213 : s5226;+  const SWord8 s5228 = 1 & s2175;+  const SBool  s5229 = 0 != s5228;+  const SWord8 s5230 = 1 & s2171;+  const SBool  s5231 = 0 != s5230;+  const SWord8 s5232 = 1 & s2164;+  const SBool  s5233 = 0 != 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 SWord8 s5243 = 1 & s2180;+  const SBool  s5244 = 0 != s5243;+  const SWord8 s5245 = s5244 ? s5240 : s5241;+  const SWord8 s5246 = s2116 ? s5242 : s5245;+  const SWord8 s5247 = 1 & s2196;+  const SBool  s5248 = 0 != s5247;+  const SWord8 s5249 = 1 & s2189;+  const SBool  s5250 = 0 != 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 SWord8 s5256 = 1 & s2201;+  const SBool  s5257 = 0 != 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 SWord8 s5262 = 1 & s2236;+  const SBool  s5263 = 0 != s5262;+  const SWord8 s5264 = 1 & s2232;+  const SBool  s5265 = 0 != s5264;+  const SWord8 s5266 = 1 & s2228;+  const SBool  s5267 = 0 != 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 SWord8 s5280 = 1 & s2241;+  const SBool  s5281 = 0 != s5280;+  const SWord8 s5282 = s5281 ? s5277 : s5278;+  const SWord8 s5283 = s2221 ? s5279 : s5282;+  const SWord8 s5284 = 1 & s2257;+  const SBool  s5285 = 0 != s5284;+  const SWord8 s5286 = 1 & s2250;+  const SBool  s5287 = 0 != 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 SWord8 s5293 = 1 & s2262;+  const SBool  s5294 = 0 != s5293;+  const SWord8 s5295 = s5294 ? s5290 : s5291;+  const SWord8 s5296 = s2221 ? s5292 : s5295;+  const SWord8 s5297 = s2097 ? s5283 : s5296;+  const SWord8 s5298 = 1 & s2283;+  const SBool  s5299 = 0 != s5298;+  const SWord8 s5300 = 1 & s2279;+  const SBool  s5301 = 0 != s5300;+  const SWord8 s5302 = 1 & s2272;+  const SBool  s5303 = 0 != 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 SWord8 s5313 = 1 & s2288;+  const SBool  s5314 = 0 != s5313;+  const SWord8 s5315 = s5314 ? s5310 : s5311;+  const SWord8 s5316 = s2221 ? s5312 : s5315;+  const SWord8 s5317 = 1 & s2304;+  const SBool  s5318 = 0 != s5317;+  const SWord8 s5319 = 1 & s2297;+  const SBool  s5320 = 0 != 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 SWord8 s5326 = 1 & s2309;+  const SBool  s5327 = 0 != 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 SWord8 s5333 = 1 & s2364;+  const SBool  s5334 = 0 != s5333;+  const SWord8 s5335 = 1 & s2360;+  const SBool  s5336 = 0 != s5335;+  const SWord8 s5337 = 1 & s2356;+  const SBool  s5338 = 0 != 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 SWord8 s5351 = 1 & s2369;+  const SBool  s5352 = 0 != s5351;+  const SWord8 s5353 = s5352 ? s5348 : s5349;+  const SWord8 s5354 = s2352 ? s5350 : s5353;+  const SWord8 s5355 = 1 & s2385;+  const SBool  s5356 = 0 != s5355;+  const SWord8 s5357 = 1 & s2378;+  const SBool  s5358 = 0 != 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 SWord8 s5364 = 1 & s2390;+  const SBool  s5365 = 0 != s5364;+  const SWord8 s5366 = s5365 ? s5361 : s5362;+  const SWord8 s5367 = s2352 ? s5363 : s5366;+  const SWord8 s5368 = s2330 ? s5354 : s5367;+  const SWord8 s5369 = 1 & s2411;+  const SBool  s5370 = 0 != s5369;+  const SWord8 s5371 = 1 & s2407;+  const SBool  s5372 = 0 != s5371;+  const SWord8 s5373 = 1 & s2400;+  const SBool  s5374 = 0 != 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 SWord8 s5384 = 1 & s2416;+  const SBool  s5385 = 0 != s5384;+  const SWord8 s5386 = s5385 ? s5381 : s5382;+  const SWord8 s5387 = s2352 ? s5383 : s5386;+  const SWord8 s5388 = 1 & s2432;+  const SBool  s5389 = 0 != s5388;+  const SWord8 s5390 = 1 & s2425;+  const SBool  s5391 = 0 != 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 SWord8 s5397 = 1 & s2437;+  const SBool  s5398 = 0 != 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 SWord8 s5403 = 1 & s2472;+  const SBool  s5404 = 0 != s5403;+  const SWord8 s5405 = 1 & s2468;+  const SBool  s5406 = 0 != s5405;+  const SWord8 s5407 = 1 & s2464;+  const SBool  s5408 = 0 != 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 SWord8 s5421 = 1 & s2477;+  const SBool  s5422 = 0 != s5421;+  const SWord8 s5423 = s5422 ? s5418 : s5419;+  const SWord8 s5424 = s2457 ? s5420 : s5423;+  const SWord8 s5425 = 1 & s2493;+  const SBool  s5426 = 0 != s5425;+  const SWord8 s5427 = 1 & s2486;+  const SBool  s5428 = 0 != 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 SWord8 s5434 = 1 & s2498;+  const SBool  s5435 = 0 != s5434;+  const SWord8 s5436 = s5435 ? s5431 : s5432;+  const SWord8 s5437 = s2457 ? s5433 : s5436;+  const SWord8 s5438 = s2330 ? s5424 : s5437;+  const SWord8 s5439 = 1 & s2519;+  const SBool  s5440 = 0 != s5439;+  const SWord8 s5441 = 1 & s2515;+  const SBool  s5442 = 0 != s5441;+  const SWord8 s5443 = 1 & s2508;+  const SBool  s5444 = 0 != 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 SWord8 s5454 = 1 & s2524;+  const SBool  s5455 = 0 != s5454;+  const SWord8 s5456 = s5455 ? s5451 : s5452;+  const SWord8 s5457 = s2457 ? s5453 : s5456;+  const SWord8 s5458 = 1 & s2540;+  const SBool  s5459 = 0 != s5458;+  const SWord8 s5460 = 1 & s2533;+  const SBool  s5461 = 0 != 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 SWord8 s5467 = 1 & s2545;+  const SBool  s5468 = 0 != 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 SWord8 s5475 = 1 & s2620;+  const SBool  s5476 = 0 != s5475;+  const SWord8 s5477 = 1 & s2616;+  const SBool  s5478 = 0 != s5477;+  const SWord8 s5479 = 1 & s2612;+  const SBool  s5480 = 0 != 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 SWord8 s5493 = 1 & s2625;+  const SBool  s5494 = 0 != s5493;+  const SWord8 s5495 = s5494 ? s5490 : s5491;+  const SWord8 s5496 = s2608 ? s5492 : s5495;+  const SWord8 s5497 = 1 & s2641;+  const SBool  s5498 = 0 != s5497;+  const SWord8 s5499 = 1 & s2634;+  const SBool  s5500 = 0 != 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 SWord8 s5506 = 1 & s2646;+  const SBool  s5507 = 0 != s5506;+  const SWord8 s5508 = s5507 ? s5503 : s5504;+  const SWord8 s5509 = s2608 ? s5505 : s5508;+  const SWord8 s5510 = s2589 ? s5496 : s5509;+  const SWord8 s5511 = 1 & s2667;+  const SBool  s5512 = 0 != s5511;+  const SWord8 s5513 = 1 & s2663;+  const SBool  s5514 = 0 != s5513;+  const SWord8 s5515 = 1 & s2656;+  const SBool  s5516 = 0 != 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 SWord8 s5526 = 1 & s2672;+  const SBool  s5527 = 0 != s5526;+  const SWord8 s5528 = s5527 ? s5523 : s5524;+  const SWord8 s5529 = s2608 ? s5525 : s5528;+  const SWord8 s5530 = 1 & s2688;+  const SBool  s5531 = 0 != s5530;+  const SWord8 s5532 = 1 & s2681;+  const SBool  s5533 = 0 != 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 SWord8 s5539 = 1 & s2693;+  const SBool  s5540 = 0 != 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 SWord8 s5545 = 1 & s2728;+  const SBool  s5546 = 0 != s5545;+  const SWord8 s5547 = 1 & s2724;+  const SBool  s5548 = 0 != s5547;+  const SWord8 s5549 = 1 & s2720;+  const SBool  s5550 = 0 != 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 SWord8 s5563 = 1 & s2733;+  const SBool  s5564 = 0 != s5563;+  const SWord8 s5565 = s5564 ? s5560 : s5561;+  const SWord8 s5566 = s2713 ? s5562 : s5565;+  const SWord8 s5567 = 1 & s2749;+  const SBool  s5568 = 0 != s5567;+  const SWord8 s5569 = 1 & s2742;+  const SBool  s5570 = 0 != 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 SWord8 s5576 = 1 & s2754;+  const SBool  s5577 = 0 != s5576;+  const SWord8 s5578 = s5577 ? s5573 : s5574;+  const SWord8 s5579 = s2713 ? s5575 : s5578;+  const SWord8 s5580 = s2589 ? s5566 : s5579;+  const SWord8 s5581 = 1 & s2775;+  const SBool  s5582 = 0 != s5581;+  const SWord8 s5583 = 1 & s2771;+  const SBool  s5584 = 0 != s5583;+  const SWord8 s5585 = 1 & s2764;+  const SBool  s5586 = 0 != 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 SWord8 s5596 = 1 & s2780;+  const SBool  s5597 = 0 != s5596;+  const SWord8 s5598 = s5597 ? s5593 : s5594;+  const SWord8 s5599 = s2713 ? s5595 : s5598;+  const SWord8 s5600 = 1 & s2796;+  const SBool  s5601 = 0 != s5600;+  const SWord8 s5602 = 1 & s2789;+  const SBool  s5603 = 0 != 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 SWord8 s5609 = 1 & s2801;+  const SBool  s5610 = 0 != 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 SWord8 s5616 = 1 & s2856;+  const SBool  s5617 = 0 != s5616;+  const SWord8 s5618 = 1 & s2852;+  const SBool  s5619 = 0 != s5618;+  const SWord8 s5620 = 1 & s2848;+  const SBool  s5621 = 0 != 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 SWord8 s5634 = 1 & s2861;+  const SBool  s5635 = 0 != s5634;+  const SWord8 s5636 = s5635 ? s5631 : s5632;+  const SWord8 s5637 = s2844 ? s5633 : s5636;+  const SWord8 s5638 = 1 & s2877;+  const SBool  s5639 = 0 != s5638;+  const SWord8 s5640 = 1 & s2870;+  const SBool  s5641 = 0 != 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 SWord8 s5647 = 1 & s2882;+  const SBool  s5648 = 0 != s5647;+  const SWord8 s5649 = s5648 ? s5644 : s5645;+  const SWord8 s5650 = s2844 ? s5646 : s5649;+  const SWord8 s5651 = s2822 ? s5637 : s5650;+  const SWord8 s5652 = 1 & s2903;+  const SBool  s5653 = 0 != s5652;+  const SWord8 s5654 = 1 & s2899;+  const SBool  s5655 = 0 != s5654;+  const SWord8 s5656 = 1 & s2892;+  const SBool  s5657 = 0 != 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 SWord8 s5667 = 1 & s2908;+  const SBool  s5668 = 0 != s5667;+  const SWord8 s5669 = s5668 ? s5664 : s5665;+  const SWord8 s5670 = s2844 ? s5666 : s5669;+  const SWord8 s5671 = 1 & s2924;+  const SBool  s5672 = 0 != s5671;+  const SWord8 s5673 = 1 & s2917;+  const SBool  s5674 = 0 != 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 SWord8 s5680 = 1 & s2929;+  const SBool  s5681 = 0 != 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 SWord8 s5686 = 1 & s2964;+  const SBool  s5687 = 0 != s5686;+  const SWord8 s5688 = 1 & s2960;+  const SBool  s5689 = 0 != s5688;+  const SWord8 s5690 = 1 & s2956;+  const SBool  s5691 = 0 != 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 SWord8 s5704 = 1 & s2969;+  const SBool  s5705 = 0 != s5704;+  const SWord8 s5706 = s5705 ? s5701 : s5702;+  const SWord8 s5707 = s2949 ? s5703 : s5706;+  const SWord8 s5708 = 1 & s2985;+  const SBool  s5709 = 0 != s5708;+  const SWord8 s5710 = 1 & s2978;+  const SBool  s5711 = 0 != 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 SWord8 s5717 = 1 & s2990;+  const SBool  s5718 = 0 != s5717;+  const SWord8 s5719 = s5718 ? s5714 : s5715;+  const SWord8 s5720 = s2949 ? s5716 : s5719;+  const SWord8 s5721 = s2822 ? s5707 : s5720;+  const SWord8 s5722 = 1 & s3011;+  const SBool  s5723 = 0 != s5722;+  const SWord8 s5724 = 1 & s3007;+  const SBool  s5725 = 0 != s5724;+  const SWord8 s5726 = 1 & s3000;+  const SBool  s5727 = 0 != 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 SWord8 s5737 = 1 & s3016;+  const SBool  s5738 = 0 != s5737;+  const SWord8 s5739 = s5738 ? s5734 : s5735;+  const SWord8 s5740 = s2949 ? s5736 : s5739;+  const SWord8 s5741 = 1 & s3032;+  const SBool  s5742 = 0 != s5741;+  const SWord8 s5743 = 1 & s3025;+  const SBool  s5744 = 0 != 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 SWord8 s5750 = 1 & s3037;+  const SBool  s5751 = 0 != 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 = s17 ? s5474 : s5757;+  const SWord8 s5759 = 1 & s3132;+  const SBool  s5760 = 0 != s5759;+  const SWord8 s5761 = 1 & s3128;+  const SBool  s5762 = 0 != s5761;+  const SWord8 s5763 = 1 & s3124;+  const SBool  s5764 = 0 != 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 SWord8 s5777 = 1 & s3137;+  const SBool  s5778 = 0 != s5777;+  const SWord8 s5779 = s5778 ? s5774 : s5775;+  const SWord8 s5780 = s3120 ? s5776 : s5779;+  const SWord8 s5781 = 1 & s3153;+  const SBool  s5782 = 0 != s5781;+  const SWord8 s5783 = 1 & s3146;+  const SBool  s5784 = 0 != 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 SWord8 s5790 = 1 & s3158;+  const SBool  s5791 = 0 != s5790;+  const SWord8 s5792 = s5791 ? s5787 : s5788;+  const SWord8 s5793 = s3120 ? s5789 : s5792;+  const SWord8 s5794 = s3101 ? s5780 : s5793;+  const SWord8 s5795 = 1 & s3179;+  const SBool  s5796 = 0 != s5795;+  const SWord8 s5797 = 1 & s3175;+  const SBool  s5798 = 0 != s5797;+  const SWord8 s5799 = 1 & s3168;+  const SBool  s5800 = 0 != 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 SWord8 s5810 = 1 & s3184;+  const SBool  s5811 = 0 != s5810;+  const SWord8 s5812 = s5811 ? s5807 : s5808;+  const SWord8 s5813 = s3120 ? s5809 : s5812;+  const SWord8 s5814 = 1 & s3200;+  const SBool  s5815 = 0 != s5814;+  const SWord8 s5816 = 1 & s3193;+  const SBool  s5817 = 0 != 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 SWord8 s5823 = 1 & s3205;+  const SBool  s5824 = 0 != 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 SWord8 s5829 = 1 & s3240;+  const SBool  s5830 = 0 != s5829;+  const SWord8 s5831 = 1 & s3236;+  const SBool  s5832 = 0 != s5831;+  const SWord8 s5833 = 1 & s3232;+  const SBool  s5834 = 0 != 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 SWord8 s5847 = 1 & s3245;+  const SBool  s5848 = 0 != s5847;+  const SWord8 s5849 = s5848 ? s5844 : s5845;+  const SWord8 s5850 = s3225 ? s5846 : s5849;+  const SWord8 s5851 = 1 & s3261;+  const SBool  s5852 = 0 != s5851;+  const SWord8 s5853 = 1 & s3254;+  const SBool  s5854 = 0 != 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 SWord8 s5860 = 1 & s3266;+  const SBool  s5861 = 0 != s5860;+  const SWord8 s5862 = s5861 ? s5857 : s5858;+  const SWord8 s5863 = s3225 ? s5859 : s5862;+  const SWord8 s5864 = s3101 ? s5850 : s5863;+  const SWord8 s5865 = 1 & s3287;+  const SBool  s5866 = 0 != s5865;+  const SWord8 s5867 = 1 & s3283;+  const SBool  s5868 = 0 != s5867;+  const SWord8 s5869 = 1 & s3276;+  const SBool  s5870 = 0 != 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 SWord8 s5880 = 1 & s3292;+  const SBool  s5881 = 0 != s5880;+  const SWord8 s5882 = s5881 ? s5877 : s5878;+  const SWord8 s5883 = s3225 ? s5879 : s5882;+  const SWord8 s5884 = 1 & s3308;+  const SBool  s5885 = 0 != s5884;+  const SWord8 s5886 = 1 & s3301;+  const SBool  s5887 = 0 != 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 SWord8 s5893 = 1 & s3313;+  const SBool  s5894 = 0 != 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 SWord8 s5900 = 1 & s3368;+  const SBool  s5901 = 0 != s5900;+  const SWord8 s5902 = 1 & s3364;+  const SBool  s5903 = 0 != s5902;+  const SWord8 s5904 = 1 & s3360;+  const SBool  s5905 = 0 != 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 SWord8 s5918 = 1 & s3373;+  const SBool  s5919 = 0 != s5918;+  const SWord8 s5920 = s5919 ? s5915 : s5916;+  const SWord8 s5921 = s3356 ? s5917 : s5920;+  const SWord8 s5922 = 1 & s3389;+  const SBool  s5923 = 0 != s5922;+  const SWord8 s5924 = 1 & s3382;+  const SBool  s5925 = 0 != 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 SWord8 s5931 = 1 & s3394;+  const SBool  s5932 = 0 != s5931;+  const SWord8 s5933 = s5932 ? s5928 : s5929;+  const SWord8 s5934 = s3356 ? s5930 : s5933;+  const SWord8 s5935 = s3334 ? s5921 : s5934;+  const SWord8 s5936 = 1 & s3415;+  const SBool  s5937 = 0 != s5936;+  const SWord8 s5938 = 1 & s3411;+  const SBool  s5939 = 0 != s5938;+  const SWord8 s5940 = 1 & s3404;+  const SBool  s5941 = 0 != 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 SWord8 s5951 = 1 & s3420;+  const SBool  s5952 = 0 != s5951;+  const SWord8 s5953 = s5952 ? s5948 : s5949;+  const SWord8 s5954 = s3356 ? s5950 : s5953;+  const SWord8 s5955 = 1 & s3436;+  const SBool  s5956 = 0 != s5955;+  const SWord8 s5957 = 1 & s3429;+  const SBool  s5958 = 0 != 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 SWord8 s5964 = 1 & s3441;+  const SBool  s5965 = 0 != 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 SWord8 s5970 = 1 & s3476;+  const SBool  s5971 = 0 != s5970;+  const SWord8 s5972 = 1 & s3472;+  const SBool  s5973 = 0 != s5972;+  const SWord8 s5974 = 1 & s3468;+  const SBool  s5975 = 0 != 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 SWord8 s5988 = 1 & s3481;+  const SBool  s5989 = 0 != s5988;+  const SWord8 s5990 = s5989 ? s5985 : s5986;+  const SWord8 s5991 = s3461 ? s5987 : s5990;+  const SWord8 s5992 = 1 & s3497;+  const SBool  s5993 = 0 != s5992;+  const SWord8 s5994 = 1 & s3490;+  const SBool  s5995 = 0 != 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 SWord8 s6001 = 1 & s3502;+  const SBool  s6002 = 0 != s6001;+  const SWord8 s6003 = s6002 ? s5998 : s5999;+  const SWord8 s6004 = s3461 ? s6000 : s6003;+  const SWord8 s6005 = s3334 ? s5991 : s6004;+  const SWord8 s6006 = 1 & s3523;+  const SBool  s6007 = 0 != s6006;+  const SWord8 s6008 = 1 & s3519;+  const SBool  s6009 = 0 != s6008;+  const SWord8 s6010 = 1 & s3512;+  const SBool  s6011 = 0 != 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 SWord8 s6021 = 1 & s3528;+  const SBool  s6022 = 0 != s6021;+  const SWord8 s6023 = s6022 ? s6018 : s6019;+  const SWord8 s6024 = s3461 ? s6020 : s6023;+  const SWord8 s6025 = 1 & s3544;+  const SBool  s6026 = 0 != s6025;+  const SWord8 s6027 = 1 & s3537;+  const SBool  s6028 = 0 != 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 SWord8 s6034 = 1 & s3549;+  const SBool  s6035 = 0 != 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 SWord8 s6042 = 1 & s3624;+  const SBool  s6043 = 0 != s6042;+  const SWord8 s6044 = 1 & s3620;+  const SBool  s6045 = 0 != s6044;+  const SWord8 s6046 = 1 & s3616;+  const SBool  s6047 = 0 != 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 SWord8 s6060 = 1 & s3629;+  const SBool  s6061 = 0 != s6060;+  const SWord8 s6062 = s6061 ? s6057 : s6058;+  const SWord8 s6063 = s3612 ? s6059 : s6062;+  const SWord8 s6064 = 1 & s3645;+  const SBool  s6065 = 0 != s6064;+  const SWord8 s6066 = 1 & s3638;+  const SBool  s6067 = 0 != 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 SWord8 s6073 = 1 & s3650;+  const SBool  s6074 = 0 != s6073;+  const SWord8 s6075 = s6074 ? s6070 : s6071;+  const SWord8 s6076 = s3612 ? s6072 : s6075;+  const SWord8 s6077 = s3593 ? s6063 : s6076;+  const SWord8 s6078 = 1 & s3671;+  const SBool  s6079 = 0 != s6078;+  const SWord8 s6080 = 1 & s3667;+  const SBool  s6081 = 0 != s6080;+  const SWord8 s6082 = 1 & s3660;+  const SBool  s6083 = 0 != 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 SWord8 s6093 = 1 & s3676;+  const SBool  s6094 = 0 != s6093;+  const SWord8 s6095 = s6094 ? s6090 : s6091;+  const SWord8 s6096 = s3612 ? s6092 : s6095;+  const SWord8 s6097 = 1 & s3692;+  const SBool  s6098 = 0 != s6097;+  const SWord8 s6099 = 1 & s3685;+  const SBool  s6100 = 0 != 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 SWord8 s6106 = 1 & s3697;+  const SBool  s6107 = 0 != 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 SWord8 s6112 = 1 & s3732;+  const SBool  s6113 = 0 != s6112;+  const SWord8 s6114 = 1 & s3728;+  const SBool  s6115 = 0 != s6114;+  const SWord8 s6116 = 1 & s3724;+  const SBool  s6117 = 0 != 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 SWord8 s6130 = 1 & s3737;+  const SBool  s6131 = 0 != s6130;+  const SWord8 s6132 = s6131 ? s6127 : s6128;+  const SWord8 s6133 = s3717 ? s6129 : s6132;+  const SWord8 s6134 = 1 & s3753;+  const SBool  s6135 = 0 != s6134;+  const SWord8 s6136 = 1 & s3746;+  const SBool  s6137 = 0 != 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 SWord8 s6143 = 1 & s3758;+  const SBool  s6144 = 0 != s6143;+  const SWord8 s6145 = s6144 ? s6140 : s6141;+  const SWord8 s6146 = s3717 ? s6142 : s6145;+  const SWord8 s6147 = s3593 ? s6133 : s6146;+  const SWord8 s6148 = 1 & s3779;+  const SBool  s6149 = 0 != s6148;+  const SWord8 s6150 = 1 & s3775;+  const SBool  s6151 = 0 != s6150;+  const SWord8 s6152 = 1 & s3768;+  const SBool  s6153 = 0 != 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 SWord8 s6163 = 1 & s3784;+  const SBool  s6164 = 0 != s6163;+  const SWord8 s6165 = s6164 ? s6160 : s6161;+  const SWord8 s6166 = s3717 ? s6162 : s6165;+  const SWord8 s6167 = 1 & s3800;+  const SBool  s6168 = 0 != s6167;+  const SWord8 s6169 = 1 & s3793;+  const SBool  s6170 = 0 != 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 SWord8 s6176 = 1 & s3805;+  const SBool  s6177 = 0 != 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 SWord8 s6183 = 1 & s3860;+  const SBool  s6184 = 0 != s6183;+  const SWord8 s6185 = 1 & s3856;+  const SBool  s6186 = 0 != s6185;+  const SWord8 s6187 = 1 & s3852;+  const SBool  s6188 = 0 != 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 SWord8 s6201 = 1 & s3865;+  const SBool  s6202 = 0 != s6201;+  const SWord8 s6203 = s6202 ? s6198 : s6199;+  const SWord8 s6204 = s3848 ? s6200 : s6203;+  const SWord8 s6205 = 1 & s3881;+  const SBool  s6206 = 0 != s6205;+  const SWord8 s6207 = 1 & s3874;+  const SBool  s6208 = 0 != 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 SWord8 s6214 = 1 & s3886;+  const SBool  s6215 = 0 != s6214;+  const SWord8 s6216 = s6215 ? s6211 : s6212;+  const SWord8 s6217 = s3848 ? s6213 : s6216;+  const SWord8 s6218 = s3826 ? s6204 : s6217;+  const SWord8 s6219 = 1 & s3907;+  const SBool  s6220 = 0 != s6219;+  const SWord8 s6221 = 1 & s3903;+  const SBool  s6222 = 0 != s6221;+  const SWord8 s6223 = 1 & s3896;+  const SBool  s6224 = 0 != 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 SWord8 s6234 = 1 & s3912;+  const SBool  s6235 = 0 != s6234;+  const SWord8 s6236 = s6235 ? s6231 : s6232;+  const SWord8 s6237 = s3848 ? s6233 : s6236;+  const SWord8 s6238 = 1 & s3928;+  const SBool  s6239 = 0 != s6238;+  const SWord8 s6240 = 1 & s3921;+  const SBool  s6241 = 0 != 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 SWord8 s6247 = 1 & s3933;+  const SBool  s6248 = 0 != 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 SWord8 s6253 = 1 & s3968;+  const SBool  s6254 = 0 != s6253;+  const SWord8 s6255 = 1 & s3964;+  const SBool  s6256 = 0 != s6255;+  const SWord8 s6257 = 1 & s3960;+  const SBool  s6258 = 0 != 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 SWord8 s6271 = 1 & s3973;+  const SBool  s6272 = 0 != s6271;+  const SWord8 s6273 = s6272 ? s6268 : s6269;+  const SWord8 s6274 = s3953 ? s6270 : s6273;+  const SWord8 s6275 = 1 & s3989;+  const SBool  s6276 = 0 != s6275;+  const SWord8 s6277 = 1 & s3982;+  const SBool  s6278 = 0 != 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 SWord8 s6284 = 1 & s3994;+  const SBool  s6285 = 0 != s6284;+  const SWord8 s6286 = s6285 ? s6281 : s6282;+  const SWord8 s6287 = s3953 ? s6283 : s6286;+  const SWord8 s6288 = s3826 ? s6274 : s6287;+  const SWord8 s6289 = 1 & s4015;+  const SBool  s6290 = 0 != s6289;+  const SWord8 s6291 = 1 & s4011;+  const SBool  s6292 = 0 != s6291;+  const SWord8 s6293 = 1 & s4004;+  const SBool  s6294 = 0 != 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 SWord8 s6304 = 1 & s4020;+  const SBool  s6305 = 0 != s6304;+  const SWord8 s6306 = s6305 ? s6301 : s6302;+  const SWord8 s6307 = s3953 ? s6303 : s6306;+  const SWord8 s6308 = 1 & s4036;+  const SBool  s6309 = 0 != s6308;+  const SWord8 s6310 = 1 & s4029;+  const SBool  s6311 = 0 != 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 SWord8 s6317 = 1 & s4041;+  const SBool  s6318 = 0 != 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 = s17 ? s6041 : s6324;+  const SWord8 s6326 = s12 ? s5758 : s6325;+  const SWord8 s6327 = s6 ? s5191 : s6326;+  +  *hi = s4056;+  *lo = s6327;+}+== END: "legatoMult.c" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/popCount1.gold view
@@ -0,0 +1,126 @@+== BEGIN: "Makefile" ================+# Makefile for popCount. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#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" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/popCount2.gold view
@@ -0,0 +1,126 @@+== BEGIN: "Makefile" ================+# Makefile for popCount. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#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" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/prefixSum_16.gold view
@@ -0,0 +1,117 @@+INPUTS+  s0 :: SWord32+  s1 :: SWord32+  s2 :: SWord32+  s3 :: SWord32+  s4 :: SWord32+  s5 :: SWord32+  s6 :: SWord32+  s7 :: SWord32+  s8 :: SWord32+  s9 :: SWord32+  s10 :: SWord32+  s11 :: SWord32+  s12 :: SWord32+  s13 :: SWord32+  s14 :: SWord32+  s15 :: SWord32+CONSTANTS+  s_2 = False+  s_1 = True+TABLES+ARRAYS+UNINTERPRETED CONSTANTS+  uninterpreted_flOp :: SWord32 -> SWord32 -> SWord32+  uninterpreted_u :: SWord32+AXIOMS+  -- user defined axiom: flOp is associative+  :assumption (forall (?x BitVec[32]) (?y BitVec[32]) (?z BitVec[32])+                      (= (uninterpreted_flOp (uninterpreted_flOp ?x ?y) ?z)+                         (uninterpreted_flOp ?x (uninterpreted_flOp ?y ?z))+                      )+              )+  -- user defined axiom: u is left-unit for flOp+  :assumption (forall (?x BitVec[32])+                      (= (uninterpreted_flOp uninterpreted_u ?x)+                         ?x+                      )+              )+DEFINE+  s16 :: SWord32 = uninterpreted_u+  s17 :: SWord32 = s16 uninterpreted_flOp s0+  s18 :: SBool = s0 == s17+  s19 :: SWord32 = s0 uninterpreted_flOp s1+  s20 :: SWord32 = s16 uninterpreted_flOp s19+  s21 :: SBool = s19 == s20+  s22 :: SWord32 = s19 uninterpreted_flOp s2+  s23 :: SWord32 = s20 uninterpreted_flOp s2+  s24 :: SBool = s22 == s23+  s25 :: SWord32 = s22 uninterpreted_flOp s3+  s26 :: SWord32 = s2 uninterpreted_flOp s3+  s27 :: SWord32 = s19 uninterpreted_flOp s26+  s28 :: SWord32 = s16 uninterpreted_flOp s27+  s29 :: SBool = s25 == s28+  s30 :: SWord32 = s25 uninterpreted_flOp s4+  s31 :: SWord32 = s28 uninterpreted_flOp s4+  s32 :: SBool = s30 == s31+  s33 :: SWord32 = s30 uninterpreted_flOp s5+  s34 :: SWord32 = s4 uninterpreted_flOp s5+  s35 :: SWord32 = s28 uninterpreted_flOp s34+  s36 :: SBool = s33 == s35+  s37 :: SWord32 = s33 uninterpreted_flOp s6+  s38 :: SWord32 = s35 uninterpreted_flOp s6+  s39 :: SBool = s37 == s38+  s40 :: SWord32 = s37 uninterpreted_flOp s7+  s41 :: SWord32 = s6 uninterpreted_flOp s7+  s42 :: SWord32 = s34 uninterpreted_flOp s41+  s43 :: SWord32 = s27 uninterpreted_flOp s42+  s44 :: SWord32 = s16 uninterpreted_flOp s43+  s45 :: SBool = s40 == s44+  s46 :: SWord32 = s40 uninterpreted_flOp s8+  s47 :: SWord32 = s44 uninterpreted_flOp s8+  s48 :: SBool = s46 == s47+  s49 :: SWord32 = s46 uninterpreted_flOp s9+  s50 :: SWord32 = s8 uninterpreted_flOp s9+  s51 :: SWord32 = s44 uninterpreted_flOp s50+  s52 :: SBool = s49 == s51+  s53 :: SWord32 = s49 uninterpreted_flOp s10+  s54 :: SWord32 = s51 uninterpreted_flOp s10+  s55 :: SBool = s53 == s54+  s56 :: SWord32 = s53 uninterpreted_flOp s11+  s57 :: SWord32 = s10 uninterpreted_flOp s11+  s58 :: SWord32 = s50 uninterpreted_flOp s57+  s59 :: SWord32 = s44 uninterpreted_flOp s58+  s60 :: SBool = s56 == s59+  s61 :: SWord32 = s56 uninterpreted_flOp s12+  s62 :: SWord32 = s59 uninterpreted_flOp s12+  s63 :: SBool = s61 == s62+  s64 :: SWord32 = s61 uninterpreted_flOp s13+  s65 :: SWord32 = s12 uninterpreted_flOp s13+  s66 :: SWord32 = s59 uninterpreted_flOp s65+  s67 :: SBool = s64 == s66+  s68 :: SWord32 = s64 uninterpreted_flOp s14+  s69 :: SWord32 = s66 uninterpreted_flOp s14+  s70 :: SBool = s68 == s69+  s71 :: SWord32 = s68 uninterpreted_flOp s15+  s72 :: SWord32 = s14 uninterpreted_flOp s15+  s73 :: SWord32 = s65 uninterpreted_flOp s72+  s74 :: SWord32 = s58 uninterpreted_flOp s73+  s75 :: SWord32 = s43 uninterpreted_flOp s74+  s76 :: SBool = s71 == s75+  s77 :: SBool = s70 & s76+  s78 :: SBool = s67 & s77+  s79 :: SBool = s63 & s78+  s80 :: SBool = s60 & s79+  s81 :: SBool = s55 & s80+  s82 :: SBool = s52 & s81+  s83 :: SBool = s48 & s82+  s84 :: SBool = s45 & s83+  s85 :: SBool = s39 & s84+  s86 :: SBool = s36 & s85+  s87 :: SBool = s32 & s86+  s88 :: SBool = s29 & s87+  s89 :: SBool = s24 & s88+  s90 :: SBool = s21 & s89+  s91 :: SBool = s18 & s90+OUTPUTS+  s91
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/selChecked.gold view
@@ -0,0 +1,87 @@+== BEGIN: "Makefile" ================+# Makefile for selChecked. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#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" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/selUnchecked.gold view
@@ -0,0 +1,87 @@+== BEGIN: "Makefile" ================+# Makefile for selUnChecked. Automatically generated by SBV. Do not edit!++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 <inttypes.h>+#include <stdint.h>++/* Unsigned bit-vectors */+typedef uint8_t  SBool  ;+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 <inttypes.h>+#include <stdint.h>+#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 <inttypes.h>+#include <stdint.h>+#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" ==================
+ Temp/sbv-0.9.18/SBVUnitTest/GoldFiles/temperature.gold view
@@ -0,0 +1,2 @@+Satisfiable. Model:+  s0 = 28 :: SWord16
+ Temp/sbv-0.9.18/SBVUnitTest/SBVUnitTest.hs view
@@ -0,0 +1,172 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Main+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- SBV library unit-test program+-----------------------------------------------------------------------------++module Main(main, createGolds) where++import Control.Monad           (when)+import System.Directory        (doesDirectoryExist, findExecutable)+import System.Environment      (getArgs, getEnv)+import System.Exit             (exitWith, ExitCode(..))+import System.FilePath         ((</>))+import System.Process          (readProcessWithExitCode)+import Test.HUnit              (Test(..), Counts(..), runTestTT)++import Data.SBV                (yices, SMTSolver(..))+import Data.SBV.Utils.SBVTest  (SBVTestSuite(..), generateGoldCheck)+import Paths_sbv               (getDataDir)++-- To add a new collection of tests, import below and add to testCollection variable+import qualified Data.SBV.TestSuite.Arrays.Memory                  as T01_01(testSuite)+import qualified Data.SBV.TestSuite.Basics.Arithmetic              as T02_01(testSuite)+import qualified Data.SBV.TestSuite.Basics.BasicTests              as T02_02(testSuite)+import qualified Data.SBV.TestSuite.Basics.Higher                  as T02_03(testSuite)+import qualified Data.SBV.TestSuite.Basics.Index                   as T02_04(testSuite)+import qualified Data.SBV.TestSuite.Basics.ProofTests              as T02_05(testSuite)+import qualified Data.SBV.TestSuite.Basics.QRem                    as T02_06(testSuite)+import qualified Data.SBV.TestSuite.BitPrecise.BitTricks           as T03_01(testSuite)+import qualified Data.SBV.TestSuite.BitPrecise.Legato              as T03_02(testSuite)+import qualified Data.SBV.TestSuite.CRC.CCITT                      as T04_01(testSuite)+import qualified Data.SBV.TestSuite.CRC.CCITT_Unidir               as T04_02(testSuite)+import qualified Data.SBV.TestSuite.CRC.GenPoly                    as T04_03(testSuite)+import qualified Data.SBV.TestSuite.CRC.Parity                     as T04_04(testSuite)+import qualified Data.SBV.TestSuite.CRC.USB5                       as T04_05(testSuite)+import qualified Data.SBV.TestSuite.CodeGeneration.AddSub          as T05_01(testSuite)+import qualified Data.SBV.TestSuite.CodeGeneration.CgTests         as T05_02(testSuite)+import qualified Data.SBV.TestSuite.CodeGeneration.Fibonacci       as T05_03(testSuite)+import qualified Data.SBV.TestSuite.CodeGeneration.GCD             as T05_04(testSuite)+import qualified Data.SBV.TestSuite.CodeGeneration.PopulationCount as T05_05(testSuite)+import qualified Data.SBV.TestSuite.Crypto.AES                     as T06_01(testSuite)+import qualified Data.SBV.TestSuite.Polynomials.Polynomials        as T07_01(testSuite)+import qualified Data.SBV.TestSuite.PrefixSum.PrefixSum            as T08_01(testSuite)+import qualified Data.SBV.TestSuite.Puzzles.DogCatMouse            as T09_01(testSuite)+import qualified Data.SBV.TestSuite.Puzzles.Euler185               as T09_02(testSuite)+import qualified Data.SBV.TestSuite.Puzzles.MagicSquare            as T09_03(testSuite)+import qualified Data.SBV.TestSuite.Puzzles.NQueens                as T09_04(testSuite)+import qualified Data.SBV.TestSuite.Puzzles.PowerSet               as T09_05(testSuite)+import qualified Data.SBV.TestSuite.Puzzles.Sudoku                 as T09_06(testSuite)+import qualified Data.SBV.TestSuite.Puzzles.Temperature            as T09_07(testSuite)+import qualified Data.SBV.TestSuite.Puzzles.U2Bridge               as T09_08(testSuite)+import qualified Data.SBV.TestSuite.Uninterpreted.AUF              as T10_01(testSuite)+import qualified Data.SBV.TestSuite.Uninterpreted.Function         as T10_02(testSuite)+import qualified Data.SBV.TestSuite.Uninterpreted.Uninterpreted    as T10_03(testSuite)++testCollection :: [(String, SBVTestSuite)]+testCollection = [+       ("mem",         T01_01.testSuite)+     , ("arith",       T02_01.testSuite)+     , ("basic",       T02_02.testSuite)+     , ("higher",      T02_03.testSuite)+     , ("index",       T02_04.testSuite)+     , ("proof",       T02_05.testSuite)+     , ("qrem",        T02_06.testSuite)+     , ("bitTricks",   T03_01.testSuite)+     , ("legato",      T03_02.testSuite)+     , ("ccitt",       T04_01.testSuite)+     , ("ccitt2",      T04_02.testSuite)+     , ("genPoly",     T04_03.testSuite)+     , ("parity",      T04_04.testSuite)+     , ("usb5",        T04_05.testSuite)+     , ("addSub",      T05_01.testSuite)+     , ("cgtest",      T05_02.testSuite)+     , ("fib",         T05_03.testSuite)+     , ("gcd",         T05_04.testSuite)+     , ("popCount",    T05_05.testSuite)+     , ("aes",         T06_01.testSuite)+     , ("poly",        T07_01.testSuite)+     , ("prefixSum",   T08_01.testSuite)+     , ("dogCatMouse", T09_01.testSuite)+     , ("euler185",    T09_02.testSuite)+     , ("magicSquare", T09_03.testSuite)+     , ("nQueens",     T09_04.testSuite)+     , ("powerset",    T09_05.testSuite)+     , ("sudoku",      T09_06.testSuite)+     , ("temperature", T09_07.testSuite)+     , ("u2bridge",    T09_08.testSuite)+     , ("auf1",        T10_01.testSuite)+     , ("auf2",        T10_02.testSuite)+     , ("unint",       T10_03.testSuite)+     ]++-- No user serviceable parts below..++main :: IO ()+main = do tgts <- getArgs+          run tgts False []++createGolds :: String -> IO ()+createGolds tgts = run (words tgts) True ["SBVUnitTest/GoldFiles"]++checkGoldDir :: FilePath -> IO ()+checkGoldDir gd = do e <- doesDirectoryExist gd+                     when (not 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++checkYices :: IO ()+checkYices = do ex <- getEnv "SBV_YICES" `catch` (\_ -> return (executable yices))+                mbP <- findExecutable ex+                case mbP of+                  Nothing -> do putStrLn $ "*** Cannot find default SMT solver executable for " ++ nm+                                putStrLn $ "*** Please make sure the executable " ++ show ex+                                putStrLn $ "*** is installed and is in your path."+                                putStrLn $ "*** Cannot run test cases, exiting."+                                exitWith $ ExitFailure 1+                  Just p  -> do putStrLn $ "*** Using solver : " ++ nm ++ " (" ++ show p ++ ")"+                                checkYicesVersion p+ where nm = name yices++checkYicesVersion :: FilePath -> IO ()+checkYicesVersion p =+        do (ec, yOut, _yErr) <- readProcessWithExitCode p ["-V"] ""+           case ec of+             ExitFailure _ -> do putStrLn $ "*** Cannot determine Yices version. Please install Yices version 2.X first."+                                 exitWith $ ExitFailure 1+             ExitSuccess   -> do let isYices1 = take 2 yOut == "1." -- crude test; might fail..+                                 when isYices1 $ putStrLn $ "*** Yices version 1.X is detected. Version 2.X is strongly recommended!"+                                 opts <- getEnv "SBV_YICES_OPTIONS" `catch` (\_ -> return (unwords (options yices)))+                                 when (isYices1 && opts /= "-tc -smt -e") $ do+                                           putStrLn $ "*** Either install Yices 2.X, or set the environment variable:"+                                           putStrLn $ "***     SBV_YICES_OPTIONS=\"-tc -smt -e\""+                                           putStrLn $ "*** To use Yices 1.X with SBV."+                                           putStrLn $ "*** However, upgrading to Yices 2.X is highly recommended!"+                                           exitWith $ ExitFailure 1++run :: [String] -> Bool -> [String] -> IO ()+run targets shouldCreate [gd] =+        do mapM_ checkTgt targets+           putStrLn $ "*** Starting SBV unit tests..\n*** Gold files at: " ++ show gd+           checkGoldDir gd+           checkYices+           cts <- runTestTT $ TestList $ map mkTst [c | (tc, c) <- testCollection, select tc]+           decide shouldCreate cts+  where mkTst (SBVTestSuite f) = f $ generateGoldCheck gd shouldCreate+        select tc = null targets || tc `elem` targets+        checkTgt t | t `elem` allTargets = return ()+                   | True                = do putStrLn $ "*** Unknown test target: " ++ show t+                                              exitWith $ ExitFailure 1+        allTargets = map fst testCollection+run targets shouldCreate [] = getDataDir >>= \d -> run targets shouldCreate [d </> "SBVUnitTest" </> "GoldFiles"]+run _       _            _  = error "SBVUnitTests.run: impossible happened!"++decide :: Bool -> Counts -> IO ()+decide shouldCreate cts@(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 if shouldCreate+                      then putStrLn $ "All " ++ show c ++ " test cases executed in gold-file generation mode."+                      else putStrLn $ "All " ++ show c ++ " test cases successfully passed."+                   exitWith $ ExitSuccess+           else exitWith $ ExitFailure 2
+ Temp/sbv-0.9.18/Setup.hs view
@@ -0,0 +1,33 @@+-----------------------------------------------------------------------------+-- |+-- Module      :  Main+-- Copyright   :  (c) Levent Erkok+-- License     :  BSD3+-- Maintainer  :  erkokl@gmail.com+-- Stability   :  experimental+-- Portability :  portable+--+-- Setup module for the sbv library+-----------------------------------------------------------------------------++{-# OPTIONS_GHC -Wall #-}+module Main(main) where++import Distribution.Simple (defaultMainWithHooks, simpleUserHooks, postInst)+import System.Directory    (findExecutable)+import System.Exit         (exitWith, ExitCode(..))++import Data.SBV.Provers.Prover (SMTSolver(..), yices)++main :: IO ()+main = defaultMainWithHooks simpleUserHooks{ postInst = checkDefSolver }+ where checkDefSolver _ _ _ _ = do+                mbP <- findExecutable ex+                case mbP of+                   Nothing -> do putStrLn $ "*** The sbv library requires the default solver " ++ nm ++ " to be installed."+                                 putStrLn $ "*** The executable " ++ show ex ++ " must be in your path."+                                 putStrLn $ "*** Do not forget to install " ++ nm ++ "!"+                   Just _  -> return ()+                exitWith ExitSuccess+       ex = executable yices+       nm = name yices
+ Temp/sbv-0.9.18/sbv.cabal view
@@ -0,0 +1,176 @@+Name:          sbv+Version:       0.9.18+Category:      Formal Methods, Theorem Provers, Bit vectors, Symbolic Computation, Math+Synopsis:      Symbolic Bit Vectors: Prove bit-precise program properties using SMT solvers.+Description:   Express properties about bit-precise Haskell programs and automatically prove+               them using SMT solvers. Automatically generate C programs from Haskell functions.+               The SBV library adds support for symbolic bit vectors, allowing formal models of+               bit-precise programs to be created.+               .+               >   $ ghci -XScopedTypeVariables+               >   Prelude> :m Data.SBV+               >   Prelude Data.SBV> prove $ \(x::SWord8) -> x `shiftL` 2 .== 4*x+               >   Q.E.D.+               >   Prelude Data.SBV> prove $ forAll ["x"] $ \(x::SWord8) -> x `shiftL` 2 .== x+               >   Falsifiable. Counter-example:+               >     x = 128 :: SWord8+               .+               The library introduces the following types and concepts:+               .+                 * 'SBool': Symbolic Booleans (bits)+               .+                 * 'SWord8', 'SWord16', 'SWord32', 'SWord64': Symbolic Words (unsigned)+               .+                 * 'SInt8',  'SInt16',  'SInt32',  'SInt64': Symbolic Ints (signed)+               .+                 * 'SArray', 'SFunArray': Flat arrays of symbolic values+               .+                 * Symbolic polynomials over GF(2^n), and polynomial arithmetic+               .+                 * Uninterpreted constants and functions over symbolic values, with user+                   defined SMT-Lib axioms+               .+               Predicates (i.e., functions that return 'SBool') built out of+               these types can be:+               .+                 * proven correct via an external SMT solver (the 'prove' function)+               .+                 * checked for satisfiability (the 'sat' and 'allSat' functions)+               .+                 * quick-checked+               .+               The SBV library can also compile Haskell functions that manipulate symbolic+               values directly to C, rendering them as straight-line C programs that can be+               executed in, say, embedded platforms.+               .+               In addition to the library, the installation will create the+               executable @SBVUnitTests@. You should run it once the installation is complete,+               to make sure the unit tests are run and all is well.+               .+               SBV is hosted at GitHub: <http://github.com/LeventErkok/sbv>. Comments,+               bug reports, and patches are always welcome.+               .+               Galois, Inc. (<http://www.galois.com>) has contributed to the development of SBV,+               by providing time and computing machinery. The following people reported bugs,+               provided comments/feedback, or contributed to the development of SBV in various ways:+               Ian Blumenfeld, Iavor Diatchki, Lee Pike, Austin Seipp, Don Stewart, and Josef Svenningsson.++Copyright:     Levent Erkok, 2010-2011+License:       BSD3+License-file:  LICENSE+Stability:     Experimental+Author:        Levent Erkok+Homepage:      http://github.com/LeventErkok/sbv+Bug-reports:   http://github.com/LeventErkok/sbv/issues+Maintainer:    Levent Erkok (erkokl@gmail.com)+Build-Type:    Custom+Cabal-Version: >= 1.6+Data-Files: SBVUnitTest/GoldFiles/*.gold+Extra-Source-Files: INSTALL, README, COPYRIGHT++source-repository head+    type:       git+    location:   git://github.com/LeventErkok/sbv.git++Library+  ghc-options     : -Wall+  ghc-prof-options: -auto-all -caf-all+  Build-Depends   : base                >= 3 && < 5+                  , deepseq             >= 1.1.0.2+                  , process             >= 1.0.1.3+                  , containers          >= 0.3.0.0+                  , QuickCheck          >= 2.4.0.1+                  , strict-concurrency  >= 0.2.4.1+                  , old-time            >= 1.0.0.5+                  , mtl                 >= 2.0.1.0+                  , array               >= 0.3.0.1+                  , HUnit               >= 1.2.2.3+                  , directory           >= 1.0.1.1+                  , filepath            >= 1.1.0.4+                  , pretty              >= 1.0.1.1+                  , random              >= 1.0.0.2+  Exposed-modules : Data.SBV+                  , Data.SBV.Internals+                  , Data.SBV.Examples.BitPrecise.BitTricks+                  , Data.SBV.Examples.BitPrecise.Legato+                  , Data.SBV.Examples.CodeGeneration.AddSub+                  , Data.SBV.Examples.CodeGeneration.Fibonacci+                  , Data.SBV.Examples.CodeGeneration.GCD+                  , Data.SBV.Examples.CodeGeneration.PopulationCount+                  , Data.SBV.Examples.Crypto.AES+                  , Data.SBV.Examples.Polynomials.Polynomials+                  , Data.SBV.Examples.PrefixSum.PrefixSum+                  , Data.SBV.Examples.Puzzles.DogCatMouse+                  , Data.SBV.Examples.Puzzles.Euler185+                  , Data.SBV.Examples.Puzzles.MagicSquare+                  , Data.SBV.Examples.Puzzles.NQueens+                  , Data.SBV.Examples.Puzzles.Sudoku+                  , Data.SBV.Examples.Puzzles.U2Bridge+                  , Data.SBV.Examples.Uninterpreted.AUF+                  , Data.SBV.Examples.Uninterpreted.Function+  Other-modules   : Data.SBV.BitVectors.Data+                  , Data.SBV.BitVectors.Model+                  , Data.SBV.BitVectors.Splittable+                  , Data.SBV.BitVectors.Polynomial+                  , Data.SBV.BitVectors.PrettyNum+                  , Data.SBV.Compilers.C+                  , Data.SBV.Compilers.CodeGen+                  , Data.SBV.SMT.SMT+                  , Data.SBV.SMT.SMTLib+                  , Data.SBV.Provers.Prover+                  , Data.SBV.Provers.SExpr+                  , Data.SBV.Provers.Yices+                  , Data.SBV.Utils.Boolean+                  , Data.SBV.Utils.TDiff+                  , Data.SBV.Utils.SBVTest+                  , Data.SBV.Utils.Lib+                  , Data.SBV.Examples.Arrays.Memory+                  , Data.SBV.Examples.Basics.BasicTests+                  , Data.SBV.Examples.Basics.Higher+                  , Data.SBV.Examples.Basics.Index+                  , Data.SBV.Examples.Basics.ProofTests+                  , Data.SBV.Examples.Basics.QRem+                  , Data.SBV.Examples.CRC.CCITT+                  , Data.SBV.Examples.CRC.CCITT_Unidir+                  , Data.SBV.Examples.CRC.GenPoly+                  , Data.SBV.Examples.CRC.Parity+                  , Data.SBV.Examples.CRC.USB5+                  , Data.SBV.Examples.Puzzles.PowerSet+                  , Data.SBV.Examples.Puzzles.Temperature+                  , Data.SBV.Examples.Uninterpreted.Uninterpreted+                  , Data.SBV.TestSuite.Arrays.Memory+                  , Data.SBV.TestSuite.Basics.Arithmetic+                  , Data.SBV.TestSuite.Basics.BasicTests+                  , Data.SBV.TestSuite.Basics.Higher+                  , Data.SBV.TestSuite.Basics.Index+                  , Data.SBV.TestSuite.Basics.ProofTests+                  , Data.SBV.TestSuite.Basics.QRem+                  , Data.SBV.TestSuite.BitPrecise.BitTricks+                  , Data.SBV.TestSuite.BitPrecise.Legato+                  , Data.SBV.TestSuite.CodeGeneration.AddSub+                  , Data.SBV.TestSuite.CodeGeneration.CgTests+                  , Data.SBV.TestSuite.CodeGeneration.Fibonacci+                  , Data.SBV.TestSuite.CodeGeneration.GCD+                  , Data.SBV.TestSuite.CodeGeneration.PopulationCount+                  , Data.SBV.TestSuite.Crypto.AES+                  , Data.SBV.TestSuite.CRC.CCITT+                  , Data.SBV.TestSuite.CRC.CCITT_Unidir+                  , Data.SBV.TestSuite.CRC.GenPoly+                  , Data.SBV.TestSuite.CRC.Parity+                  , Data.SBV.TestSuite.CRC.USB5+                  , Data.SBV.TestSuite.PrefixSum.PrefixSum+                  , Data.SBV.TestSuite.Polynomials.Polynomials+                  , Data.SBV.TestSuite.Puzzles.DogCatMouse+                  , Data.SBV.TestSuite.Puzzles.Euler185+                  , Data.SBV.TestSuite.Puzzles.MagicSquare+                  , Data.SBV.TestSuite.Puzzles.NQueens+                  , Data.SBV.TestSuite.Puzzles.PowerSet+                  , Data.SBV.TestSuite.Puzzles.Sudoku+                  , Data.SBV.TestSuite.Puzzles.U2Bridge+                  , Data.SBV.TestSuite.Puzzles.Temperature+                  , Data.SBV.TestSuite.Uninterpreted.AUF+                  , Data.SBV.TestSuite.Uninterpreted.Uninterpreted+                  , Data.SBV.TestSuite.Uninterpreted.Function++Executable SBVUnitTests+  main-is         : SBVUnitTest/SBVUnitTest.hs